Sponsored
MoonPay
Buy crypto with our non-custodial and fully decentralised platform. Buy Now!
15M+ users trust MoonPay. Checkout with your preferred payment method.
MetaMask
Manage your web3 everything with MetaMask Portfolio. Try Now!
Ready to onboard to Ethereum? With MetaMask Portfolio, you're in control.
Nexo
Join the hunt for $12,000,000+ in NEXO Tokens. Get Nexo
Collect points for eligible actions and use multipliers to win big.
Sponsored
MetaMask
Meet MetaMask Portfolio - your key to getting more out of web3. Try Now
Ready to simplify your web3 experience? Try the all-in-one web3 app trusted by millions worldwide.
CEX.IO
Claim Your Mystery Box For A Guaranteed Crypto Prize CLAIM NOW
Opt-in, make your first trade on Exchange Plus & receive random crypto rewards from 10,000 SHIB, to 0.01 BTC.
Zeedex
Earn $Zdex with each swap. Join Now
You will earn $Zdex as rewards by any trade or stake on ZeeDex exchange.
Sponsored
Сoins.game
100 free spins for registration. Spin now!
Everyday giveaways up to 100 ETH, Lucky Spins. Deposit BONUS 300% and Cashbacks!
MegaDice.com
-No KYC casino, Deposit Any Crypto, 200% up-to 1BTC Bonus. Play Now!
Play all your favorite Slots & Live Games, including Plinko, Aviator and Crash! Truly anonymous casino.
BC.GAME
- The Best ETH Casino Claim Now!
5000+ Slots & Live Casino Games, 50+cryptos. Register with Etherscan and get 760% deposit bonus. Win Big$, withdraw it fast.
Sponsored
BC.GAME
- The Best ETH Casino Claim Now!
5000+ Slots & Live Casino Games, 50+cryptos. Register with Etherscan and get 760% deposit bonus. Win Big$, withdraw it fast.
CryptoWins
200% Welcome Bonus – Supercharge Your Crypto Up to 4 BTC! Claim Now!
Play 100s of games anonymously with all major cryptos. Join CryptoWins & start winning!
CryptoSlots
Play & Get 25 Free Spins at CryptoSlots Play Now
Anonymous play on awesome games - sign up now for 25 free jackpot spins - worth $100s!
ERC-20
Add Token to MetaMask (Web3)Overview
Max Total Supply
2,413.534059588845130773 GBR
Holders
180
Market
Onchain Market Cap
$0.00
Circulating Supply Market Cap
-
Other Info
Token Contract (WITH 18 Decimals)
Balance
0.003359983592266403 GBRValue
$0.00Loading...
Loading
Loading...
Loading
Loading...
Loading
| # | Exchange | Pair | Price | 24H Volume | % Volume |
|---|
Contract Name:
Goober
Compiler Version
v0.8.17+commit.8df45f5f
Optimization Enabled:
Yes with 2000000 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity Standard Json-Input format)
// 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: 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;
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; /// @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;
}
}// 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: AGPL-3.0-only
pragma solidity >=0.8.0;
/// @notice Gas optimized reentrancy protection for smart contracts.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/ReentrancyGuard.sol)
/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol)
abstract contract ReentrancyGuard {
uint256 private locked = 1;
modifier nonReentrant() virtual {
require(locked == 1, "REENTRANCY");
locked = 2;
_;
locked = 1;
}
}// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity >=0.8.0;
import {ERC20} from "../tokens/ERC20.sol";
/// @notice Safe ETH and ERC20 transfer library that gracefully handles missing return values.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/SafeTransferLib.sol)
/// @dev Use with caution! Some functions in this library knowingly create dirty bits at the destination of the free memory pointer.
/// @dev Note that none of the functions in this library check that a token has code at all! That responsibility is delegated to the caller.
library SafeTransferLib {
/*//////////////////////////////////////////////////////////////
ETH OPERATIONS
//////////////////////////////////////////////////////////////*/
function safeTransferETH(address to, uint256 amount) internal {
bool success;
/// @solidity memory-safe-assembly
assembly {
// Transfer the ETH and store if it succeeded or not.
success := call(gas(), to, amount, 0, 0, 0, 0)
}
require(success, "ETH_TRANSFER_FAILED");
}
/*//////////////////////////////////////////////////////////////
ERC20 OPERATIONS
//////////////////////////////////////////////////////////////*/
function safeTransferFrom(
ERC20 token,
address from,
address to,
uint256 amount
) internal {
bool success;
/// @solidity memory-safe-assembly
assembly {
// Get a pointer to some free memory.
let freeMemoryPointer := mload(0x40)
// Write the abi-encoded calldata into memory, beginning with the function selector.
mstore(freeMemoryPointer, 0x23b872dd00000000000000000000000000000000000000000000000000000000)
mstore(add(freeMemoryPointer, 4), from) // Append the "from" argument.
mstore(add(freeMemoryPointer, 36), to) // Append the "to" argument.
mstore(add(freeMemoryPointer, 68), amount) // Append the "amount" argument.
success := and(
// Set success to whether the call reverted, if not we check it either
// returned exactly 1 (can't just be non-zero data), or had no return data.
or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())),
// We use 100 because the length of our calldata totals up like so: 4 + 32 * 3.
// We use 0 and 32 to copy up to 32 bytes of return data into the scratch space.
// Counterintuitively, this call must be positioned second to the or() call in the
// surrounding and() call or else returndatasize() will be zero during the computation.
call(gas(), token, 0, freeMemoryPointer, 100, 0, 32)
)
}
require(success, "TRANSFER_FROM_FAILED");
}
function safeTransfer(
ERC20 token,
address to,
uint256 amount
) internal {
bool success;
/// @solidity memory-safe-assembly
assembly {
// Get a pointer to some free memory.
let freeMemoryPointer := mload(0x40)
// Write the abi-encoded calldata into memory, beginning with the function selector.
mstore(freeMemoryPointer, 0xa9059cbb00000000000000000000000000000000000000000000000000000000)
mstore(add(freeMemoryPointer, 4), to) // Append the "to" argument.
mstore(add(freeMemoryPointer, 36), amount) // Append the "amount" argument.
success := and(
// Set success to whether the call reverted, if not we check it either
// returned exactly 1 (can't just be non-zero data), or had no return data.
or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())),
// We use 68 because the length of our calldata totals up like so: 4 + 32 * 2.
// We use 0 and 32 to copy up to 32 bytes of return data into the scratch space.
// Counterintuitively, this call must be positioned second to the or() call in the
// surrounding and() call or else returndatasize() will be zero during the computation.
call(gas(), token, 0, freeMemoryPointer, 68, 0, 32)
)
}
require(success, "TRANSFER_FAILED");
}
function safeApprove(
ERC20 token,
address to,
uint256 amount
) internal {
bool success;
/// @solidity memory-safe-assembly
assembly {
// Get a pointer to some free memory.
let freeMemoryPointer := mload(0x40)
// Write the abi-encoded calldata into memory, beginning with the function selector.
mstore(freeMemoryPointer, 0x095ea7b300000000000000000000000000000000000000000000000000000000)
mstore(add(freeMemoryPointer, 4), to) // Append the "to" argument.
mstore(add(freeMemoryPointer, 36), amount) // Append the "amount" argument.
success := and(
// Set success to whether the call reverted, if not we check it either
// returned exactly 1 (can't just be non-zero data), or had no return data.
or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())),
// We use 68 because the length of our calldata totals up like so: 4 + 32 * 2.
// We use 0 and 32 to copy up to 32 bytes of return data into the scratch space.
// Counterintuitively, this call must be positioned second to the or() call in the
// surrounding and() call or else returndatasize() will be zero during the computation.
call(gas(), token, 0, freeMemoryPointer, 68, 0, 32)
)
}
require(success, "APPROVE_FAILED");
}
}// 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.17;
import "art-gobblers/Goo.sol";
import "art-gobblers/ArtGobblers.sol";
import {ERC20} from "solmate/tokens/ERC20.sol";
import {SafeTransferLib} from "solmate/utils/SafeTransferLib.sol";
import {ReentrancyGuard} from "solmate/utils/ReentrancyGuard.sol";
import {FixedPointMathLib} from "solmate/utils/FixedPointMathLib.sol";
import "./interfaces/IERC20Metadata.sol";
import "./math/UQ112x112.sol";
import "./interfaces/IGoober.sol";
import "./interfaces/IGooberCallee.sol";
/// @title goober_xyz
/// @author 0xAlcibiades
/// @author mevbandit
/// @author neodaoist
/// @author eth_call
/// @author goerlibot
/// @author thal0x
/// @notice Goober is an experimental Uniswap V2 and EIP-4626 flavored vault to optimize Art
/// @notice production for the decentralized art factory by Justin Roiland and Paradigm.
contract Goober is ReentrancyGuard, ERC20, IGoober {
// We want to ensure all transfers are safe.
using SafeTransferLib for Goo;
using SafeTransferLib for ERC20;
// We use this for fixed point WAD scalar math.
using FixedPointMathLib for uint256;
// This is the Uniswap V2 112 bit Q math, updated for Solidity 8.
using UQ112x112 for uint224;
/*//////////////////////////////////////////////////////////////
// Immutable storage
//////////////////////////////////////////////////////////////*/
/// @notice The Goo contract.
Goo public immutable goo;
/// @notice The Art Gobblers NFT contract.
ArtGobblers public immutable artGobblers;
/// @notice The liquidity locked forever in the pool.
uint16 private constant MINIMUM_LIQUIDITY = 1e3;
/// @notice A scalar for scaling up and down to basis points.
uint16 private constant BPS_SCALAR = 1e4;
/// @notice The management fee in basis points, charged on deposits.
uint16 public constant MANAGEMENT_FEE_BPS = 200;
/// @notice The performance fee in basis points, taken in the form
/// @notice of dilution on the growth of sqrt(gooBalance * gobblerMult),
/// @notice
uint16 public constant PERFORMANCE_FEE_BPS = 1e3;
/// @notice The average multiplier of a newly minted gobbler.
/// @notice 7.3294 = weighted avg. multiplier from mint probabilities,
/// @notice derived from: ((6*3057) + (7*2621) + (8*2293) + (9*2029)) / 10000.
uint32 private constant AVERAGE_MULT_BPS = 73294;
/*//////////////////////////////////////////////////////////////
// Mutable storage
//////////////////////////////////////////////////////////////*/
// Access control
/// @notice This is the "admin" address and also where management and performance fees accrue.
address public feeTo;
/// @notice This is a privileged actor with the ability to mint gobblers when the pool price is low enough.
address public minter;
/// @notice Price oracle accumulator for goo.
uint256 public priceGooCumulativeLast;
/// @notice Price oracle accumulator for gobbler multipliers.
uint256 public priceGobblerCumulativeLast;
/// @notice K, as of immediately after the most recent liquidity event.
uint112 public kLast;
/// @notice A counter for debt accrued against performance fees during the temporary decreases in K
/// @notice after mints by the minter, before gobblers' multipliers are revealed.
uint112 public kDebt;
/// @notice Last block timestamp
/// @dev Yes, the oracle accumulators will reset in 2036.
uint32 public blockTimestampLast; // uses single storage slot, accessible via getReserves
/// @notice Flagged NFTs cannot be deposited or swapped in.
mapping(uint256 => bool) public flagged;
/*//////////////////////////////////////////////////////////////
// Constructor
//////////////////////////////////////////////////////////////*/
/// @notice Deploys the goober contract.
/// @param _gobblersAddress - The address of the Art Gobblers contract.
/// @param _gooAddress - The address of the Goo contract/token.
/// @param _feeTo - The admin and address to accrue fees to.
/// @param _minter - The address able to mint gobblers to the pool.
/// @notice The minter is able to mint using pool assets based on conditions defined in the mintGobbler function.
constructor(address _gobblersAddress, address _gooAddress, address _feeTo, address _minter)
ERC20("Goober", "GBR", 18)
{
feeTo = _feeTo;
minter = _minter;
artGobblers = ArtGobblers(_gobblersAddress);
goo = Goo(_gooAddress);
}
/*//////////////////////////////////////////////////////////////
// Modifiers
//////////////////////////////////////////////////////////////*/
/// @notice This modifier restricts function access to the feeTo address.
modifier onlyFeeTo() {
if (msg.sender != feeTo) {
revert AccessControlViolation(msg.sender, feeTo);
}
_;
}
/// @notice This modifier restricts function access to the minter address.
modifier onlyMinter() {
if (msg.sender != minter) {
revert AccessControlViolation(msg.sender, minter);
}
_;
}
/// @notice This modifier ensures the transaction is included before a specified deadline.
/// @param deadline - Unix timestamp after which the transaction will revert.
modifier ensure(uint256 deadline) {
if (block.timestamp > deadline) {
revert Expired(block.timestamp, deadline);
}
_;
}
/*//////////////////////////////////////////////////////////////
// Internal: Non-Mutating
//////////////////////////////////////////////////////////////*/
/// @notice Calculates it is within the interest of our pool to mint more Gobblers
/// @notice based on current pool and auction conditions.
function _shouldMint(uint256 _gooBalance, uint256 _gobblerBalance, uint256 _auctionPrice)
internal
pure
returns (bool mint, uint256 auctionPricePerMult, uint256 poolPricePerMult)
{
if (_gooBalance == 0 || _gobblerBalance == 0) {
revert InsufficientLiquidity(_gooBalance, _gobblerBalance);
} else if (_auctionPrice == 0) {
// Unlikely, but avoids divide by zero below.
mint = true;
} else {
if (_gooBalance > _auctionPrice) {
auctionPricePerMult = (_auctionPrice * BPS_SCALAR) / AVERAGE_MULT_BPS;
poolPricePerMult = (_gooBalance / _gobblerBalance);
mint = poolPricePerMult > auctionPricePerMult;
}
}
}
/// @dev Internal swap calculations from Uniswap V2 modified to return an integer error term.
function _swapCalculations(
uint256 _gooReserve,
uint256 _gobblerReserve,
uint256 _gooBalance,
uint256 _gobblerBalance,
uint256 gooOut,
uint256 multOut,
bool revertInsufficient
) internal pure returns (int256 erroneousGoo, uint256 amount0In, uint256 amount1In) {
erroneousGoo = 0;
amount0In = _gooBalance > _gooReserve - gooOut ? _gooBalance - (_gooReserve - gooOut) : 0;
amount1In = _gobblerBalance > _gobblerReserve - multOut ? _gobblerBalance - (_gobblerReserve - multOut) : 0;
if (!(amount0In > 0 || amount1In > 0)) {
revert InsufficientInputAmount(amount0In, amount1In);
}
{
uint256 balance0Adjusted = (_gooBalance * 1000) - (amount0In * 3);
uint256 balance1Adjusted = (_gobblerBalance * 1000) - (amount1In * 3);
uint256 adjustedBalanceK = ((balance0Adjusted * balance1Adjusted));
uint256 expectedK = ((_gooReserve * _gobblerReserve) * 1000 ** 2);
if (adjustedBalanceK < expectedK) {
uint256 error = FixedPointMathLib.mulWadUp(
FixedPointMathLib.divWadUp(
(
FixedPointMathLib.mulWadUp(FixedPointMathLib.divWadUp(expectedK, balance1Adjusted), 1)
- balance0Adjusted
),
997
),
1
);
if (revertInsufficient) {
revert InsufficientGoo(error, adjustedBalanceK, expectedK);
}
erroneousGoo += int256(error);
} else if (adjustedBalanceK > expectedK) {
erroneousGoo -= int256(
FixedPointMathLib.mulWadDown(
FixedPointMathLib.divWadDown(
(
balance0Adjusted
- FixedPointMathLib.mulWadUp(FixedPointMathLib.divWadUp(expectedK, balance1Adjusted), 1)
),
1000
),
1
)
);
}
// Otherwise return 0.
}
}
/// @notice Returns various calculations about the value of K.
function _kCalculations(uint256 _gooBalance, uint256 _gobblerBalance, uint256 _kLast, uint256 _kDebt, bool _roundUp)
internal
pure
returns (uint256 _k, uint256 _kChange, bool _kChangeSign, uint256 _kDelta, uint256 _kDebtChange)
{
// Get the present value of K.
_k = FixedPointMathLib.sqrt(_gooBalance * _gobblerBalance);
// We don't want to allow the pool to be decommed, ever.
if (_k == 0) {
revert MustLeaveLiquidity(_gooBalance, _gobblerBalance);
}
// Set delta and debt change to zero.
_kDelta = 0;
_kDebtChange = 0;
// Did K increase or decrease?
_kChangeSign = _k > _kLast;
// Get the gross change in K as a numeric.
_kChange = _kChangeSign ? _k - _kLast : _kLast - _k;
// We can't do change math on a fresh pool.
if (_kLast > 0) {
// If K went up,
if (_kChangeSign) {
// let's offset the debt first if it exists;
if (_kDebt > 0) {
if (_kChange <= _kDebt) {
_kDebtChange += _kChange;
_kChange = 0;
} else {
_kDebtChange += _kDebt;
_kChange -= _kDebt;
}
}
}
// then we can calculate the delta.
if (_roundUp) {
_kDelta = FixedPointMathLib.divWadUp(_kChange, _kLast);
} else {
_kDelta = FixedPointMathLib.divWadDown(_kChange, _kLast);
}
} else {
// If kLast -> k is 0 -> n, then the delta is 100%.
_kDelta = FixedPointMathLib.divWadUp(1, 1);
}
}
/// @notice Returns the management fee given an amount of new fractions created on deposit.
/// @param fractions New fractions issued for a deposit.
function _previewManagementFee(uint256 fractions) internal pure returns (uint256 fee) {
fee = fractions * MANAGEMENT_FEE_BPS / BPS_SCALAR;
}
/// @notice Returns a preview of the performance fee.
/// @param _gooBalance - The Goo balance to simulate with.
/// @param _gobblerBalance - The Gobbler balance to simulate with.
function _previewPerformanceFee(uint256 _gooBalance, uint256 _gobblerBalance)
internal
view
returns (uint256 fee, uint256 kDebtChange, uint256 kDelta)
{
// No K, no fee.
uint112 _kLast = kLast;
uint112 _kDebt = kDebt;
fee = 0;
kDebtChange = 0;
kDelta = 0;
// If kLast was at 0, then we won't accrue a fee yet, as the pool is uninitialized.
if (_kLast > 0) {
(, uint256 _kChange, bool _kChangeSign, uint256 _kDelta, uint256 _kDebtChange) =
_kCalculations(_gooBalance, _gobblerBalance, _kLast, _kDebt, false);
// Then, determine a fee on any remainder after offsetting outstanding debt.
if (_kChange > 0 && _kChangeSign) {
// Calculate the fee as a portion of the the growth of total supply as determined by kDelta.
fee = FixedPointMathLib.mulWadDown(totalSupply, _kDelta) * PERFORMANCE_FEE_BPS / BPS_SCALAR;
// Update kDelta return value.
kDelta = uint112(_kDelta);
// Update kDebtChange return value.
kDebtChange = uint112(_kDebtChange);
}
}
}
/*//////////////////////////////////////////////////////////////
// Internal: Mutating
//////////////////////////////////////////////////////////////*/
/// @dev Update reserves and, on the first call per block, price accumulators.
/// @param _gooBalance - The new Goo balance.
/// @param _gobblerBalance - The new Gobbler multiplier.
/// @param _gooReserve - The previous Goo reserve.
/// @param _gobblerReserve - The previous Gobbler multiplier.
function _update(
uint256 _gooBalance,
uint256 _gobblerBalance,
uint256 _gooReserve,
uint256 _gobblerReserve,
bool recordDebt,
bool updateK
) internal {
/// @dev The accumulators will reset in 2036 due to modulo.
//slither-disable-next-line weak-prng
uint32 blockTimestamp = uint32(block.timestamp % 2 ** 32);
uint32 timeElapsed;
unchecked {
// The time elapsed since the last update.
timeElapsed = blockTimestamp - blockTimestampLast; // Overflow is desired.
}
// These are accumulators which can be used for a Goo/Gobbler mult TWAP.
(uint112 castGooReserve, uint112 castGobblerReserve) = (uint112(_gooReserve), uint112(_gobblerReserve));
if (timeElapsed > 0 && _gooReserve != 0 && _gobblerReserve != 0) {
unchecked {
// * Never overflows, and + overflow is desired.
priceGooCumulativeLast +=
uint256(UQ112x112.encode(uint112(castGooReserve)).uqdiv(castGobblerReserve)) * timeElapsed;
priceGobblerCumulativeLast +=
uint256(UQ112x112.encode(uint112(castGobblerReserve)).uqdiv(uint112(castGooReserve))) * timeElapsed;
}
}
// Update the last update.
blockTimestampLast = blockTimestamp;
/// @dev We don't store reserves here as they were already stored in other contracts and there was no
// need to duplicate the state changes.
// Do we need to update historic K values?
if (updateK || recordDebt) {
// Get the present K.
uint112 _k = uint112(FixedPointMathLib.sqrt(_gooBalance * _gobblerBalance));
// Read the last K from storage.
uint112 _kLast = kLast;
// If K decreased, record the debt.
if ((_k < _kLast) && recordDebt) {
kDebt += _kLast - _k;
}
if (updateK) {
// Update historic K.
kLast = _k;
}
}
// Emit the reserves which can be used to chart the state of the pool.
emit Sync(_gooBalance, _gobblerBalance);
}
/// @notice Accrues the performance fee on the growth of K if any, offset by kDebt.
/// @param _gooBalance - The balance of Goo to use in calculating the growth of K.
/// @param _gobblerBalanceMult - The balance of Gobbler mult to use in calculating the growth of K.
function _performanceFee(uint256 _gooBalance, uint256 _gobblerBalanceMult) internal returns (uint256) {
(uint256 fee, uint256 kDebtChange, uint256 deltaK) = _previewPerformanceFee(_gooBalance, _gobblerBalanceMult);
if (kDebtChange > 0) {
kDebt -= uint112(kDebtChange);
}
if (fee > 0) {
_mint(feeTo, fee);
// Emit info about the fees, and the growth of K.
emit FeesAccrued(feeTo, fee, true, deltaK);
}
return fee;
}
/// @notice Mints and returns the management fee given an amount of new fractions created on deposit.
/// @param fractions - New fractions created for a deposit.
/// @return fee - The managment fee assesed.
function _managementFee(uint256 fractions) internal returns (uint256 fee) {
fee = _previewManagementFee(fractions);
_mint(feeTo, fee);
// _deltaK is 0 here because there isn't actually growth in K.
emit FeesAccrued(feeTo, fee, false, 0);
}
/*//////////////////////////////////////////////////////////////
// External: Non Mutating
//////////////////////////////////////////////////////////////*/
/// @inheritdoc IERC721Receiver
/// @notice Handles deposits of Art Gobblers with an on receive hook, verifying characteristics.
/// @dev We don't accept non Art Gobbler NFTs, flagged Gobblers, or unrevealed Gobblers.
function onERC721Received(address, address, uint256 tokenId, bytes calldata) external view returns (bytes4) {
/// @dev We only want Art Gobblers NFTs.
if (msg.sender != address(artGobblers)) {
revert InvalidNFT();
}
/// @dev Revert on flagged NFTs.
if (flagged[tokenId] == true) {
revert InvalidNFT();
}
/// @dev We want to make sure the Gobblers we are getting are revealed.
uint256 gobMult = artGobblers.getGobblerEmissionMultiple(tokenId);
if (gobMult < 6) {
revert InvalidMultiplier(tokenId);
}
return IERC721Receiver.onERC721Received.selector;
}
/// @inheritdoc IGoober
function totalAssets() public view returns (uint256 gooTokens, uint256 gobblerMult) {
gooTokens = artGobblers.gooBalance(address(this));
gobblerMult = artGobblers.getUserEmissionMultiple(address(this));
}
/// @inheritdoc IGoober
function convertToFractions(uint256 gooTokens, uint256 gobblerMult) external view returns (uint256 fractions) {
uint256 _totalSupply = totalSupply;
uint256 kInput = FixedPointMathLib.sqrt(gooTokens * gobblerMult);
if (_totalSupply > 0) {
(uint256 gooBalance, uint256 gobblerMultBalance) = totalAssets();
uint256 kBalance = FixedPointMathLib.sqrt(gooBalance * gobblerMultBalance);
uint256 kDelta = FixedPointMathLib.divWadDown(kInput, kBalance);
fractions = FixedPointMathLib.mulWadDown(_totalSupply, kDelta);
} else {
fractions = kInput;
}
}
/// @inheritdoc IGoober
function convertToAssets(uint256 fractions)
external
view
virtual
returns (uint256 gooTokens, uint256 gobblerMult)
{
gooTokens = 0;
gobblerMult = 0;
uint256 _totalSupply = totalSupply;
if (_totalSupply > 0) {
(gooTokens, gobblerMult) = totalAssets();
gooTokens = fractions.mulDivDown(gooTokens, _totalSupply);
gobblerMult = fractions.mulDivDown(gobblerMult, _totalSupply);
}
}
/// @inheritdoc IGoober
function getReserves()
public
view
returns (uint256 _gooReserve, uint256 _gobblerReserve, uint32 _blockTimestampLast)
{
_gooReserve = artGobblers.gooBalance(address(this));
_gobblerReserve = artGobblers.getUserEmissionMultiple(address(this));
_blockTimestampLast = blockTimestampLast;
}
/// @inheritdoc IGoober
function previewDeposit(uint256[] calldata gobblers, uint256 gooTokens) external view returns (uint256 fractions) {
// Collect a virtual performance fee.
(uint256 _gooReserve, uint256 _gobblerReserveMult,) = getReserves();
(uint256 pFee,,) = _previewPerformanceFee(_gooReserve, _gobblerReserveMult);
// Increment virtual total supply by performance fee.
uint256 _totalSupply = pFee + totalSupply;
// Simulate transfers.
uint256 _gooBalance = gooTokens + _gooReserve;
uint256 _gobblerBalanceMult = _gobblerReserveMult;
for (uint256 i = 0; i < gobblers.length; i++) {
_gobblerBalanceMult += artGobblers.getGobblerEmissionMultiple(gobblers[i]);
}
// Calculate the fractions to create based on the changes in K.
(uint256 _k,,, uint256 _kDelta,) = _kCalculations(
_gooBalance, _gobblerBalanceMult, FixedPointMathLib.sqrt(_gooReserve * _gobblerReserveMult), 0, true
);
if (_totalSupply == 0) {
// We want to start the fractions at the right order of magnitude at init, so
// we scale this by 1e9 to simulate 2 ERC20s, because Gobbler mult are integers
// rather than 1e18 ERC20s from the Uni V2 design.
fractions = _k * 1e9 - MINIMUM_LIQUIDITY;
} else {
fractions = FixedPointMathLib.mulWadDown(_totalSupply, _kDelta);
}
if (fractions == 0) {
revert InsufficientLiquidityDeposited();
}
// Simulate management fee and return preview.
fractions -= _previewManagementFee(fractions);
}
/// @inheritdoc IGoober
function previewWithdraw(uint256[] calldata gobblers, uint256 gooTokens)
external
view
returns (uint256 fractions)
{
// Collect a virtual performance fee.
(uint256 _gooReserve, uint256 _gobblerReserveMult,) = getReserves();
uint256 _totalSupply = totalSupply;
(uint256 pFee,,) = _previewPerformanceFee(_gooReserve, _gobblerReserveMult);
// Increment virtual total supply.
_totalSupply += pFee;
// Simulate transfers.
uint256 _gooBalance = _gooReserve - gooTokens;
uint256 _gobblerBalanceMult = _gobblerReserveMult;
uint256 gobblerMult;
for (uint256 i = 0; i < gobblers.length; i++) {
if (artGobblers.ownerOf(gobblers[i]) != address(this)) {
revert InvalidNFT();
}
gobblerMult = artGobblers.getGobblerEmissionMultiple(gobblers[i]);
if (gobblerMult < 6) {
revert InvalidMultiplier(gobblers[i]);
}
_gobblerBalanceMult -= gobblerMult;
}
uint256 _gobblerAmountMult = _gobblerReserveMult - _gobblerBalanceMult;
if (!(_gobblerAmountMult > 0 || gooTokens > 0)) {
revert InsufficientLiquidityWithdrawn();
}
{
// Calculate the fractions which will be destroyed based on the changes in K.
(,,, uint256 _kDelta,) = _kCalculations(
_gooBalance, _gobblerBalanceMult, FixedPointMathLib.sqrt(_gooReserve * _gobblerReserveMult), 0, true
);
// Update fractions for return.
fractions = FixedPointMathLib.mulWadUp(_totalSupply, _kDelta);
}
}
/// @inheritdoc IGoober
function previewSwap(uint256[] calldata gobblersIn, uint256 gooIn, uint256[] calldata gobblersOut, uint256 gooOut)
public
view
returns (int256 erroneousGoo)
{
(uint256 _gooReserve, uint256 _gobblerReserve,) = getReserves();
// Simulate the transfers out.
uint256 _gooBalance = _gooReserve - gooOut;
uint256 _gobblerBalance = _gobblerReserve;
uint256 multOut = 0;
uint256 gobblerMult;
for (uint256 i = 0; i < gobblersOut.length; i++) {
if (artGobblers.ownerOf(gobblersOut[i]) != address(this)) {
revert InvalidNFT();
}
gobblerMult = artGobblers.getGobblerEmissionMultiple(gobblersOut[i]);
if (gobblerMult < 6) {
revert InvalidMultiplier(gobblersOut[i]);
}
_gobblerBalance -= gobblerMult;
multOut += gobblerMult;
}
// Simulate the transfers in.
_gooBalance += gooIn;
for (uint256 i = 0; i < gobblersIn.length; i++) {
gobblerMult = artGobblers.getGobblerEmissionMultiple(gobblersIn[i]);
if (gobblerMult < 6) {
revert InvalidMultiplier(gobblersIn[i]);
}
_gobblerBalance += gobblerMult;
}
// Run swap calculations and return error term.
(erroneousGoo,,) =
_swapCalculations(_gooReserve, _gobblerReserve, _gooBalance, _gobblerBalance, gooOut, multOut, false);
}
/*//////////////////////////////////////////////////////////////
// External: Mutating, Restricted Access
//////////////////////////////////////////////////////////////*/
// Access Control
/// @inheritdoc IGoober
function setFeeTo(address newFeeTo) external onlyFeeTo {
if (newFeeTo == address(0)) {
revert InvalidAddress(newFeeTo);
}
feeTo = newFeeTo;
}
/// @inheritdoc IGoober
function setMinter(address newMinter) external onlyFeeTo {
if (newMinter == address(0)) {
revert InvalidAddress(newMinter);
}
minter = newMinter;
}
// Other Privileged Functions
/// @inheritdoc IGoober
function mintGobbler() external nonReentrant onlyMinter {
/// @dev Restricted to onlyMinter to prevent Goo price manipulation.
/// @dev Non-reentrant in case onlyMinter address/keeper is compromised.
// Get the mint price.
uint256 mintPrice = artGobblers.gobblerPrice();
// Get the reserves directly to save gas.
uint256 gooReserve = artGobblers.gooBalance(address(this));
uint256 gobblerReserve = artGobblers.getUserEmissionMultiple(address(this));
// Set an internal balance counter for Goo.
uint256 gooBalance = gooReserve;
// Should we mint?
(bool mint, uint256 auctionPricePerMult, uint256 poolPricePerMult) =
_shouldMint(gooBalance, gobblerReserve, mintPrice);
// We revert to tell the minter if it's calculations are off.
if (mint == false) {
revert AuctionPriceTooHigh(auctionPricePerMult, poolPricePerMult);
}
// Mint Gobblers to the pool when our Goo per mult > (VRGDA) auction Goo per mult.
while (mint) {
// Mint a new Gobbler.
// slither-disable-next-line unused-return
artGobblers.mintFromGoo(mintPrice, true);
// _shouldMint already prevents an overflow here.
gooBalance -= mintPrice;
// Emit info about the mint for off-chain analysis.
emit VaultMint(msg.sender, auctionPricePerMult, poolPricePerMult, mintPrice);
// Get the new mint price.
mintPrice = artGobblers.gobblerPrice();
// Should we mint again?
(mint, auctionPricePerMult, poolPricePerMult) = _shouldMint(gooBalance, gobblerReserve, mintPrice);
}
// Update accumulators, kLast, kDebt.
_update(gooBalance, gobblerReserve, gooReserve, gobblerReserve, true, true);
}
/// @inheritdoc IGoober
function skim(address erc20) external nonReentrant onlyFeeTo {
/// @dev Contract should never hold ERC20 tokens (only virtual GOO).
uint256 contractBalance = ERC20(erc20).balanceOf(address(this));
//slither-disable-next-line dangerous-strict-equalities
if (contractBalance == 0) {
revert NoSkim();
}
// Transfer the excess goo to the admin for handling.
ERC20(erc20).safeTransfer(msg.sender, contractBalance);
}
/// @inheritdoc IGoober
function flagGobbler(uint256 tokenId, bool _flagged) external onlyFeeTo {
flagged[tokenId] = _flagged;
}
/*//////////////////////////////////////////////////////////////
// External: Mutating, Unrestricted
//////////////////////////////////////////////////////////////*/
/// @inheritdoc IGoober
function deposit(uint256[] calldata gobblers, uint256 gooTokens, address receiver)
public
nonReentrant
returns (uint256 fractions)
{
// Get reserve balances before they are updated from deposit transfers.
(uint256 _gooReserve, uint256 _gobblerReserveMult,) = getReserves();
// Assess performance fee since last transaction.
_performanceFee(_gooReserve, _gobblerReserveMult);
// Transfer goo if any.
if (gooTokens > 0) {
goo.safeTransferFrom(msg.sender, address(this), gooTokens);
artGobblers.addGoo(gooTokens);
}
// Transfer gobblers if any.
for (uint256 i = 0; i < gobblers.length; i++) {
artGobblers.safeTransferFrom(msg.sender, address(this), gobblers[i]);
}
// Get the new reserves after transfers in.
(uint256 _gooBalance, uint256 _gobblerBalanceMult,) = getReserves();
{
// Check the total token supply.
uint256 _totalSupply = totalSupply;
// Calculate issuance.
uint256 _kLast = FixedPointMathLib.sqrt(_gooReserve * _gobblerReserveMult);
// Calculate the fractions to create based on the changes in K.
(uint256 _k,,, uint256 _kDelta,) = _kCalculations(_gooBalance, _gobblerBalanceMult, _kLast, 0, true);
if (_totalSupply == 0) {
// We want to start the fractions at the right order of magnitude at init, so
// we scale this by 1e9 to simulate 2 ERC20s, because Gobbler mult are integers
// rather than 1e18 ERC20s from the Uni V2 design.
fractions = _k * 1e9 - MINIMUM_LIQUIDITY;
} else {
fractions = FixedPointMathLib.mulWadDown(_totalSupply, _kDelta);
}
if (fractions == 0) {
revert InsufficientLiquidityDeposited();
}
}
// Mint fractions less management fee to depositor.
fractions -= _managementFee(fractions);
_mint(receiver, fractions);
// Update kLast and accumulators.
_update(_gooBalance, _gobblerBalanceMult, _gooReserve, _gobblerReserveMult, false, true);
emit Deposit(msg.sender, receiver, gobblers, gooTokens, fractions);
}
/// @inheritdoc IGoober
function safeDeposit(
uint256[] calldata gobblers,
uint256 gooTokens,
address receiver,
uint256 minFractionsOut,
uint256 deadline
) external ensure(deadline) returns (uint256 fractions) {
fractions = deposit(gobblers, gooTokens, receiver);
if (fractions < minFractionsOut) {
revert MintBelowLimit();
}
}
/// @inheritdoc IGoober
function withdraw(uint256[] calldata gobblers, uint256 gooTokens, address receiver, address owner)
public
nonReentrant
returns (uint256 fractions)
{
// Get the starting reserves.
(uint256 _gooReserve, uint256 _gobblerReserveMult,) = getReserves();
(uint256 _gooBalance, uint256 _gobblerBalanceMult) = (_gooReserve, _gobblerReserveMult);
// Assess performance fee since the last update of K.
_performanceFee(_gooReserve, _gobblerReserveMult);
// Optimistically transfer Goo, if any.
if (gooTokens > 0) {
artGobblers.removeGoo(gooTokens);
goo.safeTransfer(receiver, gooTokens);
_gooBalance -= gooTokens;
}
// Optimistically transfer Gobblers, if any.
uint256 gobblerMult;
for (uint256 i = 0; i < gobblers.length; i++) {
gobblerMult = artGobblers.getGobblerEmissionMultiple(gobblers[i]);
if (gobblerMult < 6) {
revert InvalidMultiplier(gobblers[i]);
}
artGobblers.transferFrom(address(this), receiver, gobblers[i]);
_gobblerBalanceMult -= gobblerMult;
}
// Measure the change in Gobbler mult.
uint256 _gobblerAmountMult = _gobblerReserveMult - _gobblerBalanceMult;
if (!(_gobblerAmountMult > 0 || gooTokens > 0)) {
revert InsufficientLiquidityWithdrawn();
}
{
// Calculate the fractions to destroy based on the changes in K.
(,,, uint256 _kDelta,) = _kCalculations(
_gooBalance, _gobblerBalanceMult, FixedPointMathLib.sqrt(_gooReserve * _gobblerReserveMult), 0, true
);
uint256 _totalSupply = totalSupply;
fractions = FixedPointMathLib.mulWadUp(_totalSupply, _kDelta);
}
// If we are withdrawing on behalf of someone else, we need to check that they have approved us to do so.
if (msg.sender != owner) {
uint256 allowed = allowance[owner][msg.sender]; // Saves gas for limited approvals.
// Check that we can withdraw the requested amount of liquidity.
if (allowed < fractions) {
revert InsufficientAllowance();
}
if (allowed != type(uint256).max) allowance[owner][msg.sender] = allowed - fractions;
}
// Destroy the fractions from owner.
_burn(owner, fractions);
// Update the reserves.
_update(_gooBalance, _gobblerBalanceMult, _gooReserve, _gobblerReserveMult, false, true);
emit Withdraw(msg.sender, receiver, owner, gobblers, gooTokens, fractions);
}
/// @inheritdoc IGoober
function safeWithdraw(
uint256[] calldata gobblers,
uint256 gooTokens,
address receiver,
address owner,
uint256 maxFractionsIn,
uint256 deadline
) external ensure(deadline) returns (uint256 fractions) {
fractions = withdraw(gobblers, gooTokens, receiver, owner);
if (fractions > maxFractionsIn) {
revert BurnAboveLimit();
}
}
/// @inheritdoc IGoober
function swap(
uint256[] calldata gobblersIn,
uint256 gooIn,
uint256[] calldata gobblersOut,
uint256 gooOut,
address receiver,
bytes calldata data
) public nonReentrant returns (int256) {
if (!(gooOut > 0 || gobblersOut.length > 0)) {
revert InsufficientOutputAmount(gooOut, gobblersOut.length);
}
if (receiver == address(goo) || receiver == address(artGobblers)) {
revert InvalidReceiver(receiver);
}
// Intermediary struct so that the stack doesn't get too deep.
SwapData memory internalData = SwapData({
gooReserve: 0,
gobblerReserve: 0,
gooBalance: 0,
gobblerBalance: 0,
multOut: 0,
amount0In: 0,
amount1In: 0,
erroneousGoo: 0
});
(internalData.gooReserve, internalData.gobblerReserve,) = getReserves();
// Transfer out.
// Optimistically transfer Goo, if any.
if (gooOut > 0) {
// Will underflow and revert if we don't have enough Goo, by design.
artGobblers.removeGoo(gooOut);
goo.safeTransfer(receiver, gooOut);
}
// Optimistically transfer Gobblers, if any.
if (gobblersOut.length > 0) {
for (uint256 i = 0; i < gobblersOut.length; i++) {
uint256 gobblerMult = artGobblers.getGobblerEmissionMultiple(gobblersOut[i]);
if (gobblerMult < 6) {
revert InvalidMultiplier(gobblersOut[i]);
}
internalData.multOut += gobblerMult;
artGobblers.transferFrom(address(this), receiver, gobblersOut[i]);
}
}
/// @dev Flash loan call out.
/// @dev Unlike Uni V2, we only need to send the data,
/// @dev because token transfers in are pulled below.
if (data.length > 0) IGooberCallee(receiver).gooberCall(data);
// Transfer in.
// Transfer in Goo, if any.
if (gooIn > 0) {
goo.safeTransferFrom(msg.sender, address(this), gooIn);
artGobblers.addGoo(gooIn);
}
// Transfer in Gobblers, if any
for (uint256 i = 0; i < gobblersIn.length; i++) {
artGobblers.safeTransferFrom(msg.sender, address(this), gobblersIn[i]);
}
// Get updated balances.
(internalData.gooBalance, internalData.gobblerBalance,) = getReserves();
// Perform swap computation.
(internalData.erroneousGoo, internalData.amount0In, internalData.amount1In) = _swapCalculations(
internalData.gooReserve,
internalData.gobblerReserve,
internalData.gooBalance,
internalData.gobblerBalance,
gooOut,
internalData.multOut,
true
);
// Update oracle.
_update(
internalData.gooBalance,
internalData.gobblerBalance,
internalData.gooReserve,
internalData.gobblerReserve,
false,
false
);
emit Swap(msg.sender, receiver, internalData.amount0In, internalData.amount1In, gooOut, internalData.multOut);
return internalData.erroneousGoo;
}
/// @inheritdoc IGoober
function safeSwap(
uint256 erroneousGooAbs,
uint256 deadline,
uint256[] calldata gobblersIn,
uint256 gooIn,
uint256[] calldata gobblersOut,
uint256 gooOut,
address receiver,
bytes calldata data
) external ensure(deadline) returns (int256 erroneousGoo) {
erroneousGoo = previewSwap(gobblersIn, gooIn, gobblersOut, gooOut);
if (erroneousGoo < 0) {
uint256 additionalGooOut = uint256(-erroneousGoo);
if (additionalGooOut > erroneousGooAbs) {
revert ExcessiveErroneousGoo(additionalGooOut, erroneousGooAbs);
}
gooOut += additionalGooOut;
} else if (erroneousGoo > 0) {
uint256 additionalGooIn = uint256(erroneousGoo);
if (additionalGooIn > erroneousGooAbs) {
revert ExcessiveErroneousGoo(additionalGooIn, erroneousGooAbs);
}
gooIn += additionalGooIn;
}
erroneousGoo = swap(gobblersIn, gooIn, gobblersOut, gooOut, receiver, data);
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `from` to `to` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./IERC20.sol";
/**
* @dev Interface for the optional metadata functions from the ERC20 standard.
*
* _Available since v4.1._
*/
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;
/**
* @title ERC721 token receiver interface
* @dev Interface for any contract that wants to support safeTransfers
* from ERC721 asset contracts.
*/
interface IERC721Receiver {
/**
* @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
* by `operator` from `from`, this function is called.
*
* It must return its Solidity selector to confirm the token transfer.
* If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
*
* The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
*/
function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data)
external
returns (bytes4);
}// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;
import "./IERC20Metadata.sol";
import "./IERC721Receiver.sol";
interface IGoober is IERC721Receiver {
// Errors
// Balance Errors
error InsufficientAllowance();
error InsufficientGoo(uint256 amount, uint256 actualK, uint256 expectedK);
// Deposit Errors
error InsufficientLiquidityDeposited();
error MintBelowLimit();
// K Calculation Errors
error MustLeaveLiquidity(uint256 gooBalance, uint256 gobblerBalance);
// Mint Errors
error AuctionPriceTooHigh(uint256 auctionPrice, uint256 poolPrice);
error InsufficientLiquidity(uint256 gooBalance, uint256 gobblerBalance);
error MintFailed();
// NFT Errors
error InvalidNFT();
error InvalidMultiplier(uint256 gobblerId);
// Skim Errors
error NoSkim();
// Swap Errors
error InsufficientInputAmount(uint256 amount0In, uint256 amount1In);
error InsufficientOutputAmount(uint256 gooOut, uint256 gobblersOut);
error InvalidReceiver(address receiver);
error ExcessiveErroneousGoo(uint256 actualErroneousGoo, uint256 allowedErroneousGoo);
// Time Errors
error Expired(uint256 time, uint256 deadline);
// Withdraw Errors
error InsufficientLiquidityWithdrawn();
error BurnAboveLimit();
/**
* @notice The caller doesn't have permission to access the function.
* @param accessor The requesting address.
* @param permissioned The address which has the requisite permissions.
*/
error AccessControlViolation(address accessor, address permissioned);
/**
* @notice Invalid feeTo address.
* @param feeTo the feeTo address.
*/
error InvalidAddress(address feeTo);
// Structs
/// @dev Intermediary struct for swap calculation.
struct SwapData {
uint256 gooReserve;
uint256 gobblerReserve;
uint256 gooBalance;
uint256 gobblerBalance;
uint256 multOut;
uint256 amount0In;
uint256 amount1In;
int256 erroneousGoo;
}
// Events
event VaultMint(address indexed minter, uint256 auctionPricePerMult, uint256 poolPricePerMult, uint256 gooConsumed);
event Deposit(
address indexed caller, address indexed receiver, uint256[] gobblers, uint256 gooTokens, uint256 fractions
);
event Withdraw(
address indexed caller,
address indexed receiver,
address indexed owner,
uint256[] gobblers,
uint256 gooTokens,
uint256 fractions
);
event FeesAccrued(address indexed feeTo, uint256 fractions, bool performanceFee, uint256 _deltaK);
event Swap(
address indexed caller,
address indexed receiver,
uint256 gooTokensIn,
uint256 gobblersMultIn,
uint256 gooTokensOut,
uint256 gobblerMultOut
);
event Sync(uint256 gooBalance, uint256 multBalance);
/*//////////////////////////////////////////////////////////////
// External: Non Mutating
//////////////////////////////////////////////////////////////*/
/// @return gooTokens The total amount of Goo owned.
/// @return gobblerMult The total multiple of all Gobblers owned.
function totalAssets() external view returns (uint256 gooTokens, uint256 gobblerMult);
/// @param gooTokens - The amount of Goo to simulate.
/// @param gobblerMult - The amount of Gobbler mult in to simulate.
/// @return fractions - The fractions, without any fees assessed, which would be returned for a deposit.
function convertToFractions(uint256 gooTokens, uint256 gobblerMult) external view returns (uint256 fractions);
/// @param fractions The amount of fractions to simulate converting.
/// @param gooTokens - The amount of Goo out.
/// @param gobblerMult - The amount of Gobbler mult out.
function convertToAssets(uint256 fractions) external view returns (uint256 gooTokens, uint256 gobblerMult);
/// @notice Gets the vault reserves of Goo and Gobbler mult, along with the last update time.
/// @dev This can be used to calculate slippage on a swap of certain sizes
/// @dev using Uni V2 style liquidity math.
/// @return _gooReserve - The amount of Goo in the tank for the pool.
/// @return _gobblerReserve - The total multiplier of all Gobblers in the pool.
/// @return _blockTimestampLast - The last time that the oracles were updated.
function getReserves()
external
view
returns (uint256 _gooReserve, uint256 _gobblerReserve, uint32 _blockTimestampLast);
/// @notice Previews a deposit of the supplied Gobblers and Goo.
/// @param gobblers - Array of Gobbler ids.
/// @param gooTokens - Amount of Goo to deposit.
/// @return fractions - Amount of fractions created.
function previewDeposit(uint256[] calldata gobblers, uint256 gooTokens) external view returns (uint256 fractions);
/// @notice Previews a withdraw of the requested Gobblers and Goo tokens from the vault.
/// @param gobblers - Array of Gobbler ids.
/// @param gooTokens - Amount of Goo to withdraw.
/// @return fractions - Amount of fractions withdrawn.
function previewWithdraw(uint256[] calldata gobblers, uint256 gooTokens)
external
view
returns (uint256 fractions);
/// @notice Simulates a swap.
/// @param gobblersIn - Array of Gobbler ids to swap in.
/// @param gooIn - Amount of Goo to swap in.
/// @param gobblersOut - Array of Gobbler ids to swap out.
/// @param gooOut - Amount of Goo to swap out.
/// @return erroneousGoo - The amount in wei by which to increase or decrease gooIn/Out to balance the swap.
function previewSwap(uint256[] calldata gobblersIn, uint256 gooIn, uint256[] calldata gobblersOut, uint256 gooOut)
external
view
returns (int256 erroneousGoo);
/*//////////////////////////////////////////////////////////////
// External: Mutating, Restricted Access
//////////////////////////////////////////////////////////////*/
// Access Control
/**
* @notice Updates the address that fees are sent to.
* @param newFeeTo The new address to which fees will be sent.
*/
function setFeeTo(address newFeeTo) external;
/**
* @notice Updates the address that can call mintGobbler.
* @param newMinter The new address to which will be able to call mintGobbler.
*/
function setMinter(address newMinter) external;
// Other Privileged Functions
/// @notice Mints Gobblers using the pool's virtual reserves of Goo
/// @notice when specific conditions are met.
function mintGobbler() external;
/// @notice Restricted function for skimming any ERC20s that may have been erroneously sent to the pool.
function skim(address erc20) external;
/// @notice Restricted function for blocking/unblocking compromised Gobblers from the pool.
function flagGobbler(uint256 tokenId, bool _flagged) external;
/*//////////////////////////////////////////////////////////////
// External: Mutating, Unrestricted
//////////////////////////////////////////////////////////////*/
/// @notice Deposits the supplied Gobblers/Goo from the owner and sends fractions to the receiver.
/// @param gobblers - Array of Gobbler ids.
/// @param gooTokens - Amount of Goo to deposit.
/// @param receiver - Address to receive fractions.
/// @return fractions - Amount of fractions created.
function deposit(uint256[] calldata gobblers, uint256 gooTokens, address receiver)
external
returns (uint256 fractions);
/// @notice Deposits the supplied Gobblers/Goo from the owner and sends fractions to the
/// @notice receiver whilst ensuring a deadline is met, and a minimum amount of fractions are created.
/// @param gobblers - Array of Gobbler ids to deposit.
/// @param gooTokens - Amount of Goo to deposit.
/// @param receiver - Address to receive fractions.
/// @param minFractionsOut - Minimum amount of fractions to be sent.
/// @param deadline - Unix timestamp by which the transaction must execute.
/// @return fractions - Amount of fractions created.
function safeDeposit(
uint256[] calldata gobblers,
uint256 gooTokens,
address receiver,
uint256 minFractionsOut,
uint256 deadline
) external returns (uint256 fractions);
/// @notice Withdraws the requested Gobblers and Goo from the vault.
/// @param gobblers - Array of Gobbler ids to withdraw
/// @param gooTokens - Amount of Goo to withdraw.
/// @param receiver - Address to receive the Goo and Gobblers.
/// @param owner - Owner of the fractions to be destroyed.
/// @return fractions - Amount of fractions destroyed.
function withdraw(uint256[] calldata gobblers, uint256 gooTokens, address receiver, address owner)
external
returns (uint256 fractions);
/// @notice Withdraws the requested Gobblers/Goo from the vault to the receiver and destroys fractions
/// @notice from the owner whilst ensuring a deadline is met, and a maximimum amount of fractions are destroyed.
/// @param gobblers - Array of Gobbler ids to withdraw.
/// @param gooTokens - Amount of Goo to withdraw.
/// @param receiver - Address to receive the Goo and Gobblers.
/// @param owner - Owner of the fractions to be destroyed.
/// @param maxFractionsIn - Maximum amount of fractions to be destroyed.
/// @param deadline - Unix timestamp by which the transaction must execute.
/// @return fractions - Aamount of fractions destroyed.
function safeWithdraw(
uint256[] calldata gobblers,
uint256 gooTokens,
address receiver,
address owner,
uint256 maxFractionsIn,
uint256 deadline
) external returns (uint256 fractions);
/// @notice Swaps supplied Gobblers/Goo for Gobblers/Goo in the pool.
function swap(
uint256[] calldata gobblersIn,
uint256 gooIn,
uint256[] calldata gobblersOut,
uint256 gooOut,
address receiver,
bytes calldata data
) external returns (int256 erroneousGoo);
/// @notice Swaps supplied Gobblers/Goo for Gobblers/Goo in the pool, with slippage and deadline control.
function safeSwap(
uint256 erroneousGooAbs,
uint256 deadline,
uint256[] calldata gobblersIn,
uint256 gooIn,
uint256[] calldata gobblersOut,
uint256 gooOut,
address receiver,
bytes calldata data
) external returns (int256 erroneousGoo);
}// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;
import "./IGoober.sol";
interface IGooberCallee {
function gooberCall(bytes calldata data) external;
}// SPDX-License-Identifier: GPL
pragma solidity ^0.8.17;
// a library for handling binary fixed point numbers (https://en.wikipedia.org/wiki/Q_(number_format))
// range: [0, 2**112 - 1]
// resolution: 1 / 2**112
library UQ112x112 {
uint224 public constant Q112 = 2 ** 112;
// encode a uint112 as a UQ112x112
function encode(uint112 y) internal pure returns (uint224 z) {
z = uint224(y) * Q112; // never overflows
}
// divide a UQ112x112 by a uint112, returning a UQ112x112
function uqdiv(uint224 x, uint112 y) internal pure returns (uint224 z) {
z = x / uint224(y);
}
}{
"remappings": [
"VRGDAs/=lib/art-gobblers/lib/VRGDAs/src/",
"art-gobblers/=lib/art-gobblers/src/",
"chainlink/=lib/art-gobblers/lib/chainlink/contracts/src/",
"ds-test/=lib/forge-std/lib/ds-test/src/",
"forge-std/=lib/forge-std/src/",
"goo-issuance/=lib/art-gobblers/lib/goo-issuance/src/",
"solmate/=lib/solmate/src/"
],
"optimizer": {
"enabled": true,
"runs": 2000000
},
"metadata": {
"bytecodeHash": "ipfs"
},
"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":"address","name":"_gobblersAddress","type":"address"},{"internalType":"address","name":"_gooAddress","type":"address"},{"internalType":"address","name":"_feeTo","type":"address"},{"internalType":"address","name":"_minter","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"accessor","type":"address"},{"internalType":"address","name":"permissioned","type":"address"}],"name":"AccessControlViolation","type":"error"},{"inputs":[{"internalType":"uint256","name":"auctionPrice","type":"uint256"},{"internalType":"uint256","name":"poolPrice","type":"uint256"}],"name":"AuctionPriceTooHigh","type":"error"},{"inputs":[],"name":"BurnAboveLimit","type":"error"},{"inputs":[{"internalType":"uint256","name":"actualErroneousGoo","type":"uint256"},{"internalType":"uint256","name":"allowedErroneousGoo","type":"uint256"}],"name":"ExcessiveErroneousGoo","type":"error"},{"inputs":[{"internalType":"uint256","name":"time","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"name":"Expired","type":"error"},{"inputs":[],"name":"InsufficientAllowance","type":"error"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"actualK","type":"uint256"},{"internalType":"uint256","name":"expectedK","type":"uint256"}],"name":"InsufficientGoo","type":"error"},{"inputs":[{"internalType":"uint256","name":"amount0In","type":"uint256"},{"internalType":"uint256","name":"amount1In","type":"uint256"}],"name":"InsufficientInputAmount","type":"error"},{"inputs":[{"internalType":"uint256","name":"gooBalance","type":"uint256"},{"internalType":"uint256","name":"gobblerBalance","type":"uint256"}],"name":"InsufficientLiquidity","type":"error"},{"inputs":[],"name":"InsufficientLiquidityDeposited","type":"error"},{"inputs":[],"name":"InsufficientLiquidityWithdrawn","type":"error"},{"inputs":[{"internalType":"uint256","name":"gooOut","type":"uint256"},{"internalType":"uint256","name":"gobblersOut","type":"uint256"}],"name":"InsufficientOutputAmount","type":"error"},{"inputs":[{"internalType":"address","name":"feeTo","type":"address"}],"name":"InvalidAddress","type":"error"},{"inputs":[{"internalType":"uint256","name":"gobblerId","type":"uint256"}],"name":"InvalidMultiplier","type":"error"},{"inputs":[],"name":"InvalidNFT","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"InvalidReceiver","type":"error"},{"inputs":[],"name":"MintBelowLimit","type":"error"},{"inputs":[],"name":"MintFailed","type":"error"},{"inputs":[{"internalType":"uint256","name":"gooBalance","type":"uint256"},{"internalType":"uint256","name":"gobblerBalance","type":"uint256"}],"name":"MustLeaveLiquidity","type":"error"},{"inputs":[],"name":"NoSkim","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"caller","type":"address"},{"indexed":true,"internalType":"address","name":"receiver","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"gobblers","type":"uint256[]"},{"indexed":false,"internalType":"uint256","name":"gooTokens","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"fractions","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"feeTo","type":"address"},{"indexed":false,"internalType":"uint256","name":"fractions","type":"uint256"},{"indexed":false,"internalType":"bool","name":"performanceFee","type":"bool"},{"indexed":false,"internalType":"uint256","name":"_deltaK","type":"uint256"}],"name":"FeesAccrued","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"caller","type":"address"},{"indexed":true,"internalType":"address","name":"receiver","type":"address"},{"indexed":false,"internalType":"uint256","name":"gooTokensIn","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"gobblersMultIn","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"gooTokensOut","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"gobblerMultOut","type":"uint256"}],"name":"Swap","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"gooBalance","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"multBalance","type":"uint256"}],"name":"Sync","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"minter","type":"address"},{"indexed":false,"internalType":"uint256","name":"auctionPricePerMult","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"poolPricePerMult","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"gooConsumed","type":"uint256"}],"name":"VaultMint","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"caller","type":"address"},{"indexed":true,"internalType":"address","name":"receiver","type":"address"},{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"gobblers","type":"uint256[]"},{"indexed":false,"internalType":"uint256","name":"gooTokens","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"fractions","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MANAGEMENT_FEE_BPS","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PERFORMANCE_FEE_BPS","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"artGobblers","outputs":[{"internalType":"contract ArtGobblers","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"blockTimestampLast","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"fractions","type":"uint256"}],"name":"convertToAssets","outputs":[{"internalType":"uint256","name":"gooTokens","type":"uint256"},{"internalType":"uint256","name":"gobblerMult","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"gooTokens","type":"uint256"},{"internalType":"uint256","name":"gobblerMult","type":"uint256"}],"name":"convertToFractions","outputs":[{"internalType":"uint256","name":"fractions","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"gobblers","type":"uint256[]"},{"internalType":"uint256","name":"gooTokens","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"}],"name":"deposit","outputs":[{"internalType":"uint256","name":"fractions","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"feeTo","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bool","name":"_flagged","type":"bool"}],"name":"flagGobbler","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"flagged","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getReserves","outputs":[{"internalType":"uint256","name":"_gooReserve","type":"uint256"},{"internalType":"uint256","name":"_gobblerReserve","type":"uint256"},{"internalType":"uint32","name":"_blockTimestampLast","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"goo","outputs":[{"internalType":"contract Goo","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"kDebt","outputs":[{"internalType":"uint112","name":"","type":"uint112"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"kLast","outputs":[{"internalType":"uint112","name":"","type":"uint112"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mintGobbler","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"minter","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"gobblers","type":"uint256[]"},{"internalType":"uint256","name":"gooTokens","type":"uint256"}],"name":"previewDeposit","outputs":[{"internalType":"uint256","name":"fractions","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"gobblersIn","type":"uint256[]"},{"internalType":"uint256","name":"gooIn","type":"uint256"},{"internalType":"uint256[]","name":"gobblersOut","type":"uint256[]"},{"internalType":"uint256","name":"gooOut","type":"uint256"}],"name":"previewSwap","outputs":[{"internalType":"int256","name":"erroneousGoo","type":"int256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"gobblers","type":"uint256[]"},{"internalType":"uint256","name":"gooTokens","type":"uint256"}],"name":"previewWithdraw","outputs":[{"internalType":"uint256","name":"fractions","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"priceGobblerCumulativeLast","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"priceGooCumulativeLast","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"gobblers","type":"uint256[]"},{"internalType":"uint256","name":"gooTokens","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint256","name":"minFractionsOut","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"name":"safeDeposit","outputs":[{"internalType":"uint256","name":"fractions","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"erroneousGooAbs","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint256[]","name":"gobblersIn","type":"uint256[]"},{"internalType":"uint256","name":"gooIn","type":"uint256"},{"internalType":"uint256[]","name":"gobblersOut","type":"uint256[]"},{"internalType":"uint256","name":"gooOut","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeSwap","outputs":[{"internalType":"int256","name":"erroneousGoo","type":"int256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"gobblers","type":"uint256[]"},{"internalType":"uint256","name":"gooTokens","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"maxFractionsIn","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"name":"safeWithdraw","outputs":[{"internalType":"uint256","name":"fractions","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newFeeTo","type":"address"}],"name":"setFeeTo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newMinter","type":"address"}],"name":"setMinter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"erc20","type":"address"}],"name":"skim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"gobblersIn","type":"uint256[]"},{"internalType":"uint256","name":"gooIn","type":"uint256"},{"internalType":"uint256[]","name":"gobblersOut","type":"uint256[]"},{"internalType":"uint256","name":"gooOut","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"swap","outputs":[{"internalType":"int256","name":"","type":"int256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAssets","outputs":[{"internalType":"uint256","name":"gooTokens","type":"uint256"},{"internalType":"uint256","name":"gobblerMult","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"gobblers","type":"uint256[]"},{"internalType":"uint256","name":"gooTokens","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"owner","type":"address"}],"name":"withdraw","outputs":[{"internalType":"uint256","name":"fractions","type":"uint256"}],"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)
00000000000000000000000060bb1e2aa1c9acafb4d34f71585d7e959f387769000000000000000000000000600000000a36f3cd48407e35eb7c5c910dc1f7a80000000000000000000000000cc56e024e9fda80f939ab3b434d0dd76765d1750000000000000000000000000cc56e024e9fda80f939ab3b434d0dd76765d175
-----Decoded View---------------
Arg [0] : _gobblersAddress (address): 0x60bb1e2AA1c9ACAfB4d34F71585D7e959f387769
Arg [1] : _gooAddress (address): 0x600000000a36F3cD48407e35eB7C5c910dc1f7a8
Arg [2] : _feeTo (address): 0x0Cc56E024E9FDa80F939aB3b434d0DD76765d175
Arg [3] : _minter (address): 0x0Cc56E024E9FDa80F939aB3b434d0DD76765d175
-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 00000000000000000000000060bb1e2aa1c9acafb4d34f71585d7e959f387769
Arg [1] : 000000000000000000000000600000000a36f3cd48407e35eb7c5c910dc1f7a8
Arg [2] : 0000000000000000000000000cc56e024e9fda80f939ab3b434d0dd76765d175
Arg [3] : 0000000000000000000000000cc56e024e9fda80f939ab3b434d0dd76765d175
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.