0x5e...DcFe
Locked Lizard
LLZ
Collection
Collection
This contract's source code is verified!
Contract Metadata
Compiler
0.8.19+commit.7dd6d404
Language
Solidity
// SPDX-License-Identifier: BSD-4-Clause
/*
* ABDK Math 64.64 Smart Contract Library. Copyright © 2019 by ABDK Consulting.
* Author: Mikhail Vladimirov <mikhail.vladimirov@gmail.com>
*/
pragma solidity 0.8.17;
/**
* Smart contract library of mathematical functions operating with signed
* 64.64-bit fixed point numbers. Signed 64.64-bit fixed point number is
* basically a simple fraction whose numerator is signed 128-bit integer and
* denominator is 2^64. As long as denominator is always the same, there is no
* need to store it, thus in Solidity signed 64.64-bit fixed point numbers are
* represented by int128 type holding only the numerator.
*/
library ABDKMath64x64 {
/*
* Minimum value signed 64.64-bit fixed point number may have.
*/
int128 private constant MIN_64x64 = -0x80000000000000000000000000000000;
/*
* Maximum value signed 64.64-bit fixed point number may have.
*/
int128 private constant MAX_64x64 = 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
/**
* Convert signed 256-bit integer number into signed 64.64-bit fixed point
* number. Revert on overflow.
*
* @param x signed 256-bit integer number
* @return signed 64.64-bit fixed point number
*/
function fromInt(int256 x) internal pure returns (int128) {
unchecked {
require(x >= -0x8000000000000000 && x <= 0x7FFFFFFFFFFFFFFF);
return int128(x << 64);
}
}
/**
* Convert signed 64.64 fixed point number into signed 64-bit integer number
* rounding down.
*
* @param x signed 64.64-bit fixed point number
* @return signed 64-bit integer number
*/
function toInt(int128 x) internal pure returns (int64) {
unchecked {
return int64(x >> 64);
}
}
/**
* Convert unsigned 256-bit integer number into signed 64.64-bit fixed point
* number. Revert on overflow.
*
* @param x unsigned 256-bit integer number
* @return signed 64.64-bit fixed point number
*/
function fromUInt(uint256 x) internal pure returns (int128) {
unchecked {
require(x <= 0x7FFFFFFFFFFFFFFF);
return int128(int256(x << 64));
}
}
/**
* Convert signed 64.64 fixed point number into unsigned 64-bit integer
* number rounding down. Revert on underflow.
*
* @param x signed 64.64-bit fixed point number
* @return unsigned 64-bit integer number
*/
function toUInt(int128 x) internal pure returns (uint64) {
unchecked {
require(x >= 0);
return uint64(uint128(x >> 64));
}
}
/**
* Convert signed 128.128 fixed point number into signed 64.64-bit fixed point
* number rounding down. Revert on overflow.
*
* @param x signed 128.128-bin fixed point number
* @return signed 64.64-bit fixed point number
*/
function from128x128(int256 x) internal pure returns (int128) {
unchecked {
int256 result = x >> 64;
require(result >= MIN_64x64 && result <= MAX_64x64);
return int128(result);
}
}
/**
* Convert signed 64.64 fixed point number into signed 128.128 fixed point
* number.
*
* @param x signed 64.64-bit fixed point number
* @return signed 128.128 fixed point number
*/
function to128x128(int128 x) internal pure returns (int256) {
unchecked {
return int256(x) << 64;
}
}
/**
* Calculate x + y. Revert on overflow.
*
* @param x signed 64.64-bit fixed point number
* @param y signed 64.64-bit fixed point number
* @return signed 64.64-bit fixed point number
*/
function add(int128 x, int128 y) internal pure returns (int128) {
unchecked {
int256 result = int256(x) + y;
require(result >= MIN_64x64 && result <= MAX_64x64);
return int128(result);
}
}
/**
* Calculate x - y. Revert on overflow.
*
* @param x signed 64.64-bit fixed point number
* @param y signed 64.64-bit fixed point number
* @return signed 64.64-bit fixed point number
*/
function sub(int128 x, int128 y) internal pure returns (int128) {
unchecked {
int256 result = int256(x) - y;
require(result >= MIN_64x64 && result <= MAX_64x64);
return int128(result);
}
}
/**
* Calculate x * y rounding down. Revert on overflow.
*
* @param x signed 64.64-bit fixed point number
* @param y signed 64.64-bit fixed point number
* @return signed 64.64-bit fixed point number
*/
function mul(int128 x, int128 y) internal pure returns (int128) {
unchecked {
int256 result = int256(x) * y >> 64;
require(result >= MIN_64x64 && result <= MAX_64x64);
return int128(result);
}
}
/**
* Calculate x * y rounding towards zero, where x is signed 64.64 fixed point
* number and y is signed 256-bit integer number. Revert on overflow.
*
* @param x signed 64.64 fixed point number
* @param y signed 256-bit integer number
* @return signed 256-bit integer number
*/
function muli(int128 x, int256 y) internal pure returns (int256) {
unchecked {
if (x == MIN_64x64) {
require(
y >= -0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
&& y <= 0x1000000000000000000000000000000000000000000000000
);
return -y << 63;
} else {
bool negativeResult = false;
if (x < 0) {
x = -x;
negativeResult = true;
}
if (y < 0) {
y = -y; // We rely on overflow behavior here
negativeResult = !negativeResult;
}
uint256 absoluteResult = mulu(x, uint256(y));
if (negativeResult) {
require(absoluteResult <= 0x8000000000000000000000000000000000000000000000000000000000000000);
return -int256(absoluteResult); // We rely on overflow behavior here
} else {
require(absoluteResult <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
return int256(absoluteResult);
}
}
}
}
/**
* Calculate x * y rounding down, where x is signed 64.64 fixed point number
* and y is unsigned 256-bit integer number. Revert on overflow.
*
* @param x signed 64.64 fixed point number
* @param y unsigned 256-bit integer number
* @return unsigned 256-bit integer number
*/
function mulu(int128 x, uint256 y) internal pure returns (uint256) {
unchecked {
if (y == 0) return 0;
require(x >= 0);
uint256 lo = (uint256(int256(x)) * (y & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)) >> 64;
uint256 hi = uint256(int256(x)) * (y >> 128);
require(hi <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
hi <<= 64;
require(hi <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF - lo);
return hi + lo;
}
}
/**
* Calculate x / y rounding towards zero. Revert on overflow or when y is
* zero.
*
* @param x signed 64.64-bit fixed point number
* @param y signed 64.64-bit fixed point number
* @return signed 64.64-bit fixed point number
*/
function div(int128 x, int128 y) internal pure returns (int128) {
unchecked {
require(y != 0);
int256 result = (int256(x) << 64) / y;
require(result >= MIN_64x64 && result <= MAX_64x64);
return int128(result);
}
}
/**
* Calculate x / y rounding towards zero, where x and y are signed 256-bit
* integer numbers. Revert on overflow or when y is zero.
*
* @param x signed 256-bit integer number
* @param y signed 256-bit integer number
* @return signed 64.64-bit fixed point number
*/
function divi(int256 x, int256 y) internal pure returns (int128) {
unchecked {
require(y != 0);
bool negativeResult = false;
if (x < 0) {
x = -x; // We rely on overflow behavior here
negativeResult = true;
}
if (y < 0) {
y = -y; // We rely on overflow behavior here
negativeResult = !negativeResult;
}
uint128 absoluteResult = divuu(uint256(x), uint256(y));
if (negativeResult) {
require(absoluteResult <= 0x80000000000000000000000000000000);
return -int128(absoluteResult); // We rely on overflow behavior here
} else {
require(absoluteResult <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
return int128(absoluteResult); // We rely on overflow behavior here
}
}
}
/**
* Calculate x / y rounding towards zero, where x and y are unsigned 256-bit
* integer numbers. Revert on overflow or when y is zero.
*
* @param x unsigned 256-bit integer number
* @param y unsigned 256-bit integer number
* @return signed 64.64-bit fixed point number
*/
function divu(uint256 x, uint256 y) internal pure returns (int128) {
unchecked {
require(y != 0);
uint128 result = divuu(x, y);
require(result <= uint128(MAX_64x64));
return int128(result);
}
}
/**
* Calculate -x. Revert on overflow.
*
* @param x signed 64.64-bit fixed point number
* @return signed 64.64-bit fixed point number
*/
function neg(int128 x) internal pure returns (int128) {
unchecked {
require(x != MIN_64x64);
return -x;
}
}
/**
* Calculate |x|. Revert on overflow.
*
* @param x signed 64.64-bit fixed point number
* @return signed 64.64-bit fixed point number
*/
function abs(int128 x) internal pure returns (int128) {
unchecked {
require(x != MIN_64x64);
return x < 0 ? -x : x;
}
}
/**
* Calculate 1 / x rounding towards zero. Revert on overflow or when x is
* zero.
*
* @param x signed 64.64-bit fixed point number
* @return signed 64.64-bit fixed point number
*/
function inv(int128 x) internal pure returns (int128) {
unchecked {
require(x != 0);
int256 result = int256(0x100000000000000000000000000000000) / x;
require(result >= MIN_64x64 && result <= MAX_64x64);
return int128(result);
}
}
/**
* Calculate arithmetics average of x and y, i.e. (x + y) / 2 rounding down.
*
* @param x signed 64.64-bit fixed point number
* @param y signed 64.64-bit fixed point number
* @return signed 64.64-bit fixed point number
*/
function avg(int128 x, int128 y) internal pure returns (int128) {
unchecked {
return int128((int256(x) + int256(y)) >> 1);
}
}
/**
* Calculate geometric average of x and y, i.e. sqrt (x * y) rounding down.
* Revert on overflow or in case x * y is negative.
*
* @param x signed 64.64-bit fixed point number
* @param y signed 64.64-bit fixed point number
* @return signed 64.64-bit fixed point number
*/
function gavg(int128 x, int128 y) internal pure returns (int128) {
unchecked {
int256 m = int256(x) * int256(y);
require(m >= 0);
require(m < 0x4000000000000000000000000000000000000000000000000000000000000000);
return int128(sqrtu(uint256(m)));
}
}
/**
* Calculate x^y assuming 0^0 is 1, where x is signed 64.64 fixed point number
* and y is unsigned 256-bit integer number. Revert on overflow.
*
* @param x signed 64.64-bit fixed point number
* @param y uint256 value
* @return signed 64.64-bit fixed point number
*/
function pow(int128 x, uint256 y) internal pure returns (int128) {
unchecked {
bool negative = x < 0 && y & 1 == 1;
uint256 absX = uint128(x < 0 ? -x : x);
uint256 absResult;
absResult = 0x100000000000000000000000000000000;
if (absX <= 0x10000000000000000) {
absX <<= 63;
while (y != 0) {
if (y & 0x1 != 0) {
absResult = absResult * absX >> 127;
}
absX = absX * absX >> 127;
if (y & 0x2 != 0) {
absResult = absResult * absX >> 127;
}
absX = absX * absX >> 127;
if (y & 0x4 != 0) {
absResult = absResult * absX >> 127;
}
absX = absX * absX >> 127;
if (y & 0x8 != 0) {
absResult = absResult * absX >> 127;
}
absX = absX * absX >> 127;
y >>= 4;
}
absResult >>= 64;
} else {
uint256 absXShift = 63;
if (absX < 0x1000000000000000000000000) {
absX <<= 32;
absXShift -= 32;
}
if (absX < 0x10000000000000000000000000000) {
absX <<= 16;
absXShift -= 16;
}
if (absX < 0x1000000000000000000000000000000) {
absX <<= 8;
absXShift -= 8;
}
if (absX < 0x10000000000000000000000000000000) {
absX <<= 4;
absXShift -= 4;
}
if (absX < 0x40000000000000000000000000000000) {
absX <<= 2;
absXShift -= 2;
}
if (absX < 0x80000000000000000000000000000000) {
absX <<= 1;
absXShift -= 1;
}
uint256 resultShift = 0;
while (y != 0) {
require(absXShift < 64);
if (y & 0x1 != 0) {
absResult = absResult * absX >> 127;
resultShift += absXShift;
if (absResult > 0x100000000000000000000000000000000) {
absResult >>= 1;
resultShift += 1;
}
}
absX = absX * absX >> 127;
absXShift <<= 1;
if (absX >= 0x100000000000000000000000000000000) {
absX >>= 1;
absXShift += 1;
}
y >>= 1;
}
require(resultShift < 64);
absResult >>= 64 - resultShift;
}
int256 result = negative ? -int256(absResult) : int256(absResult);
require(result >= MIN_64x64 && result <= MAX_64x64);
return int128(result);
}
}
/**
* Calculate sqrt (x) rounding down. Revert if x < 0.
*
* @param x signed 64.64-bit fixed point number
* @return signed 64.64-bit fixed point number
*/
function sqrt(int128 x) internal pure returns (int128) {
unchecked {
require(x >= 0);
return int128(sqrtu(uint256(int256(x)) << 64));
}
}
/**
* Calculate binary logarithm of x. Revert if x <= 0.
*
* @param x signed 64.64-bit fixed point number
* @return signed 64.64-bit fixed point number
*/
function log_2(int128 x) internal pure returns (int128) {
unchecked {
require(x > 0);
int256 msb = 0;
int256 xc = x;
if (xc >= 0x10000000000000000) {
xc >>= 64;
msb += 64;
}
if (xc >= 0x100000000) {
xc >>= 32;
msb += 32;
}
if (xc >= 0x10000) {
xc >>= 16;
msb += 16;
}
if (xc >= 0x100) {
xc >>= 8;
msb += 8;
}
if (xc >= 0x10) {
xc >>= 4;
msb += 4;
}
if (xc >= 0x4) {
xc >>= 2;
msb += 2;
}
if (xc >= 0x2) msb += 1; // No need to shift xc anymore
int256 result = msb - 64 << 64;
uint256 ux = uint256(int256(x)) << uint256(127 - msb);
for (int256 bit = 0x8000000000000000; bit > 0; bit >>= 1) {
ux *= ux;
uint256 b = ux >> 255;
ux >>= 127 + b;
result += bit * int256(b);
}
return int128(result);
}
}
/**
* Calculate natural logarithm of x. Revert if x <= 0.
*
* @param x signed 64.64-bit fixed point number
* @return signed 64.64-bit fixed point number
*/
function ln(int128 x) internal pure returns (int128) {
unchecked {
require(x > 0);
return int128(int256(uint256(int256(log_2(x))) * 0xB17217F7D1CF79ABC9E3B39803F2F6AF >> 128));
}
}
/**
* Calculate binary exponent of x. Revert on overflow.
*
* @param x signed 64.64-bit fixed point number
* @return signed 64.64-bit fixed point number
*/
function exp_2(int128 x) internal pure returns (int128) {
unchecked {
require(x < 0x400000000000000000); // Overflow
if (x < -0x400000000000000000) return 0; // Underflow
uint256 result = 0x80000000000000000000000000000000;
if (x & 0x8000000000000000 > 0) {
result = result * 0x16A09E667F3BCC908B2FB1366EA957D3E >> 128;
}
if (x & 0x4000000000000000 > 0) {
result = result * 0x1306FE0A31B7152DE8D5A46305C85EDEC >> 128;
}
if (x & 0x2000000000000000 > 0) {
result = result * 0x1172B83C7D517ADCDF7C8C50EB14A791F >> 128;
}
if (x & 0x1000000000000000 > 0) {
result = result * 0x10B5586CF9890F6298B92B71842A98363 >> 128;
}
if (x & 0x800000000000000 > 0) {
result = result * 0x1059B0D31585743AE7C548EB68CA417FD >> 128;
}
if (x & 0x400000000000000 > 0) {
result = result * 0x102C9A3E778060EE6F7CACA4F7A29BDE8 >> 128;
}
if (x & 0x200000000000000 > 0) {
result = result * 0x10163DA9FB33356D84A66AE336DCDFA3F >> 128;
}
if (x & 0x100000000000000 > 0) {
result = result * 0x100B1AFA5ABCBED6129AB13EC11DC9543 >> 128;
}
if (x & 0x80000000000000 > 0) {
result = result * 0x10058C86DA1C09EA1FF19D294CF2F679B >> 128;
}
if (x & 0x40000000000000 > 0) {
result = result * 0x1002C605E2E8CEC506D21BFC89A23A00F >> 128;
}
if (x & 0x20000000000000 > 0) {
result = result * 0x100162F3904051FA128BCA9C55C31E5DF >> 128;
}
if (x & 0x10000000000000 > 0) {
result = result * 0x1000B175EFFDC76BA38E31671CA939725 >> 128;
}
if (x & 0x8000000000000 > 0) {
result = result * 0x100058BA01FB9F96D6CACD4B180917C3D >> 128;
}
if (x & 0x4000000000000 > 0) {
result = result * 0x10002C5CC37DA9491D0985C348C68E7B3 >> 128;
}
if (x & 0x2000000000000 > 0) {
result = result * 0x1000162E525EE054754457D5995292026 >> 128;
}
if (x & 0x1000000000000 > 0) {
result = result * 0x10000B17255775C040618BF4A4ADE83FC >> 128;
}
if (x & 0x800000000000 > 0) {
result = result * 0x1000058B91B5BC9AE2EED81E9B7D4CFAB >> 128;
}
if (x & 0x400000000000 > 0) {
result = result * 0x100002C5C89D5EC6CA4D7C8ACC017B7C9 >> 128;
}
if (x & 0x200000000000 > 0) {
result = result * 0x10000162E43F4F831060E02D839A9D16D >> 128;
}
if (x & 0x100000000000 > 0) {
result = result * 0x100000B1721BCFC99D9F890EA06911763 >> 128;
}
if (x & 0x80000000000 > 0) {
result = result * 0x10000058B90CF1E6D97F9CA14DBCC1628 >> 128;
}
if (x & 0x40000000000 > 0) {
result = result * 0x1000002C5C863B73F016468F6BAC5CA2B >> 128;
}
if (x & 0x20000000000 > 0) {
result = result * 0x100000162E430E5A18F6119E3C02282A5 >> 128;
}
if (x & 0x10000000000 > 0) {
result = result * 0x1000000B1721835514B86E6D96EFD1BFE >> 128;
}
if (x & 0x8000000000 > 0) {
result = result * 0x100000058B90C0B48C6BE5DF846C5B2EF >> 128;
}
if (x & 0x4000000000 > 0) {
result = result * 0x10000002C5C8601CC6B9E94213C72737A >> 128;
}
if (x & 0x2000000000 > 0) {
result = result * 0x1000000162E42FFF037DF38AA2B219F06 >> 128;
}
if (x & 0x1000000000 > 0) {
result = result * 0x10000000B17217FBA9C739AA5819F44F9 >> 128;
}
if (x & 0x800000000 > 0) {
result = result * 0x1000000058B90BFCDEE5ACD3C1CEDC823 >> 128;
}
if (x & 0x400000000 > 0) {
result = result * 0x100000002C5C85FE31F35A6A30DA1BE50 >> 128;
}
if (x & 0x200000000 > 0) {
result = result * 0x10000000162E42FF0999CE3541B9FFFCF >> 128;
}
if (x & 0x100000000 > 0) {
result = result * 0x100000000B17217F80F4EF5AADDA45554 >> 128;
}
if (x & 0x80000000 > 0) {
result = result * 0x10000000058B90BFBF8479BD5A81B51AD >> 128;
}
if (x & 0x40000000 > 0) {
result = result * 0x1000000002C5C85FDF84BD62AE30A74CC >> 128;
}
if (x & 0x20000000 > 0) {
result = result * 0x100000000162E42FEFB2FED257559BDAA >> 128;
}
if (x & 0x10000000 > 0) {
result = result * 0x1000000000B17217F7D5A7716BBA4A9AE >> 128;
}
if (x & 0x8000000 > 0) {
result = result * 0x100000000058B90BFBE9DDBAC5E109CCE >> 128;
}
if (x & 0x4000000 > 0) {
result = result * 0x10000000002C5C85FDF4B15DE6F17EB0D >> 128;
}
if (x & 0x2000000 > 0) {
result = result * 0x1000000000162E42FEFA494F1478FDE05 >> 128;
}
if (x & 0x1000000 > 0) {
result = result * 0x10000000000B17217F7D20CF927C8E94C >> 128;
}
if (x & 0x800000 > 0) {
result = result * 0x1000000000058B90BFBE8F71CB4E4B33D >> 128;
}
if (x & 0x400000 > 0) {
result = result * 0x100000000002C5C85FDF477B662B26945 >> 128;
}
if (x & 0x200000 > 0) {
result = result * 0x10000000000162E42FEFA3AE53369388C >> 128;
}
if (x & 0x100000 > 0) {
result = result * 0x100000000000B17217F7D1D351A389D40 >> 128;
}
if (x & 0x80000 > 0) {
result = result * 0x10000000000058B90BFBE8E8B2D3D4EDE >> 128;
}
if (x & 0x40000 > 0) {
result = result * 0x1000000000002C5C85FDF4741BEA6E77E >> 128;
}
if (x & 0x20000 > 0) {
result = result * 0x100000000000162E42FEFA39FE95583C2 >> 128;
}
if (x & 0x10000 > 0) {
result = result * 0x1000000000000B17217F7D1CFB72B45E1 >> 128;
}
if (x & 0x8000 > 0) {
result = result * 0x100000000000058B90BFBE8E7CC35C3F0 >> 128;
}
if (x & 0x4000 > 0) {
result = result * 0x10000000000002C5C85FDF473E242EA38 >> 128;
}
if (x & 0x2000 > 0) {
result = result * 0x1000000000000162E42FEFA39F02B772C >> 128;
}
if (x & 0x1000 > 0) {
result = result * 0x10000000000000B17217F7D1CF7D83C1A >> 128;
}
if (x & 0x800 > 0) {
result = result * 0x1000000000000058B90BFBE8E7BDCBE2E >> 128;
}
if (x & 0x400 > 0) {
result = result * 0x100000000000002C5C85FDF473DEA871F >> 128;
}
if (x & 0x200 > 0) {
result = result * 0x10000000000000162E42FEFA39EF44D91 >> 128;
}
if (x & 0x100 > 0) {
result = result * 0x100000000000000B17217F7D1CF79E949 >> 128;
}
if (x & 0x80 > 0) {
result = result * 0x10000000000000058B90BFBE8E7BCE544 >> 128;
}
if (x & 0x40 > 0) {
result = result * 0x1000000000000002C5C85FDF473DE6ECA >> 128;
}
if (x & 0x20 > 0) {
result = result * 0x100000000000000162E42FEFA39EF366F >> 128;
}
if (x & 0x10 > 0) {
result = result * 0x1000000000000000B17217F7D1CF79AFA >> 128;
}
if (x & 0x8 > 0) {
result = result * 0x100000000000000058B90BFBE8E7BCD6D >> 128;
}
if (x & 0x4 > 0) {
result = result * 0x10000000000000002C5C85FDF473DE6B2 >> 128;
}
if (x & 0x2 > 0) {
result = result * 0x1000000000000000162E42FEFA39EF358 >> 128;
}
if (x & 0x1 > 0) {
result = result * 0x10000000000000000B17217F7D1CF79AB >> 128;
}
result >>= uint256(int256(63 - (x >> 64)));
require(result <= uint256(int256(MAX_64x64)));
return int128(int256(result));
}
}
/**
* Calculate natural exponent of x. Revert on overflow.
*
* @param x signed 64.64-bit fixed point number
* @return signed 64.64-bit fixed point number
*/
function exp(int128 x) internal pure returns (int128) {
unchecked {
require(x < 0x400000000000000000); // Overflow
if (x < -0x400000000000000000) return 0; // Underflow
return exp_2(int128(int256(x) * 0x171547652B82FE1777D0FFDA0D23A7D12 >> 128));
}
}
/**
* Calculate x / y rounding towards zero, where x and y are unsigned 256-bit
* integer numbers. Revert on overflow or when y is zero.
*
* @param x unsigned 256-bit integer number
* @param y unsigned 256-bit integer number
* @return unsigned 64.64-bit fixed point number
*/
function divuu(uint256 x, uint256 y) private pure returns (uint128) {
unchecked {
require(y != 0);
uint256 result;
if (x <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF) {
result = (x << 64) / y;
} else {
uint256 msb = 192;
uint256 xc = x >> 192;
if (xc >= 0x100000000) {
xc >>= 32;
msb += 32;
}
if (xc >= 0x10000) {
xc >>= 16;
msb += 16;
}
if (xc >= 0x100) {
xc >>= 8;
msb += 8;
}
if (xc >= 0x10) {
xc >>= 4;
msb += 4;
}
if (xc >= 0x4) {
xc >>= 2;
msb += 2;
}
if (xc >= 0x2) msb += 1; // No need to shift xc anymore
result = (x << 255 - msb) / ((y - 1 >> msb - 191) + 1);
require(result <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
uint256 hi = result * (y >> 128);
uint256 lo = result * (y & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
uint256 xh = x >> 192;
uint256 xl = x << 64;
if (xl < lo) xh -= 1;
xl -= lo; // We rely on overflow behavior here
lo = hi << 128;
if (xl < lo) xh -= 1;
xl -= lo; // We rely on overflow behavior here
assert(xh == hi >> 128);
result += xl / y;
}
require(result <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
return uint128(result);
}
}
/**
* Calculate sqrt (x) rounding down, where x is unsigned 256-bit integer
* number.
*
* @param x unsigned 256-bit integer number
* @return unsigned 128-bit integer number
*/
function sqrtu(uint256 x) private pure returns (uint128) {
unchecked {
if (x == 0) {
return 0;
} else {
uint256 xx = x;
uint256 r = 1;
if (xx >= 0x100000000000000000000000000000000) {
xx >>= 128;
r <<= 64;
}
if (xx >= 0x10000000000000000) {
xx >>= 64;
r <<= 32;
}
if (xx >= 0x100000000) {
xx >>= 32;
r <<= 16;
}
if (xx >= 0x10000) {
xx >>= 16;
r <<= 8;
}
if (xx >= 0x100) {
xx >>= 8;
r <<= 4;
}
if (xx >= 0x10) {
xx >>= 4;
r <<= 2;
}
if (xx >= 0x4) r <<= 1;
r = (r + x / r) >> 1;
r = (r + x / r) >> 1;
r = (r + x / r) >> 1;
r = (r + x / r) >> 1;
r = (r + x / r) >> 1;
r = (r + x / r) >> 1;
r = (r + x / r) >> 1; // Seven iterations should be enough
uint256 r1 = x / r;
return uint128(r < r1 ? r : r1);
}
}
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)
pragma solidity ^0.8.1;
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*
* [IMPORTANT]
* ====
* You shouldn't rely on `isContract` to protect against flash loan attacks!
*
* Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
* like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
* constructor.
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
/**
* @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
* the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
*
* _Available since v4.8._
*/
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
/**
* @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason or using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
pragma solidity ^0.8.0;
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)
pragma solidity ^0.8.0;
import "./IERC165.sol";
/**
* @dev Implementation of the {IERC165} interface.
*
* Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
* for the additional interface id that will be supported. For example:
*
* ```solidity
* function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
* return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
* }
* ```
*
* Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
*/
abstract contract ERC165 is IERC165 {
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/ERC721.sol)
pragma solidity ^0.8.0;
import "./IERC721.sol";
import "./IERC721Receiver.sol";
import "./extensions/IERC721Metadata.sol";
import "../../utils/Address.sol";
import "../../utils/Context.sol";
import "../../utils/Strings.sol";
import "../../utils/introspection/ERC165.sol";
/**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata extension, but not including the Enumerable extension, which is available separately as
* {ERC721Enumerable}.
*/
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to owner address
mapping(uint256 => address) private _owners;
// Mapping owner address to token count
mapping(address => uint256) private _balances;
// Mapping from token ID to approved address
mapping(uint256 => address) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: address zero is not a valid owner");
return _balances[owner];
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _ownerOf(tokenId);
require(owner != address(0), "ERC721: invalid token ID");
return owner;
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
_requireMinted(tokenId);
string memory baseURI = _baseURI();
return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overridden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
return "";
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not token owner or approved for all"
);
_approve(to, tokenId);
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
_requireMinted(tokenId);
return _tokenApprovals[tokenId];
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
_setApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
//solhint-disable-next-line max-line-length
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");
_transfer(from, to, tokenId);
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");
_safeTransfer(from, to, tokenId, data);
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* `data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer");
}
/**
* @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist
*/
function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
return _owners[tokenId];
}
/**
* @dev Returns whether `tokenId` exists.
*
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
*
* Tokens start existing when they are minted (`_mint`),
* and stop existing when they are burned (`_burn`).
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return _ownerOf(tokenId) != address(0);
}
/**
* @dev Returns whether `spender` is allowed to manage `tokenId`.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
address owner = ERC721.ownerOf(tokenId);
return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender);
}
/**
* @dev Safely mints `tokenId` and transfers it to `to`.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(
address to,
uint256 tokenId,
bytes memory data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, data),
"ERC721: transfer to non ERC721Receiver implementer"
);
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId, 1);
// Check that tokenId was not minted by `_beforeTokenTransfer` hook
require(!_exists(tokenId), "ERC721: token already minted");
unchecked {
// Will not overflow unless all 2**256 token ids are minted to the same owner.
// Given that tokens are minted one by one, it is impossible in practice that
// this ever happens. Might change if we allow batch minting.
// The ERC fails to describe this case.
_balances[to] += 1;
}
_owners[tokenId] = to;
emit Transfer(address(0), to, tokenId);
_afterTokenTransfer(address(0), to, tokenId, 1);
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
* This is an internal function that does not check if the sender is authorized to operate on the token.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId, 1);
// Update ownership in case tokenId was transferred by `_beforeTokenTransfer` hook
owner = ERC721.ownerOf(tokenId);
// Clear approvals
delete _tokenApprovals[tokenId];
unchecked {
// Cannot overflow, as that would require more tokens to be burned/transferred
// out than the owner initially received through minting and transferring in.
_balances[owner] -= 1;
}
delete _owners[tokenId];
emit Transfer(owner, address(0), tokenId);
_afterTokenTransfer(owner, address(0), tokenId, 1);
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId, 1);
// Check that tokenId was not transferred by `_beforeTokenTransfer` hook
require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
// Clear approvals from the previous owner
delete _tokenApprovals[tokenId];
unchecked {
// `_balances[from]` cannot overflow for the same reason as described in `_burn`:
// `from`'s balance is the number of token held, which is at least one before the current
// transfer.
// `_balances[to]` could overflow in the conditions described in `_mint`. That would require
// all 2**256 token ids to be minted, which in practice is impossible.
_balances[from] -= 1;
_balances[to] += 1;
}
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
_afterTokenTransfer(from, to, tokenId, 1);
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* Emits an {Approval} event.
*/
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
}
/**
* @dev Approve `operator` to operate on all of `owner` tokens
*
* Emits an {ApprovalForAll} event.
*/
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
require(owner != operator, "ERC721: approve to caller");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
/**
* @dev Reverts if the `tokenId` has not been minted yet.
*/
function _requireMinted(uint256 tokenId) internal view virtual {
require(_exists(tokenId), "ERC721: invalid token ID");
}
/**
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
* The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param data bytes optional data to send along with the call
* @return bool whether the call correctly returned the expected magic value
*/
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory data
) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
/// @solidity memory-safe-assembly
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
/**
* @dev Hook that is called before any token transfer. This includes minting and burning. If {ERC721Consecutive} is
* used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s tokens will be transferred to `to`.
* - When `from` is zero, the tokens will be minted for `to`.
* - When `to` is zero, ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
* - `batchSize` is non-zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address from,
address to,
uint256, /* firstTokenId */
uint256 batchSize
) internal virtual {
if (batchSize > 1) {
if (from != address(0)) {
_balances[from] -= batchSize;
}
if (to != address(0)) {
_balances[to] += batchSize;
}
}
}
/**
* @dev Hook that is called after any token transfer. This includes minting and burning. If {ERC721Consecutive} is
* used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, ``from``'s tokens were transferred to `to`.
* - When `from` is zero, the tokens were minted for `to`.
* - When `to` is zero, ``from``'s tokens were burned.
* - `from` and `to` are never both zero.
* - `batchSize` is non-zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _afterTokenTransfer(
address from,
address to,
uint256 firstTokenId,
uint256 batchSize
) internal virtual {}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC165 standard, as defined in the
* https://eips.ethereum.org/EIPS/eip-165[EIP].
*
* Implementers can declare support of contract interfaces, which can then be
* queried by others ({ERC165Checker}).
*
* For an implementation, see {ERC165}.
*/
interface IERC165 {
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/IERC721.sol)
pragma solidity ^0.8.0;
import "../../utils/introspection/IERC165.sol";
/**
* @dev Required interface of an ERC721 compliant contract.
*/
interface IERC721 is IERC165 {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
*/
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/**
* @dev Returns the number of tokens in ``owner``'s account.
*/
function balanceOf(address owner) external view returns (uint256 balance);
/**
* @dev Returns the owner of the `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function ownerOf(uint256 tokenId) external view returns (address owner);
/**
* @dev Safely transfers `tokenId` token from `from` to `to`.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
/**
* @dev Transfers `tokenId` token from `from` to `to`.
*
* WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
* or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
* understand this adds an external call which potentially creates a reentrancy vulnerability.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
/**
* @dev Gives permission to `to` to transfer `tokenId` token to another account.
* The approval is cleared when the token is transferred.
*
* Only a single account can be approved at a time, so approving the zero address clears previous approvals.
*
* Requirements:
*
* - The caller must own the token or be an approved operator.
* - `tokenId` must exist.
*
* Emits an {Approval} event.
*/
function approve(address to, uint256 tokenId) external;
/**
* @dev Approve or remove `operator` as an operator for the caller.
* Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
*
* Requirements:
*
* - The `operator` cannot be the caller.
*
* Emits an {ApprovalForAll} event.
*/
function setApprovalForAll(address operator, bool _approved) external;
/**
* @dev Returns the account approved for `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function getApproved(uint256 tokenId) external view returns (address operator);
/**
* @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
*
* See {setApprovalForAll}
*/
function isApprovedForAll(address owner, address operator) external view returns (bool);
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)
pragma solidity ^0.8.0;
import "../IERC721.sol";
/**
* @title ERC-721 Non-Fungible Token Standard, optional metadata extension
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/
interface IERC721Metadata is IERC721 {
/**
* @dev Returns the token collection name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the token collection symbol.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId) external view returns (string memory);
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)
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: GPL-3.0
pragma solidity 0.8.17;
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
interface IEthlizards is IERC721 {
function batchTransferFrom(address _from, address _to, uint256[] calldata _tokenId) external;
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.17;
interface IGenesisEthlizards {
function batchTransferFrom(address _from, address _to, uint256[] calldata _tokenId) external;
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.17;
interface IUSDC {
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function balanceOf(address _owner) external returns (uint256);
function approve(address _spender, uint256 _value) external returns (bool success);
function transfer(address to, uint256 value) external returns (bool);
}
// SPDX-License-Identifier: GPL-3.0
pragma solidity 0.8.17;
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "./ABDKMath64x64.sol";
import "./interfaces/IEthLizards.sol";
import "./interfaces/IGenesisEthLizards.sol";
import "./interfaces/IUSDC.sol";
/**
* @title The staking contract for Ethlizards
* @author kmao (@kmao37)
* @notice Lets users stake their Ethlizard NFTs accruing continuous compound interest,
* and also claim rewards based on their share of the pool(s).
* See docs at docs.ethlizards.io
* @dev One Ethlizard is assigned the value of 100 * 1e18 (without any rebases), and we store the overall
* combined shares of all of the Ethlizards in order to calculate the specific percentage share of an Ethlizards.
* Rebases refer to the daily interest that is applied to each Ethlizard.
* Resets refer to when rewards are released into a pool for claim.
* Technical documentation can be found at docs.ethlizards.io
*/
contract LizardLounge is ERC721, Ownable {
IEthlizards public immutable Ethlizards;
IGenesisEthlizards public immutable GenesisLiz;
IUSDC public immutable USDc;
// Last ID of the EthlizardsV2 Collection
uint256 constant MAXETHLIZARDID = 5049;
// The default assigned share of a staked Ethlizard, which is 100,
// we multiply by 1e18 for more precise calculation and storage of a user's shares
uint256 constant DEFAULTLIZARDSHARE = 100 * 1e18;
// When a LLZ is first initially minted
event LockedLizardMinted(address mintedAddress, uint256 mintedId);
// When a LLZ is transferred from this contract, ie, a user stakes their Ethlizards again
event LockedLizardReMinted(address ownerAddress, uint256 lizardId);
// When a user claims rewards from their lizard
event RewardsClaimed(uint256 tokenId, uint256 rewardsClaimed);
// A deposit is made
event RewardsDeposited(uint256 depositAmount);
// AllowedContracts is updated
event AllowedContractsUpdated(address allowedContract, bool status);
// Reset Share Value is updated
event ResetShareValueUpdated(uint256 newResetShareValue);
// Council address is updated
event CouncilAddressUpdated(address councilAddress);
// Updating the min days a user needs to be staked to withdraw their funds
event MinLockedTimeUpdated(uint256 minLockedTime);
// Min Reset Value has been updated
event MinResetValueUpdated(uint256 newMinResetValue);
// BaseURI has been updated
event BaseURIUpdated(string newBaseuri);
// Stores which tokenId was staked by which address
mapping(uint256 => address) public originalLockedLizardOwners;
// Stores the timestamp deposited per tokenId
mapping(uint256 => uint256) public timeLizardLocked;
// Stores the tokenId, and it's current claim status on each specific pool,
// when a claim is made, we make it true
mapping(uint256 => mapping(uint256 => bool)) stakePoolClaims;
// Stores which contracts Locked Lizards are able to interact and approve to
mapping(address => bool) public allowedContracts;
struct Pool {
// Timestamp of reset/pool creation
uint256 time;
// USDC value stored in the pool
uint256 value;
// The current overallShare when the pool is created
uint256 currentGlobalShare;
}
// Pool structure
Pool[] pool;
// Flipstate for staking deposits
bool public depositsActive;
// Address of the EthlizardsDAO
address public ethlizardsDAO = 0xa5D55281917936818665c6cB87959b6a147D9306;
// Council address used for depositing rewards
address public councilAddress;
// Current count of rewards that are not in a pool, in 1e6 decimals
uint256 public currentRewards;
// Total count of the rewards that have been invested
uint256 public totalRewardsInvested;
// Current count of Ethlizards staked
uint256 public currentEthlizardStaked;
// Current count of Ethlizards staked
uint256 public currentGenesisEthlizardStaked;
// The timestamp when deposits are enabled
uint256 public startTimestamp;
// Global counter for the combined shares of all Ethlizards
uint256 public overallShare;
// The timestamp of the last rebase
uint256 public lastGlobalUpdate;
// Counter for resets
uint256 public resetCounter = 0;
// Refers to the current percentage of inflation kept per reset
// EG, 20 = 80% slash in inflation, 20% of inflated shares kept per reset.
uint256 public resetShareValue = 20;
// The minimum rewards to be deposited for a reset to occur/a pool to be created.
// Is in 1e6 format due to USDC's restrictions
uint256 public minResetValue = 50000 * 1e6;
// How long a lizard is locked up for
uint256 public minLockedTime = 90 days;
// Counter for rebases
uint256 public rebaseCounter = 0;
// This is the current approximated rebase value, stored in 64.64 fixed point format.
// The real rebase value is calculated by nominator/2^64.
int128 public nominator = 18.5389777940780994 * 1e18;
// Metadata for LLZs
string public baseURI = "https://ipfs.io/ipfsx";
/**
* @notice Deploys the smart contract and assigns interfaces
* @param ethLizardsAddress Existing address of EthlizardsV2
* @param genesisLizaddress Existing address of Genesis Ethlizards
* @param USDCAddress Existing address of USDC
*/
constructor(IEthlizards ethLizardsAddress, IGenesisEthlizards genesisLizaddress, IUSDC USDCAddress)
ERC721("Locked Lizard", "LLZ")
{
Ethlizards = ethLizardsAddress;
GenesisLiz = genesisLizaddress;
USDc = USDCAddress;
}
/// @dev Modifier created to prevent marketplace sales and listings of Locked Lizard NFTs
modifier onlyApprovedContracts(address operator) {
if (!allowedContracts[operator]) {
revert NotWhitelistedContract();
}
_;
}
/**
* @notice Allows user to deposit their regular and Genesis Ethlizards for staking
* @dev Upon initial call, a user will mint a Locked Lizard per Ethlizards (genesis and regular) they stake.
* with matching tokenIds. Upon withdrawing their stake and staking their Ethlizard again,
* the LLZ will be stored in the contract and thus when a later deposit is made, it is transferred
* to the user. Genesis Ids are incremented by 5049 (The last tokenId of a regular Ethlizard).
* @param _regularTokenIds The array of tokenIds that is deposited by the caller
* @param _genesisTokenIds The array of Genesis tokenIds that is deposited by the caller
*/
function depositStake(uint256[] calldata _regularTokenIds, uint256[] calldata _genesisTokenIds) external {
if (!depositsActive) {
revert DepositsInactive();
}
if (msg.sender != tx.origin) {
revert CallerNotAnAddress();
}
if (_regularTokenIds.length > 0) {
Ethlizards.batchTransferFrom(msg.sender, address(this), _regularTokenIds);
}
if (_genesisTokenIds.length > 0) {
GenesisLiz.batchTransferFrom(msg.sender, address(this), _genesisTokenIds);
}
// Iterate over the regular Ethlizards deposits
for (uint256 i = 0; i < _regularTokenIds.length; i++) {
// First time stakers mint their new LLZ
if (!_exists(_regularTokenIds[i])) {
mintLLZ(_regularTokenIds[i]);
} else {
// Later deposits
_safeTransfer(address(this), (msg.sender), _regularTokenIds[i], "");
emit LockedLizardReMinted(msg.sender, _regularTokenIds[i]);
}
// add the timestamp the lizard was locked, and map user's address to deposited tokenId
originalLockedLizardOwners[_regularTokenIds[i]] = msg.sender;
timeLizardLocked[_regularTokenIds[i]] = block.timestamp;
currentEthlizardStaked++;
}
// Iterate over the genesis Ethlizards deposits
for (uint256 i = 0; i < _genesisTokenIds.length; i++) {
// First time stakers mint their new LLZ, exception is here is the genesis ids
uint256 newGenesisId = _genesisTokenIds[i] + MAXETHLIZARDID;
if (!_exists(newGenesisId)) {
mintLLZ(newGenesisId);
emit LockedLizardMinted(msg.sender, newGenesisId);
} else {
// Later deposits
_safeTransfer(address(this), (msg.sender), newGenesisId, "");
emit LockedLizardReMinted(msg.sender, newGenesisId);
}
// add the timestamp the lizard was locked, and map user's address to deposited newGenesisId
originalLockedLizardOwners[newGenesisId] = msg.sender;
timeLizardLocked[newGenesisId] = block.timestamp;
currentGenesisEthlizardStaked++;
}
/// @notice Calls a global update to the overallShare, then add the new shares
updateGlobalShares();
uint256 totalDeposit =
(_regularTokenIds.length * DEFAULTLIZARDSHARE) + (_genesisTokenIds.length * DEFAULTLIZARDSHARE * 2);
overallShare += totalDeposit;
}
/**
* @notice Allows a user to withdraw their stake
* @dev Users should only be able to withdraw their stake of both Genesis and regular Ethlizard,
* and remove their current raw share from the overallShare.
* @param _regularTokenIds The array of regular Ethlizards tokenIds that is deposited by the caller
* @param _genesisTokenIds The array of genesis Ethlizards tokenIds that is deposited by the caller
*/
function withdrawStake(uint256[] calldata _regularTokenIds, uint256[] calldata _genesisTokenIds) external {
if (msg.sender != tx.origin) {
revert CallerNotAnAddress();
}
/// @dev We need to update the overall share values first to ensure the future rebases are accurate
updateGlobalShares();
// Array of Locked Lizard tokenIds we transfer back to the staking contract
/// @dev Loop for regular Ethlizard tokenIds
for (uint256 i = 0; i < _regularTokenIds.length; i++) {
if (originalLockedLizardOwners[_regularTokenIds[i]] != msg.sender) {
revert CallerNotdepositor({
depositor: originalLockedLizardOwners[_regularTokenIds[i]],
caller: msg.sender
});
}
if (!isLizardWithdrawable(_regularTokenIds[i])) {
revert LizardNotWithdrawable();
}
// Remove the current raw share from the overall total
uint256 regularShare = getCurrentShareRaw(_regularTokenIds[i]);
overallShare = overallShare - regularShare;
// Reset values
timeLizardLocked[_regularTokenIds[i]] = 0;
originalLockedLizardOwners[_regularTokenIds[i]] = address(0);
currentEthlizardStaked--;
// Transfer the token
transferFrom(msg.sender, address(this), _regularTokenIds[i]);
}
for (uint256 i = 0; i < _genesisTokenIds.length; i++) {
if (originalLockedLizardOwners[_genesisTokenIds[i]] != msg.sender) {
revert CallerNotdepositor({
depositor: originalLockedLizardOwners[_genesisTokenIds[i]],
caller: msg.sender
});
}
if (!isLizardWithdrawable(_genesisTokenIds[i])) {
revert LizardNotWithdrawable();
}
// Remove the current raw share from the overall total
uint256 genesisShare = getCurrentShareRaw(_genesisTokenIds[i]) * 2;
overallShare = overallShare - genesisShare;
// Reset values
uint256 genesisId = _genesisTokenIds[i] + MAXETHLIZARDID;
timeLizardLocked[genesisId] = 0;
originalLockedLizardOwners[genesisId] = address(0);
currentGenesisEthlizardStaked--;
// Transfer the token
transferFrom(msg.sender, address(this), _genesisTokenIds[i]);
}
if (_regularTokenIds.length > 0) {
Ethlizards.batchTransferFrom(address(this), msg.sender, _regularTokenIds);
}
if (_genesisTokenIds.length > 0) {
GenesisLiz.batchTransferFrom(address(this), msg.sender, _genesisTokenIds);
}
}
/**
* @notice Allows a user to claim their rewards
* @dev When users unstake their NFT, they will lose their rewards, and the funds
* will be locked into the contract.
* @param _tokenIds Array of Locked Lizard tokenIds
* @param _poolNumber Number of the pool where the user is trying to claim rewards from
*/
function claimReward(uint256[] calldata _tokenIds, uint256 _poolNumber) external {
uint256 claimableRewards;
for (uint256 i = 0; i < _tokenIds.length; i++) {
if (originalLockedLizardOwners[_tokenIds[i]] != msg.sender) {
revert CallerNotdepositor({depositor: originalLockedLizardOwners[_tokenIds[i]], caller: msg.sender});
}
if (isRewardsClaimed(_tokenIds[i], _poolNumber)) {
revert RewardsAlreadyClaimed({tokenId: _tokenIds[i], poolNumber: _poolNumber});
}
if (timeLizardLocked[_tokenIds[i]] >= pool[_poolNumber].time) {
revert TokenStakedAfterPoolCreation({
tokenStakedTime: timeLizardLocked[_tokenIds[i]],
poolTime: pool[_poolNumber].time
});
}
// Rewards calculation
if (_tokenIds[i] > MAXETHLIZARDID) {
// Genesis tokens have 2x more rewards share
claimableRewards += (claimCalculation(_tokenIds[i], _poolNumber)) * 2;
stakePoolClaims[_tokenIds[i]][_poolNumber] = true;
emit RewardsClaimed(_tokenIds[i], (claimCalculation(_tokenIds[i], _poolNumber)) * 2);
} else {
claimableRewards += claimCalculation(_tokenIds[i], _poolNumber);
stakePoolClaims[_tokenIds[i]][_poolNumber] = true;
emit RewardsClaimed(_tokenIds[i], (claimCalculation(_tokenIds[i], _poolNumber)));
}
}
// Transfer the USDC rewards to the user, this function does not require approvals
USDc.transfer(msg.sender, claimableRewards);
}
/// @dev Required implementation for a smart contract to receive ERC721 token
function onERC721Received(address, address, uint256, bytes calldata) external pure returns (bytes4) {
return IERC721Receiver.onERC721Received.selector;
}
/**
* @notice Allows a user to send their Locked Lizard NFT back to the original depositor address
* @dev As the claim function requires the user to hold the LLZ whilst also be the original depositor,
* this function sends their LLZs back to them.
* @param _tokenIds Array of Locked Lizard tokenIds
*/
function retractLockedLizard(uint256[] calldata _tokenIds) external {
for (uint256 i = 0; i < _tokenIds.length; i++) {
if (originalLockedLizardOwners[_tokenIds[i]] != msg.sender) {
revert CallerNotdepositor({depositor: originalLockedLizardOwners[_tokenIds[i]], caller: msg.sender});
}
_safeTransfer(
ownerOf(_tokenIds[i]),
(originalLockedLizardOwners[_tokenIds[i]]),
/// @dev Don't think using msg.sender here is as safe as this
_tokenIds[i],
""
);
}
}
/**
* @notice Allows an approved council address to deposit rewards
* @dev Council members deposit USDC, and once the deposited rewards reach the minResetValue,
* a new pool is created and the currentRewards counter is reset.
* @param _depositAmount Amount of USDC to withdrawal, in 6 DP
*/
function depositRewards(uint256 _depositAmount) external {
if (msg.sender != councilAddress) {
revert AddressNotCouncil({council: councilAddress, caller: msg.sender});
}
USDc.transferFrom(msg.sender, address(this), _depositAmount);
currentRewards += _depositAmount;
totalRewardsInvested += _depositAmount;
if (currentRewards >= minResetValue) {
resetCounter++;
createPool(currentRewards);
}
emit RewardsDeposited(_depositAmount);
}
/**
* @notice Checks if a lizard is withdrawable
* @dev A lizard is withdrawable if it been over minLockedTime since it was deposited
* @param _tokenId TokenId of the lizard
*/
function isLizardWithdrawable(uint256 _tokenId) public view returns (bool) {
if (block.timestamp - timeLizardLocked[_tokenId] >= minLockedTime) {
return true;
} else {
return false;
}
}
/**
* @notice Checks if the rewards of a lizard for a specific pool have been claimed
* @dev Default mapping is false, when claim is made, mapping is updated to be true
* @param _tokenId TokenId of the lizard
* @param _poolNumber The pool number
*/
function isRewardsClaimed(uint256 _tokenId, uint256 _poolNumber) public view returns (bool) {
return stakePoolClaims[_tokenId][_poolNumber];
}
/**
* @dev Overriden approval function to limit contract interactions and marketplace listings
*/
function setApprovalForAll(address operator, bool approved) public override onlyApprovedContracts(operator) {
super.setApprovalForAll(operator, approved);
}
/**
* @dev Overriden approval function to limit contract interactions and marketplace listings
*/
function approve(address operator, uint256 tokenId) public override onlyApprovedContracts(operator) {
super.approve(operator, tokenId);
}
/**
* @dev Flips the state of deposits, only called once.
*/
function setDepositsActive() external onlyOwner {
if (depositsActive) {
revert DepositsAlreadyActive();
}
depositsActive = true;
startTimestamp = block.timestamp;
lastGlobalUpdate = block.timestamp;
}
/**
* @notice This function can only be called by the EthlizardsDAO address
* This should only be used in emergency scenarios
* @param _withdrawalAmount Amount of USDC to withdrawal, in 6 DP
*/
function withdrawalToDAO(uint256 _withdrawalAmount) external {
if (msg.sender != ethlizardsDAO) {
revert AddressNotDAO();
}
USDc.transfer(msg.sender, _withdrawalAmount);
}
/**
* @dev Sets contracts users are allowed to approve contract interactions with
* @param _address Contract address where access is being modified
* @param access The access of the address (false = users aren't allowed to approve, vice versa)
*/
function setAllowedContracts(address _address, bool access) external onlyOwner {
allowedContracts[_address] = access;
emit AllowedContractsUpdated(_address, access);
}
/**
* @dev Sets the reset value. Values are stored in percentages, 20 = 20% of inflation rewards kept per reset
* @param _newShareResetValue New reset value
*/
function setResetShareValue(uint256 _newShareResetValue) external onlyOwner {
if (_newShareResetValue >= 100) {
revert ShareResetTooHigh();
}
resetShareValue = _newShareResetValue;
emit ResetShareValueUpdated(_newShareResetValue);
}
/**
* @dev Whitelists a council address to be able to deposit rewards.
* There can only be one council address at the same time.
* @param _councilAddress The council's address
*/
function setCouncilAddress(address _councilAddress) external onlyOwner {
councilAddress = _councilAddress;
emit CouncilAddressUpdated(_councilAddress);
}
/**
* @dev Updates how long a user needs to stake before they can withdraw their NFT
* @param _minLockedTime The amount of seconds a user needs to stake
*/
function setMinLockedTime(uint256 _minLockedTime) external onlyOwner {
minLockedTime = _minLockedTime;
emit MinLockedTimeUpdated(minLockedTime);
}
/**
* @dev Modifies the minimum value for a reset to occur and a new pool to be created
* @param _newMinResetValue The minimum value for a reset, keep in mind USDC uses 6 decimal points
* so an input of 100,000,000,000 would be 100,000 USDC
*/
function setMinResetValue(uint256 _newMinResetValue) external onlyOwner {
minResetValue = _newMinResetValue;
emit MinResetValueUpdated(_newMinResetValue);
}
/**
* @notice Updates metadata
*/
function setBaseURI(string calldata _baseURI) external onlyOwner {
baseURI = _baseURI;
emit BaseURIUpdated(_baseURI);
}
/**
* @notice Overriden tokenURI to accept ipfs links
*/
function tokenURI(uint256 _tokenId) public view override returns (string memory) {
return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, Strings.toString(_tokenId), ".json")) : "";
}
/**
* @notice Gets the current raw share of an Ethlizard
* @dev See technical documentation for how user's shares are calculated
* @param _tokenId TokenId for which share is being calculated
*/
function getCurrentShareRaw(uint256 _tokenId) public view returns (uint256) {
// The current raw share which gets iterated over throughout the code
uint256 currentShareRaw;
// Counter for the current pool
uint256 currPool;
// Counter for the previous pool
uint256 prevPool;
// Case A: If there is only 1 pool, we do not need to factor into resets.
// Case B: If no pools have been created after the user has staked, we do not need to factor in resets.
if ((pool.length == 0) || (pool[pool.length - 1].time) < timeLizardLocked[_tokenId]) {
currentShareRaw = calculateShareFromTime(block.timestamp, timeLizardLocked[_tokenId], DEFAULTLIZARDSHARE);
return currentShareRaw;
} // Case C: One or more pools created, but the user was staked before the creation of all of them.
else if (timeLizardLocked[_tokenId] <= pool[0].time) {
// Will always be the first pool because the the user is staked before creation of any pools
currentShareRaw = calculateShareFromTime(pool[0].time, timeLizardLocked[_tokenId], DEFAULTLIZARDSHARE);
currentShareRaw = resetShareRaw(currentShareRaw);
// Setting the values for the loop
currPool = 1;
prevPool = currPool - 1;
} // Case D: User was staked between 2 pools
else {
// Iterate through the pools and set currPool to the next pool created after user is staked.
currPool = pool.length - 1;
prevPool = currPool - 1;
while (timeLizardLocked[_tokenId] < pool[prevPool].time) {
currPool--;
prevPool--;
}
// Calculate first share which is done by the first pool created after token staked
currentShareRaw =
calculateShareFromTime(pool[currPool].time, timeLizardLocked[_tokenId], DEFAULTLIZARDSHARE);
currentShareRaw = resetShareRaw(currentShareRaw);
currPool++;
prevPool++;
}
// Counter for the last reset
uint256 lastReset = pool.length - 1;
// Looping over the pools
while (currPool <= lastReset) {
currentShareRaw = calculateShareFromTime(pool[currPool].time, pool[prevPool].time, currentShareRaw);
currentShareRaw = resetShareRaw(currentShareRaw);
currPool++;
prevPool++;
}
// Finding the inflation between the current time and the last pool's reset's time.
currentShareRaw = calculateShareFromTime(block.timestamp, pool[lastReset].time, currentShareRaw);
return currentShareRaw;
}
/**
* @notice Creates a new pool for rewards
* @dev A new pool is created everytime a reset occurs, and they contain a user's rewards.
* Reset of user's shares and inflation occurs after the values are pushed to the pool.
*/
function createPool(uint256 _value) internal {
updateGlobalShares();
pool.push(Pool(block.timestamp, _value, overallShare));
currentRewards = 0;
resetGlobalShares();
}
/**
* @notice Resets the inflation for a user's shares
* @dev See technical documentation for how shares are calculated
*/
function resetGlobalShares() internal {
uint256 nonInflatedOverallShare =
(currentEthlizardStaked * DEFAULTLIZARDSHARE) + (currentGenesisEthlizardStaked * DEFAULTLIZARDSHARE * 2);
overallShare = (((overallShare - nonInflatedOverallShare) * resetShareValue) / 100) + (nonInflatedOverallShare);
}
/**
* @notice Updates the global counter shares
* @dev See technical documentation for how shares are calculated
*/
function updateGlobalShares() internal {
uint256 requiredRebases = ((block.timestamp - lastGlobalUpdate) / 1 days);
if (requiredRebases >= 1) {
overallShare = ((overallShare * calculateRebasePercentage(requiredRebases)) / 1e18);
rebaseCounter += requiredRebases;
lastGlobalUpdate += requiredRebases * 1 days;
}
}
/**
* @notice Calculates the rewards of a tokenId for the specific pool
* @param _tokenId The tokenId which rewards are being claimed
* @param _poolNumber The pool in which rewards are being claimed from
*/
function claimCalculation(uint256 _tokenId, uint256 _poolNumber) public view returns (uint256 owedAmount) {
// The current raw share which gets iterated over throughout the code
uint256 currentShareRaw;
// Counter for the current pool
uint256 currPool;
// Counter for the previous pool
uint256 prevPool;
// Case A: If there is only 1 pool, we do not need to factor into any resets
if (_poolNumber == 0) {
currentShareRaw =
calculateShareFromTime(pool[_poolNumber].time, timeLizardLocked[_tokenId], DEFAULTLIZARDSHARE);
owedAmount = (currentShareRaw * pool[_poolNumber].value) / pool[_poolNumber].currentGlobalShare;
return owedAmount;
} // Case B: One or more pools created, but the user was staked before the creation of all of them.
else if (timeLizardLocked[_tokenId] <= pool[0].time) {
// Second case runs if there has been at least 1 reset
// and the user was staked before the first reset
currentShareRaw = calculateShareFromTime(pool[0].time, timeLizardLocked[_tokenId], DEFAULTLIZARDSHARE);
currPool = 1;
prevPool = currPool - 1;
} // Case C: User was staked between 2 pools
else {
// Iterate through the pools and set currPool to the next pool created after the user has staked.
currPool = pool.length - 1;
prevPool = currPool - 1;
while (timeLizardLocked[_tokenId] < pool[prevPool].time) {
currPool--;
prevPool--;
}
// Calculate first share which is done by the first pool created after token staked
currentShareRaw =
calculateShareFromTime(pool[currPool].time, timeLizardLocked[_tokenId], DEFAULTLIZARDSHARE);
currPool++;
prevPool++;
}
// Loop to apply inflations
while (currPool <= _poolNumber) {
currentShareRaw = resetShareRaw(currentShareRaw);
currentShareRaw = calculateShareFromTime(pool[currPool].time, pool[prevPool].time, currentShareRaw);
prevPool++;
currPool++;
}
// Calculate the rewards the user can claim
owedAmount = (currentShareRaw * pool[_poolNumber].value) / pool[_poolNumber].currentGlobalShare;
return owedAmount;
}
/**
* @notice Takes 2 different unix timestamps and returns the inflation-applied raw share of it.
* If 0 is called from requiredRebases, the rebase percentage will just be 1.
*/
function calculateShareFromTime(uint256 _currentTime, uint256 _previousTime, uint256 _rawShare)
internal
view
returns (uint256)
{
uint256 requiredRebases = ((_currentTime - startTimestamp) - (_previousTime - startTimestamp)) / 1 days;
uint256 result = (_rawShare * calculateRebasePercentage(requiredRebases)) / 1e18;
return result;
}
/**
* @notice We calculate the 1.005^_requiredRebases via this function.
* @dev See technical documents for how maths is calculated.
* We apply log laws to a compound interest formula which allows us to calculate
* values in big number form without overflow errors
*/
function calculateRebasePercentage(uint256 _requiredRebases) internal view returns (uint256) {
// Conversion of the uint256 rebases to int128 form
// Divide by 2^64 as the converted result is in 64.64-bit fixed point form
int128 requiredRebasesConverted = ABDKMath64x64.fromUInt(_requiredRebases) / (2 ** 64);
// Using compound formula specified in technical documents
int128 calculation = (ABDKMath64x64.log_2(nominator) * requiredRebasesConverted);
int128 result = (ABDKMath64x64.exp_2(calculation) * 1e16);
uint256 uintResult = ABDKMath64x64.toUInt(result) * 1e2;
return uintResult;
}
/**
* @dev Maths function to apply a reset to a user's shares
* @param _currentShareRaw The raw share where inflation is being slashed
*/
function resetShareRaw(uint256 _currentShareRaw) internal view returns (uint256) {
return (((_currentShareRaw - DEFAULTLIZARDSHARE) * resetShareValue) / 100) + (DEFAULTLIZARDSHARE);
}
/**
* @notice Calls ERC721's mint function
* @param _tokenId TokenId being minted
*/
function mintLLZ(uint256 _tokenId) internal {
_mint(msg.sender, _tokenId);
emit LockedLizardMinted(msg.sender, _tokenId);
}
////////////
// Errors //
////////////
// User is trying to approve contract interactions with a contract that hasn't been whitelisted
error NotWhitelistedContract();
// Deposits are not enabled yet
error DepositsInactive();
// The address isn't the same address as the depositor
error CallerNotdepositor(address depositor, address caller);
// The lizard has not passed the minimum lockup term and is not withdrawable
error LizardNotWithdrawable();
// Rewards have already been claimed for the lizard
error RewardsAlreadyClaimed(uint256 tokenId, uint256 poolNumber);
// Address isn't the council
error AddressNotCouncil(address council, address caller);
// Address isn't the Ethlizards DAO address
error AddressNotDAO();
// _newShareResetValue value cannot be more than 100%
error ShareResetTooHigh();
// Deposits are already active
error DepositsAlreadyActive();
// Tokens must have been staked prior to a pools creation
error TokenStakedAfterPoolCreation(uint256 tokenStakedTime, uint256 poolTime);
// No contract interactions
error CallerNotAnAddress();
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)
pragma solidity ^0.8.0;
/**
* @dev Standard math utilities missing in the Solidity language.
*/
library Math {
enum Rounding {
Down, // Toward negative infinity
Up, // Toward infinity
Zero // Toward zero
}
/**
* @dev Returns the largest of two numbers.
*/
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
/**
* @dev Returns the smallest of two numbers.
*/
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
/**
* @dev Returns the average of two numbers. The result is rounded towards
* zero.
*/
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow.
return (a & b) + (a ^ b) / 2;
}
/**
* @dev Returns the ceiling of the division of two numbers.
*
* This differs from standard division with `/` in that it rounds up instead
* of rounding down.
*/
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b - 1) / b can overflow on addition, so we distribute.
return a == 0 ? 0 : (a - 1) / b + 1;
}
/**
* @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
* @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
* with further edits by Uniswap Labs also under MIT license.
*/
function mulDiv(
uint256 x,
uint256 y,
uint256 denominator
) internal pure returns (uint256 result) {
unchecked {
// 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
// use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
// variables such that product = prod1 * 2^256 + prod0.
uint256 prod0; // Least significant 256 bits of the product
uint256 prod1; // Most significant 256 bits of the product
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
// Handle non-overflow cases, 256 by 256 division.
if (prod1 == 0) {
return prod0 / denominator;
}
// Make sure the result is less than 2^256. Also prevents denominator == 0.
require(denominator > prod1);
///////////////////////////////////////////////
// 512 by 256 division.
///////////////////////////////////////////////
// Make division exact by subtracting the remainder from [prod1 prod0].
uint256 remainder;
assembly {
// Compute remainder using mulmod.
remainder := mulmod(x, y, denominator)
// Subtract 256 bit number from 512 bit number.
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
// Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
// See https://cs.stackexchange.com/q/138556/92363.
// Does not overflow because the denominator cannot be zero at this stage in the function.
uint256 twos = denominator & (~denominator + 1);
assembly {
// Divide denominator by twos.
denominator := div(denominator, twos)
// Divide [prod1 prod0] by twos.
prod0 := div(prod0, twos)
// Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
twos := add(div(sub(0, twos), twos), 1)
}
// Shift in bits from prod1 into prod0.
prod0 |= prod1 * twos;
// Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
// that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
// four bits. That is, denominator * inv = 1 mod 2^4.
uint256 inverse = (3 * denominator) ^ 2;
// Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
// in modular arithmetic, doubling the correct bits in each step.
inverse *= 2 - denominator * inverse; // inverse mod 2^8
inverse *= 2 - denominator * inverse; // inverse mod 2^16
inverse *= 2 - denominator * inverse; // inverse mod 2^32
inverse *= 2 - denominator * inverse; // inverse mod 2^64
inverse *= 2 - denominator * inverse; // inverse mod 2^128
inverse *= 2 - denominator * inverse; // inverse mod 2^256
// Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
// This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
// less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
// is no longer required.
result = prod0 * inverse;
return result;
}
}
/**
* @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
*/
function mulDiv(
uint256 x,
uint256 y,
uint256 denominator,
Rounding rounding
) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
/**
* @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
*
* Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
*/
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
// For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
//
// We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
// `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
//
// This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
// → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
// → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
//
// Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
uint256 result = 1 << (log2(a) >> 1);
// At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
// since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
// every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
// into the expected uint128 result.
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
/**
* @notice Calculates sqrt(a), following the selected rounding direction.
*/
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
}
}
/**
* @dev Return the log in base 2, rounded down, of a positive value.
* Returns 0 if given 0.
*/
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 2, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
}
}
/**
* @dev Return the log in base 10, rounded down, of a positive value.
* Returns 0 if given 0.
*/
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10**64) {
value /= 10**64;
result += 64;
}
if (value >= 10**32) {
value /= 10**32;
result += 32;
}
if (value >= 10**16) {
value /= 10**16;
result += 16;
}
if (value >= 10**8) {
value /= 10**8;
result += 8;
}
if (value >= 10**4) {
value /= 10**4;
result += 4;
}
if (value >= 10**2) {
value /= 10**2;
result += 2;
}
if (value >= 10**1) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 10, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
}
}
/**
* @dev Return the log in base 256, rounded down, of a positive value.
* Returns 0 if given 0.
*
* Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
*/
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 10, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
}
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)
pragma solidity ^0.8.0;
import "../utils/Context.sol";
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
_transferOwnership(_msgSender());
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
_checkOwner();
_;
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
return _owner;
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)
pragma solidity ^0.8.0;
import "./math/Math.sol";
/**
* @dev String operations.
*/
library Strings {
bytes16 private constant _SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = Math.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
/// @solidity memory-safe-assembly
assembly {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
/// @solidity memory-safe-assembly
assembly {
mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
unchecked {
return toHexString(value, Math.log256(value) + 1);
}
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
/**
* @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
*/
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
}
{
"compilationTarget": {
"src/LizardLounge.sol": "LizardLounge"
},
"evmVersion": "london",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs"
},
"optimizer": {
"enabled": true,
"runs": 20000
},
"remappings": [
":@openzeppelin/=lib/openzeppelin-contracts/",
":abdk-libraries-solidity/=lib/abdk-libraries-solidity/",
":ds-test/=lib/forge-std/lib/ds-test/src/",
":forge-std/=lib/forge-std/src/"
]
}[{"inputs":[{"internalType":"contract IEthlizards","name":"ethLizardsAddress","type":"address"},{"internalType":"contract IGenesisEthlizards","name":"genesisLizaddress","type":"address"},{"internalType":"contract IUSDC","name":"USDCAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"council","type":"address"},{"internalType":"address","name":"caller","type":"address"}],"name":"AddressNotCouncil","type":"error"},{"inputs":[],"name":"AddressNotDAO","type":"error"},{"inputs":[],"name":"CallerNotAnAddress","type":"error"},{"inputs":[{"internalType":"address","name":"depositor","type":"address"},{"internalType":"address","name":"caller","type":"address"}],"name":"CallerNotdepositor","type":"error"},{"inputs":[],"name":"DepositsAlreadyActive","type":"error"},{"inputs":[],"name":"DepositsInactive","type":"error"},{"inputs":[],"name":"LizardNotWithdrawable","type":"error"},{"inputs":[],"name":"NotWhitelistedContract","type":"error"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"poolNumber","type":"uint256"}],"name":"RewardsAlreadyClaimed","type":"error"},{"inputs":[],"name":"ShareResetTooHigh","type":"error"},{"inputs":[{"internalType":"uint256","name":"tokenStakedTime","type":"uint256"},{"internalType":"uint256","name":"poolTime","type":"uint256"}],"name":"TokenStakedAfterPoolCreation","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"allowedContract","type":"address"},{"indexed":false,"internalType":"bool","name":"status","type":"bool"}],"name":"AllowedContractsUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"newBaseuri","type":"string"}],"name":"BaseURIUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"councilAddress","type":"address"}],"name":"CouncilAddressUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"mintedAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"mintedId","type":"uint256"}],"name":"LockedLizardMinted","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"ownerAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"lizardId","type":"uint256"}],"name":"LockedLizardReMinted","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"minLockedTime","type":"uint256"}],"name":"MinLockedTimeUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newMinResetValue","type":"uint256"}],"name":"MinResetValueUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newResetShareValue","type":"uint256"}],"name":"ResetShareValueUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"rewardsClaimed","type":"uint256"}],"name":"RewardsClaimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"depositAmount","type":"uint256"}],"name":"RewardsDeposited","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"Ethlizards","outputs":[{"internalType":"contract IEthlizards","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"GenesisLiz","outputs":[{"internalType":"contract IGenesisEthlizards","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"USDc","outputs":[{"internalType":"contract IUSDC","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"allowedContracts","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"uint256","name":"_poolNumber","type":"uint256"}],"name":"claimCalculation","outputs":[{"internalType":"uint256","name":"owedAmount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_tokenIds","type":"uint256[]"},{"internalType":"uint256","name":"_poolNumber","type":"uint256"}],"name":"claimReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"councilAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"currentEthlizardStaked","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"currentGenesisEthlizardStaked","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"currentRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_depositAmount","type":"uint256"}],"name":"depositRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_regularTokenIds","type":"uint256[]"},{"internalType":"uint256[]","name":"_genesisTokenIds","type":"uint256[]"}],"name":"depositStake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"depositsActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ethlizardsDAO","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"getCurrentShareRaw","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"isLizardWithdrawable","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"uint256","name":"_poolNumber","type":"uint256"}],"name":"isRewardsClaimed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastGlobalUpdate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minLockedTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minResetValue","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nominator","outputs":[{"internalType":"int128","name":"","type":"int128"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"originalLockedLizardOwners","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"overallShare","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rebaseCounter","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"resetCounter","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"resetShareValue","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_tokenIds","type":"uint256[]"}],"name":"retractLockedLizard","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"},{"internalType":"bool","name":"access","type":"bool"}],"name":"setAllowedContracts","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_baseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_councilAddress","type":"address"}],"name":"setCouncilAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"setDepositsActive","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_minLockedTime","type":"uint256"}],"name":"setMinLockedTime","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newMinResetValue","type":"uint256"}],"name":"setMinResetValue","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newShareResetValue","type":"uint256"}],"name":"setResetShareValue","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"timeLizardLocked","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalRewardsInvested","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_regularTokenIds","type":"uint256[]"},{"internalType":"uint256[]","name":"_genesisTokenIds","type":"uint256[]"}],"name":"withdrawStake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_withdrawalAmount","type":"uint256"}],"name":"withdrawalToDAO","outputs":[],"stateMutability":"nonpayable","type":"function"}]