// SPDX-License-Identifier: MITpragmasolidity ^0.8.4;/// @notice Arithmetic library with operations for fixed-point numbers./// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/FixedPointMathLib.sol)/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/FixedPointMathLib.sol)libraryFixedPointMathLib{
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* CUSTOM ERRORS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev The operation failed, as the output exceeds the maximum value of uint256.errorExpOverflow();
/// @dev The operation failed, as the output exceeds the maximum value of uint256.errorFactorialOverflow();
/// @dev The operation failed, due to an overflow.errorRPowOverflow();
/// @dev The mantissa is too big to fit.errorMantissaOverflow();
/// @dev The operation failed, due to an multiplication overflow.errorMulWadFailed();
/// @dev The operation failed, due to an multiplication overflow.errorSMulWadFailed();
/// @dev The operation failed, either due to a multiplication overflow, or a division by a zero.errorDivWadFailed();
/// @dev The operation failed, either due to a multiplication overflow, or a division by a zero.errorSDivWadFailed();
/// @dev The operation failed, either due to a multiplication overflow, or a division by a zero.errorMulDivFailed();
/// @dev The division failed, as the denominator is zero.errorDivFailed();
/// @dev The full precision multiply-divide operation failed, either due/// to the result being larger than 256 bits, or a division by a zero.errorFullMulDivFailed();
/// @dev The output is undefined, as the input is less-than-or-equal to zero.errorLnWadUndefined();
/// @dev The input outside the acceptable domain.errorOutOfDomain();
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* CONSTANTS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev The scalar of ETH and most ERC20s.uint256internalconstant WAD =1e18;
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* SIMPLIFIED FIXED POINT OPERATIONS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev Equivalent to `(x * y) / WAD` rounded down.functionmulWad(uint256 x, uint256 y) internalpurereturns (uint256 z) {
/// @solidity memory-safe-assemblyassembly {
// Equivalent to `require(y == 0 || x <= type(uint256).max / y)`.ifgt(x, div(not(0), y)) {
if y {
mstore(0x00, 0xbac65e5b) // `MulWadFailed()`.revert(0x1c, 0x04)
}
}
z :=div(mul(x, y), WAD)
}
}
/// @dev Equivalent to `(x * y) / WAD` rounded down.functionsMulWad(int256 x, int256 y) internalpurereturns (int256 z) {
/// @solidity memory-safe-assemblyassembly {
z :=mul(x, y)
// Equivalent to `require((x == 0 || z / x == y) && !(x == -1 && y == type(int256).min))`.ifiszero(gt(or(iszero(x), eq(sdiv(z, x), y)), lt(not(x), eq(y, shl(255, 1))))) {
mstore(0x00, 0xedcd4dd4) // `SMulWadFailed()`.revert(0x1c, 0x04)
}
z :=sdiv(z, WAD)
}
}
/// @dev Equivalent to `(x * y) / WAD` rounded down, but without overflow checks.functionrawMulWad(uint256 x, uint256 y) internalpurereturns (uint256 z) {
/// @solidity memory-safe-assemblyassembly {
z :=div(mul(x, y), WAD)
}
}
/// @dev Equivalent to `(x * y) / WAD` rounded down, but without overflow checks.functionrawSMulWad(int256 x, int256 y) internalpurereturns (int256 z) {
/// @solidity memory-safe-assemblyassembly {
z :=sdiv(mul(x, y), WAD)
}
}
/// @dev Equivalent to `(x * y) / WAD` rounded up.functionmulWadUp(uint256 x, uint256 y) internalpurereturns (uint256 z) {
/// @solidity memory-safe-assemblyassembly {
z :=mul(x, y)
// Equivalent to `require(y == 0 || x <= type(uint256).max / y)`.ifiszero(eq(div(z, y), x)) {
if y {
mstore(0x00, 0xbac65e5b) // `MulWadFailed()`.revert(0x1c, 0x04)
}
}
z :=add(iszero(iszero(mod(z, WAD))), div(z, WAD))
}
}
/// @dev Equivalent to `(x * y) / WAD` rounded up, but without overflow checks.functionrawMulWadUp(uint256 x, uint256 y) internalpurereturns (uint256 z) {
/// @solidity memory-safe-assemblyassembly {
z :=add(iszero(iszero(mod(mul(x, y), WAD))), div(mul(x, y), WAD))
}
}
/// @dev Equivalent to `(x * WAD) / y` rounded down.functiondivWad(uint256 x, uint256 y) internalpurereturns (uint256 z) {
/// @solidity memory-safe-assemblyassembly {
// Equivalent to `require(y != 0 && x <= type(uint256).max / WAD)`.ifiszero(mul(y, lt(x, add(1, div(not(0), WAD))))) {
mstore(0x00, 0x7c5f487d) // `DivWadFailed()`.revert(0x1c, 0x04)
}
z :=div(mul(x, WAD), y)
}
}
/// @dev Equivalent to `(x * WAD) / y` rounded down.functionsDivWad(int256 x, int256 y) internalpurereturns (int256 z) {
/// @solidity memory-safe-assemblyassembly {
z :=mul(x, WAD)
// Equivalent to `require(y != 0 && ((x * WAD) / WAD == x))`.ifiszero(mul(y, eq(sdiv(z, WAD), x))) {
mstore(0x00, 0x5c43740d) // `SDivWadFailed()`.revert(0x1c, 0x04)
}
z :=sdiv(z, y)
}
}
/// @dev Equivalent to `(x * WAD) / y` rounded down, but without overflow and divide by zero checks.functionrawDivWad(uint256 x, uint256 y) internalpurereturns (uint256 z) {
/// @solidity memory-safe-assemblyassembly {
z :=div(mul(x, WAD), y)
}
}
/// @dev Equivalent to `(x * WAD) / y` rounded down, but without overflow and divide by zero checks.functionrawSDivWad(int256 x, int256 y) internalpurereturns (int256 z) {
/// @solidity memory-safe-assemblyassembly {
z :=sdiv(mul(x, WAD), y)
}
}
/// @dev Equivalent to `(x * WAD) / y` rounded up.functiondivWadUp(uint256 x, uint256 y) internalpurereturns (uint256 z) {
/// @solidity memory-safe-assemblyassembly {
// Equivalent to `require(y != 0 && x <= type(uint256).max / WAD)`.ifiszero(mul(y, lt(x, add(1, div(not(0), WAD))))) {
mstore(0x00, 0x7c5f487d) // `DivWadFailed()`.revert(0x1c, 0x04)
}
z :=add(iszero(iszero(mod(mul(x, WAD), y))), div(mul(x, WAD), y))
}
}
/// @dev Equivalent to `(x * WAD) / y` rounded up, but without overflow and divide by zero checks.functionrawDivWadUp(uint256 x, uint256 y) internalpurereturns (uint256 z) {
/// @solidity memory-safe-assemblyassembly {
z :=add(iszero(iszero(mod(mul(x, WAD), y))), div(mul(x, WAD), y))
}
}
/// @dev Equivalent to `x` to the power of `y`./// because `x ** y = (e ** ln(x)) ** y = e ** (ln(x) * y)`./// Note: This function is an approximation.functionpowWad(int256 x, int256 y) internalpurereturns (int256) {
// Using `ln(x)` means `x` must be greater than 0.return expWad((lnWad(x) * y) /int256(WAD));
}
/// @dev Returns `exp(x)`, denominated in `WAD`./// Credit to Remco Bloemen under MIT license: https://2π.com/22/exp-ln/// Note: This function is an approximation. Monotonically increasing.functionexpWad(int256 x) internalpurereturns (int256 r) {
unchecked {
// When the result is less than 0.5 we return zero.// This happens when `x <= (log(1e-18) * 1e18) ~ -4.15e19`.if (x <=-41446531673892822313) return r;
/// @solidity memory-safe-assemblyassembly {
// When the result is greater than `(2**255 - 1) / 1e18` we can not represent it as// an int. This happens when `x >= floor(log((2**255 - 1) / 1e18) * 1e18) ≈ 135`.ifiszero(slt(x, 135305999368893231589)) {
mstore(0x00, 0xa37bfec9) // `ExpOverflow()`.revert(0x1c, 0x04)
}
}
// `x` is now in the range `(-42, 136) * 1e18`. Convert to `(-42, 136) * 2**96`// for more intermediate precision and a binary basis. This base conversion// is a multiplication by 1e18 / 2**96 = 5**18 / 2**78.
x = (x <<78) /5**18;
// Reduce range of x to (-½ ln 2, ½ ln 2) * 2**96 by factoring out powers// of two such that exp(x) = exp(x') * 2**k, where k is an integer.// Solving this gives k = round(x / log(2)) and x' = x - k * log(2).int256 k = ((x <<96) /54916777467707473351141471128+2**95) >>96;
x = x - k *54916777467707473351141471128;
// `k` is in the range `[-61, 195]`.// Evaluate using a (6, 7)-term rational approximation.// `p` is made monic, we'll multiply by a scale factor later.int256 y = x +1346386616545796478920950773328;
y = ((y * x) >>96) +57155421227552351082224309758442;
int256 p = y + x -94201549194550492254356042504812;
p = ((p * y) >>96) +28719021644029726153956944680412240;
p = p * x + (4385272521454847904659076985693276<<96);
// We leave `p` in `2**192` basis so we don't need to scale it back up for the division.int256 q = x -2855989394907223263936484059900;
q = ((q * x) >>96) +50020603652535783019961831881945;
q = ((q * x) >>96) -533845033583426703283633433725380;
q = ((q * x) >>96) +3604857256930695427073651918091429;
q = ((q * x) >>96) -14423608567350463180887372962807573;
q = ((q * x) >>96) +26449188498355588339934803723976023;
/// @solidity memory-safe-assemblyassembly {
// Div in assembly because solidity adds a zero check despite the unchecked.// The q polynomial won't have zeros in the domain as all its roots are complex.// No scaling is necessary because p is already `2**96` too large.
r :=sdiv(p, q)
}
// r should be in the range `(0.09, 0.25) * 2**96`.// We now need to multiply r by:// - The scale factor `s ≈ 6.031367120`.// - The `2**k` factor from the range reduction.// - The `1e18 / 2**96` factor for base conversion.// We do this all at once, with an intermediate result in `2**213`// basis, so the final right shift is always by a positive amount.
r =int256(
(uint256(r) *3822833074963236453042738258902158003155416615667) >>uint256(195- k)
);
}
}
/// @dev Returns `ln(x)`, denominated in `WAD`./// Credit to Remco Bloemen under MIT license: https://2π.com/22/exp-ln/// Note: This function is an approximation. Monotonically increasing.functionlnWad(int256 x) internalpurereturns (int256 r) {
/// @solidity memory-safe-assemblyassembly {
// We want to convert `x` from `10**18` fixed point to `2**96` fixed point.// We do this by multiplying by `2**96 / 10**18`. But since// `ln(x * C) = ln(x) + ln(C)`, we can simply do nothing here// and add `ln(2**96 / 10**18)` at the end.// Compute `k = log2(x) - 96`, `r = 159 - k = 255 - log2(x) = 255 ^ log2(x)`.
r :=shl(7, lt(0xffffffffffffffffffffffffffffffff, x))
r :=or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))
r :=or(r, shl(5, lt(0xffffffff, shr(r, x))))
r :=or(r, shl(4, lt(0xffff, shr(r, x))))
r :=or(r, shl(3, lt(0xff, shr(r, x))))
// We place the check here for more optimal stack operations.ifiszero(sgt(x, 0)) {
mstore(0x00, 0x1615e638) // `LnWadUndefined()`.revert(0x1c, 0x04)
}
// forgefmt: disable-next-item
r :=xor(r, byte(and(0x1f, shr(shr(r, x), 0x8421084210842108cc6318c6db6d54be)),
0xf8f9f9faf9fdfafbf9fdfcfdfafbfcfef9fafdfafcfcfbfefafafcfbffffffff))
// Reduce range of x to (1, 2) * 2**96// ln(2^k * x) = k * ln(2) + ln(x)
x :=shr(159, shl(r, x))
// Evaluate using a (8, 8)-term rational approximation.// `p` is made monic, we will multiply by a scale factor later.// forgefmt: disable-next-itemlet p :=sub( // This heavily nested expression is to avoid stack-too-deep for via-ir.sar(96, mul(add(43456485725739037958740375743393,
sar(96, mul(add(24828157081833163892658089445524,
sar(96, mul(add(3273285459638523848632254066296,
x), x))), x))), x)), 11111509109440967052023855526967)
p :=sub(sar(96, mul(p, x)), 45023709667254063763336534515857)
p :=sub(sar(96, mul(p, x)), 14706773417378608786704636184526)
p :=sub(mul(p, x), shl(96, 795164235651350426258249787498))
// We leave `p` in `2**192` basis so we don't need to scale it back up for the division.// `q` is monic by convention.let q :=add(5573035233440673466300451813936, x)
q :=add(71694874799317883764090561454958, sar(96, mul(x, q)))
q :=add(283447036172924575727196451306956, sar(96, mul(x, q)))
q :=add(401686690394027663651624208769553, sar(96, mul(x, q)))
q :=add(204048457590392012362485061816622, sar(96, mul(x, q)))
q :=add(31853899698501571402653359427138, sar(96, mul(x, q)))
q :=add(909429971244387300277376558375, sar(96, mul(x, q)))
// `p / q` is in the range `(0, 0.125) * 2**96`.// Finalization, we need to:// - Multiply by the scale factor `s = 5.549…`.// - Add `ln(2**96 / 10**18)`.// - Add `k * ln(2)`.// - Multiply by `10**18 / 2**96 = 5**18 >> 78`.// The q polynomial is known not to have zeros in the domain.// No scaling required because p is already `2**96` too large.
p :=sdiv(p, q)
// Multiply by the scaling factor: `s * 5**18 * 2**96`, base is now `5**18 * 2**192`.
p :=mul(1677202110996718588342820967067443963516166, p)
// Add `ln(2) * k * 5**18 * 2**192`.// forgefmt: disable-next-item
p :=add(mul(16597577552685614221487285958193947469193820559219878177908093499208371, sub(159, r)), p)
// Add `ln(2**96 / 10**18) * 5**18 * 2**192`.
p :=add(600920179829731861736702779321621459595472258049074101567377883020018308, p)
// Base conversion: mul `2**18 / 2**192`.
r :=sar(174, p)
}
}
/// @dev Returns `W_0(x)`, denominated in `WAD`./// See: https://en.wikipedia.org/wiki/Lambert_W_function/// a.k.a. Product log function. This is an approximation of the principal branch./// Note: This function is an approximation. Monotonically increasing.functionlambertW0Wad(int256 x) internalpurereturns (int256 w) {
// forgefmt: disable-next-itemunchecked {
if ((w = x) <=-367879441171442322) revert OutOfDomain(); // `x` less than `-1/e`.
(int256 wad, int256 p) = (int256(WAD), x);
uint256 c; // Whether we need to avoid catastrophic cancellation.uint256 i =4; // Number of iterations.if (w <=0x1ffffffffffff) {
if (-0x4000000000000<= w) {
i =1; // Inputs near zero only take one step to converge.
} elseif (w <=-0x3ffffffffffffff) {
i =32; // Inputs near `-1/e` take very long to converge.
}
} elseif (uint256(w >>63) ==uint256(0)) {
/// @solidity memory-safe-assemblyassembly {
// Inline log2 for more performance, since the range is small.let v :=shr(49, w)
let l :=shl(3, lt(0xff, v))
l :=add(or(l, byte(and(0x1f, shr(shr(l, v), 0x8421084210842108cc6318c6db6d54be)),
0x0706060506020504060203020504030106050205030304010505030400000000)), 49)
w :=sdiv(shl(l, 7), byte(sub(l, 31), 0x0303030303030303040506080c13))
c :=gt(l, 60)
i :=add(2, add(gt(l, 53), c))
}
} else {
int256 ll = lnWad(w = lnWad(w));
/// @solidity memory-safe-assemblyassembly {
// `w = ln(x) - ln(ln(x)) + b * ln(ln(x)) / ln(x)`.
w :=add(sdiv(mul(ll, 1023715080943847266), w), sub(w, ll))
i :=add(3, iszero(shr(68, x)))
c :=iszero(shr(143, x))
}
if (c ==uint256(0)) {
do { // If `x` is big, use Newton's so that intermediate values won't overflow.int256 e = expWad(w);
/// @solidity memory-safe-assemblyassembly {
let t :=mul(w, div(e, wad))
w :=sub(w, sdiv(sub(t, x), div(add(e, t), wad)))
}
if (p <= w) break;
p = w;
} while (--i !=uint256(0));
/// @solidity memory-safe-assemblyassembly {
w :=sub(w, sgt(w, 2))
}
return w;
}
}
do { // Otherwise, use Halley's for faster convergence.int256 e = expWad(w);
/// @solidity memory-safe-assemblyassembly {
let t :=add(w, wad)
let s :=sub(mul(w, e), mul(x, wad))
w :=sub(w, sdiv(mul(s, wad), sub(mul(e, t), sdiv(mul(add(t, wad), s), add(t, t)))))
}
if (p <= w) break;
p = w;
} while (--i != c);
/// @solidity memory-safe-assemblyassembly {
w :=sub(w, sgt(w, 2))
}
// For certain ranges of `x`, we'll use the quadratic-rate recursive formula of// R. Iacono and J.P. Boyd for the last iteration, to avoid catastrophic cancellation.if (c ==uint256(0)) return w;
int256 t = w |1;
/// @solidity memory-safe-assemblyassembly {
x :=sdiv(mul(x, wad), t)
}
x = (t * (wad + lnWad(x)));
/// @solidity memory-safe-assemblyassembly {
w :=sdiv(x, add(wad, t))
}
}
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* GENERAL NUMBER UTILITIES *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev Calculates `floor(x * y / d)` with full precision./// Throws if result overflows a uint256 or when `d` is zero./// Credit to Remco Bloemen under MIT license: https://2π.com/21/muldivfunctionfullMulDiv(uint256 x, uint256 y, uint256 d) internalpurereturns (uint256 result) {
/// @solidity memory-safe-assemblyassembly {
// 512-bit multiply `[p1 p0] = x * y`.// Compute the product mod `2**256` and mod `2**256 - 1`// then use the Chinese Remainder Theorem to reconstruct// the 512 bit result. The result is stored in two 256// variables such that `product = p1 * 2**256 + p0`.// Temporarily use `result` as `p0` to save gas.
result :=mul(x, y) // Lower 256 bits of `x * y`.for {} 1 {} {
// If overflows.ifiszero(mul(or(iszero(x), eq(div(result, x), y)), d)) {
let mm :=mulmod(x, y, not(0))
let p1 :=sub(mm, add(result, lt(mm, result))) // Upper 256 bits of `x * y`./*------------------- 512 by 256 division --------------------*/// Make division exact by subtracting the remainder from `[p1 p0]`.let r :=mulmod(x, y, d) // Compute remainder using mulmod.let t :=and(d, sub(0, d)) // The least significant bit of `d`. `t >= 1`.// Make sure the result is less than `2**256`. Also prevents `d == 0`.// Placing the check here seems to give more optimal stack operations.ifiszero(gt(d, p1)) {
mstore(0x00, 0xae47f702) // `FullMulDivFailed()`.revert(0x1c, 0x04)
}
d :=div(d, t) // Divide `d` by `t`, which is a power of two.// Invert `d mod 2**256`// Now that `d` is an odd number, it has an inverse// modulo `2**256` such that `d * inv = 1 mod 2**256`.// Compute the inverse by starting with a seed that is correct// correct for four bits. That is, `d * inv = 1 mod 2**4`.let inv :=xor(2, mul(3, d))
// Now use 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.
inv :=mul(inv, sub(2, mul(d, inv))) // inverse mod 2**8
inv :=mul(inv, sub(2, mul(d, inv))) // inverse mod 2**16
inv :=mul(inv, sub(2, mul(d, inv))) // inverse mod 2**32
inv :=mul(inv, sub(2, mul(d, inv))) // inverse mod 2**64
inv :=mul(inv, sub(2, mul(d, inv))) // inverse mod 2**128
result :=mul(
// Divide [p1 p0] by the factors of two.// Shift in bits from `p1` into `p0`. For this we need// to flip `t` such that it is `2**256 / t`.or(
mul(sub(p1, gt(r, result)), add(div(sub(0, t), t), 1)),
div(sub(result, r), t)
),
mul(sub(2, mul(d, inv)), inv) // inverse mod 2**256
)
break
}
result :=div(result, d)
break
}
}
}
/// @dev Calculates `floor(x * y / d)` with full precision./// Behavior is undefined if `d` is zero or the final result cannot fit in 256 bits./// Performs the full 512 bit calculation regardless.functionfullMulDivUnchecked(uint256 x, uint256 y, uint256 d)
internalpurereturns (uint256 result)
{
/// @solidity memory-safe-assemblyassembly {
result :=mul(x, y)
let mm :=mulmod(x, y, not(0))
let p1 :=sub(mm, add(result, lt(mm, result)))
let t :=and(d, sub(0, d))
let r :=mulmod(x, y, d)
d :=div(d, t)
let inv :=xor(2, mul(3, d))
inv :=mul(inv, sub(2, mul(d, inv)))
inv :=mul(inv, sub(2, mul(d, inv)))
inv :=mul(inv, sub(2, mul(d, inv)))
inv :=mul(inv, sub(2, mul(d, inv)))
inv :=mul(inv, sub(2, mul(d, inv)))
result :=mul(
or(mul(sub(p1, gt(r, result)), add(div(sub(0, t), t), 1)), div(sub(result, r), t)),
mul(sub(2, mul(d, inv)), inv)
)
}
}
/// @dev Calculates `floor(x * y / d)` with full precision, rounded up./// Throws if result overflows a uint256 or when `d` is zero./// Credit to Uniswap-v3-core under MIT license:/// https://github.com/Uniswap/v3-core/blob/main/contracts/libraries/FullMath.solfunctionfullMulDivUp(uint256 x, uint256 y, uint256 d) internalpurereturns (uint256 result) {
result = fullMulDiv(x, y, d);
/// @solidity memory-safe-assemblyassembly {
ifmulmod(x, y, d) {
result :=add(result, 1)
ifiszero(result) {
mstore(0x00, 0xae47f702) // `FullMulDivFailed()`.revert(0x1c, 0x04)
}
}
}
}
/// @dev Returns `floor(x * y / d)`./// Reverts if `x * y` overflows, or `d` is zero.functionmulDiv(uint256 x, uint256 y, uint256 d) internalpurereturns (uint256 z) {
/// @solidity memory-safe-assemblyassembly {
z :=mul(x, y)
// Equivalent to `require(d != 0 && (y == 0 || x <= type(uint256).max / y))`.ifiszero(mul(or(iszero(x), eq(div(z, x), y)), d)) {
mstore(0x00, 0xad251c27) // `MulDivFailed()`.revert(0x1c, 0x04)
}
z :=div(z, d)
}
}
/// @dev Returns `ceil(x * y / d)`./// Reverts if `x * y` overflows, or `d` is zero.functionmulDivUp(uint256 x, uint256 y, uint256 d) internalpurereturns (uint256 z) {
/// @solidity memory-safe-assemblyassembly {
z :=mul(x, y)
// Equivalent to `require(d != 0 && (y == 0 || x <= type(uint256).max / y))`.ifiszero(mul(or(iszero(x), eq(div(z, x), y)), d)) {
mstore(0x00, 0xad251c27) // `MulDivFailed()`.revert(0x1c, 0x04)
}
z :=add(iszero(iszero(mod(z, d))), div(z, d))
}
}
/// @dev Returns `ceil(x / d)`./// Reverts if `d` is zero.functiondivUp(uint256 x, uint256 d) internalpurereturns (uint256 z) {
/// @solidity memory-safe-assemblyassembly {
ifiszero(d) {
mstore(0x00, 0x65244e4e) // `DivFailed()`.revert(0x1c, 0x04)
}
z :=add(iszero(iszero(mod(x, d))), div(x, d))
}
}
/// @dev Returns `max(0, x - y)`.functionzeroFloorSub(uint256 x, uint256 y) internalpurereturns (uint256 z) {
/// @solidity memory-safe-assemblyassembly {
z :=mul(gt(x, y), sub(x, y))
}
}
/// @dev Returns `condition ? x : y`, without branching.functionternary(bool condition, uint256 x, uint256 y) internalpurereturns (uint256 result) {
/// @solidity memory-safe-assemblyassembly {
result :=xor(x, mul(xor(x, y), iszero(condition)))
}
}
/// @dev Exponentiate `x` to `y` by squaring, denominated in base `b`./// Reverts if the computation overflows.functionrpow(uint256 x, uint256 y, uint256 b) internalpurereturns (uint256 z) {
/// @solidity memory-safe-assemblyassembly {
z :=mul(b, iszero(y)) // `0 ** 0 = 1`. Otherwise, `0 ** n = 0`.if x {
z :=xor(b, mul(xor(b, x), and(y, 1))) // `z = isEven(y) ? scale : x`let half :=shr(1, b) // Divide `b` by 2.// Divide `y` by 2 every iteration.for { y :=shr(1, y) } y { y :=shr(1, y) } {
let xx :=mul(x, x) // Store x squared.let xxRound :=add(xx, half) // Round to the nearest number.// Revert if `xx + half` overflowed, or if `x ** 2` overflows.ifor(lt(xxRound, xx), shr(128, x)) {
mstore(0x00, 0x49f7642b) // `RPowOverflow()`.revert(0x1c, 0x04)
}
x :=div(xxRound, b) // Set `x` to scaled `xxRound`.// If `y` is odd:ifand(y, 1) {
let zx :=mul(z, x) // Compute `z * x`.let zxRound :=add(zx, half) // Round to the nearest number.// If `z * x` overflowed or `zx + half` overflowed:ifor(xor(div(zx, x), z), lt(zxRound, zx)) {
// Revert if `x` is non-zero.if x {
mstore(0x00, 0x49f7642b) // `RPowOverflow()`.revert(0x1c, 0x04)
}
}
z :=div(zxRound, b) // Return properly scaled `zxRound`.
}
}
}
}
}
/// @dev Returns the square root of `x`, rounded down.functionsqrt(uint256 x) internalpurereturns (uint256 z) {
/// @solidity memory-safe-assemblyassembly {
// `floor(sqrt(2**15)) = 181`. `sqrt(2**15) - 181 = 2.84`.
z :=181// The "correct" value is 1, but this saves a multiplication later.// This segment is to get a reasonable initial estimate for the Babylonian method. With a bad// start, the correct # of bits increases ~linearly each iteration instead of ~quadratically.// Let `y = x / 2**r`. We check `y >= 2**(k + 8)`// but shift right by `k` bits to ensure that if `x >= 256`, then `y >= 256`.let r :=shl(7, lt(0xffffffffffffffffffffffffffffffffff, x))
r :=or(r, shl(6, lt(0xffffffffffffffffff, shr(r, x))))
r :=or(r, shl(5, lt(0xffffffffff, shr(r, x))))
r :=or(r, shl(4, lt(0xffffff, shr(r, x))))
z :=shl(shr(1, r), z)
// Goal was to get `z*z*y` within a small factor of `x`. More iterations could// get y in a tighter range. Currently, we will have y in `[256, 256*(2**16))`.// We ensured `y >= 256` so that the relative difference between `y` and `y+1` is small.// That's not possible if `x < 256` but we can just verify those cases exhaustively.// Now, `z*z*y <= x < z*z*(y+1)`, and `y <= 2**(16+8)`, and either `y >= 256`, or `x < 256`.// Correctness can be checked exhaustively for `x < 256`, so we assume `y >= 256`.// Then `z*sqrt(y)` is within `sqrt(257)/sqrt(256)` of `sqrt(x)`, or about 20bps.// For `s` in the range `[1/256, 256]`, the estimate `f(s) = (181/1024) * (s+1)`// is in the range `(1/2.84 * sqrt(s), 2.84 * sqrt(s))`,// with largest error when `s = 1` and when `s = 256` or `1/256`.// Since `y` is in `[256, 256*(2**16))`, let `a = y/65536`, so that `a` is in `[1/256, 256)`.// Then we can estimate `sqrt(y)` using// `sqrt(65536) * 181/1024 * (a + 1) = 181/4 * (y + 65536)/65536 = 181 * (y + 65536)/2**18`.// There is no overflow risk here since `y < 2**136` after the first branch above.
z :=shr(18, mul(z, add(shr(r, x), 65536))) // A `mul()` is saved from starting `z` at 181.// Given the worst case multiplicative error of 2.84 above, 7 iterations should be enough.
z :=shr(1, add(z, div(x, z)))
z :=shr(1, add(z, div(x, z)))
z :=shr(1, add(z, div(x, z)))
z :=shr(1, add(z, div(x, z)))
z :=shr(1, add(z, div(x, z)))
z :=shr(1, add(z, div(x, z)))
z :=shr(1, add(z, div(x, z)))
// If `x+1` is a perfect square, the Babylonian method cycles between// `floor(sqrt(x))` and `ceil(sqrt(x))`. This statement ensures we return floor.// See: https://en.wikipedia.org/wiki/Integer_square_root#Using_only_integer_division
z :=sub(z, lt(div(x, z), z))
}
}
/// @dev Returns the cube root of `x`, rounded down./// Credit to bout3fiddy and pcaversaccio under AGPLv3 license:/// https://github.com/pcaversaccio/snekmate/blob/main/src/utils/Math.vy/// Formally verified by xuwinnie:/// https://github.com/vectorized/solady/blob/main/audits/xuwinnie-solady-cbrt-proof.pdffunctioncbrt(uint256 x) internalpurereturns (uint256 z) {
/// @solidity memory-safe-assemblyassembly {
let r :=shl(7, lt(0xffffffffffffffffffffffffffffffff, x))
r :=or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))
r :=or(r, shl(5, lt(0xffffffff, shr(r, x))))
r :=or(r, shl(4, lt(0xffff, shr(r, x))))
r :=or(r, shl(3, lt(0xff, shr(r, x))))
// Makeshift lookup table to nudge the approximate log2 result.
z :=div(shl(div(r, 3), shl(lt(0xf, shr(r, x)), 0xf)), xor(7, mod(r, 3)))
// Newton-Raphson's.
z :=div(add(add(div(x, mul(z, z)), z), z), 3)
z :=div(add(add(div(x, mul(z, z)), z), z), 3)
z :=div(add(add(div(x, mul(z, z)), z), z), 3)
z :=div(add(add(div(x, mul(z, z)), z), z), 3)
z :=div(add(add(div(x, mul(z, z)), z), z), 3)
z :=div(add(add(div(x, mul(z, z)), z), z), 3)
z :=div(add(add(div(x, mul(z, z)), z), z), 3)
// Round down.
z :=sub(z, lt(div(x, mul(z, z)), z))
}
}
/// @dev Returns the square root of `x`, denominated in `WAD`, rounded down.functionsqrtWad(uint256 x) internalpurereturns (uint256 z) {
unchecked {
if (x <=type(uint256).max/10**18) return sqrt(x *10**18);
z = (1+ sqrt(x)) *10**9;
z = (fullMulDivUnchecked(x, 10**18, z) + z) >>1;
}
/// @solidity memory-safe-assemblyassembly {
z :=sub(z, gt(999999999999999999, sub(mulmod(z, z, x), 1))) // Round down.
}
}
/// @dev Returns the cube root of `x`, denominated in `WAD`, rounded down./// Formally verified by xuwinnie:/// https://github.com/vectorized/solady/blob/main/audits/xuwinnie-solady-cbrt-proof.pdffunctioncbrtWad(uint256 x) internalpurereturns (uint256 z) {
unchecked {
if (x <=type(uint256).max/10**36) return cbrt(x *10**36);
z = (1+ cbrt(x)) *10**12;
z = (fullMulDivUnchecked(x, 10**36, z * z) + z + z) /3;
}
/// @solidity memory-safe-assemblyassembly {
let p := x
for {} 1 {} {
ifiszero(shr(229, p)) {
ifiszero(shr(199, p)) {
p :=mul(p, 100000000000000000) // 10 ** 17.break
}
p :=mul(p, 100000000) // 10 ** 8.break
}
ifiszero(shr(249, p)) { p :=mul(p, 100) }
break
}
let t :=mulmod(mul(z, z), z, p)
z :=sub(z, gt(lt(t, shr(1, p)), iszero(t))) // Round down.
}
}
/// @dev Returns the factorial of `x`.functionfactorial(uint256 x) internalpurereturns (uint256 result) {
/// @solidity memory-safe-assemblyassembly {
result :=1ifiszero(lt(x, 58)) {
mstore(0x00, 0xaba0f2a2) // `FactorialOverflow()`.revert(0x1c, 0x04)
}
for {} x { x :=sub(x, 1) } { result :=mul(result, x) }
}
}
/// @dev Returns the log2 of `x`./// Equivalent to computing the index of the most significant bit (MSB) of `x`./// Returns 0 if `x` is zero.functionlog2(uint256 x) internalpurereturns (uint256 r) {
/// @solidity memory-safe-assemblyassembly {
r :=shl(7, lt(0xffffffffffffffffffffffffffffffff, x))
r :=or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))
r :=or(r, shl(5, lt(0xffffffff, shr(r, x))))
r :=or(r, shl(4, lt(0xffff, shr(r, x))))
r :=or(r, shl(3, lt(0xff, shr(r, x))))
// forgefmt: disable-next-item
r :=or(r, byte(and(0x1f, shr(shr(r, x), 0x8421084210842108cc6318c6db6d54be)),
0x0706060506020504060203020504030106050205030304010505030400000000))
}
}
/// @dev Returns the log2 of `x`, rounded up./// Returns 0 if `x` is zero.functionlog2Up(uint256 x) internalpurereturns (uint256 r) {
r =log2(x);
/// @solidity memory-safe-assemblyassembly {
r :=add(r, lt(shl(r, 1), x))
}
}
/// @dev Returns the log10 of `x`./// Returns 0 if `x` is zero.functionlog10(uint256 x) internalpurereturns (uint256 r) {
/// @solidity memory-safe-assemblyassembly {
ifiszero(lt(x, 100000000000000000000000000000000000000)) {
x :=div(x, 100000000000000000000000000000000000000)
r :=38
}
ifiszero(lt(x, 100000000000000000000)) {
x :=div(x, 100000000000000000000)
r :=add(r, 20)
}
ifiszero(lt(x, 10000000000)) {
x :=div(x, 10000000000)
r :=add(r, 10)
}
ifiszero(lt(x, 100000)) {
x :=div(x, 100000)
r :=add(r, 5)
}
r :=add(r, add(gt(x, 9), add(gt(x, 99), add(gt(x, 999), gt(x, 9999)))))
}
}
/// @dev Returns the log10 of `x`, rounded up./// Returns 0 if `x` is zero.functionlog10Up(uint256 x) internalpurereturns (uint256 r) {
r = log10(x);
/// @solidity memory-safe-assemblyassembly {
r :=add(r, lt(exp(10, r), x))
}
}
/// @dev Returns the log256 of `x`./// Returns 0 if `x` is zero.functionlog256(uint256 x) internalpurereturns (uint256 r) {
/// @solidity memory-safe-assemblyassembly {
r :=shl(7, lt(0xffffffffffffffffffffffffffffffff, x))
r :=or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))
r :=or(r, shl(5, lt(0xffffffff, shr(r, x))))
r :=or(r, shl(4, lt(0xffff, shr(r, x))))
r :=or(shr(3, r), lt(0xff, shr(r, x)))
}
}
/// @dev Returns the log256 of `x`, rounded up./// Returns 0 if `x` is zero.functionlog256Up(uint256 x) internalpurereturns (uint256 r) {
r = log256(x);
/// @solidity memory-safe-assemblyassembly {
r :=add(r, lt(shl(shl(3, r), 1), x))
}
}
/// @dev Returns the scientific notation format `mantissa * 10 ** exponent` of `x`./// Useful for compressing prices (e.g. using 25 bit mantissa and 7 bit exponent).functionsci(uint256 x) internalpurereturns (uint256 mantissa, uint256 exponent) {
/// @solidity memory-safe-assemblyassembly {
mantissa := x
if mantissa {
ifiszero(mod(mantissa, 1000000000000000000000000000000000)) {
mantissa :=div(mantissa, 1000000000000000000000000000000000)
exponent :=33
}
ifiszero(mod(mantissa, 10000000000000000000)) {
mantissa :=div(mantissa, 10000000000000000000)
exponent :=add(exponent, 19)
}
ifiszero(mod(mantissa, 1000000000000)) {
mantissa :=div(mantissa, 1000000000000)
exponent :=add(exponent, 12)
}
ifiszero(mod(mantissa, 1000000)) {
mantissa :=div(mantissa, 1000000)
exponent :=add(exponent, 6)
}
ifiszero(mod(mantissa, 10000)) {
mantissa :=div(mantissa, 10000)
exponent :=add(exponent, 4)
}
ifiszero(mod(mantissa, 100)) {
mantissa :=div(mantissa, 100)
exponent :=add(exponent, 2)
}
ifiszero(mod(mantissa, 10)) {
mantissa :=div(mantissa, 10)
exponent :=add(exponent, 1)
}
}
}
}
/// @dev Convenience function for packing `x` into a smaller number using `sci`./// The `mantissa` will be in bits [7..255] (the upper 249 bits)./// The `exponent` will be in bits [0..6] (the lower 7 bits)./// Use `SafeCastLib` to safely ensure that the `packed` number is small/// enough to fit in the desired unsigned integer type:/// ```/// uint32 packed = SafeCastLib.toUint32(FixedPointMathLib.packSci(777 ether));/// ```functionpackSci(uint256 x) internalpurereturns (uint256 packed) {
(x, packed) = sci(x); // Reuse for `mantissa` and `exponent`./// @solidity memory-safe-assemblyassembly {
ifshr(249, x) {
mstore(0x00, 0xce30380c) // `MantissaOverflow()`.revert(0x1c, 0x04)
}
packed :=or(shl(7, x), packed)
}
}
/// @dev Convenience function for unpacking a packed number from `packSci`.functionunpackSci(uint256 packed) internalpurereturns (uint256 unpacked) {
unchecked {
unpacked = (packed >>7) *10** (packed &0x7f);
}
}
/// @dev Returns the average of `x` and `y`. Rounds towards zero.functionavg(uint256 x, uint256 y) internalpurereturns (uint256 z) {
unchecked {
z = (x & y) + ((x ^ y) >>1);
}
}
/// @dev Returns the average of `x` and `y`. Rounds towards negative infinity.functionavg(int256 x, int256 y) internalpurereturns (int256 z) {
unchecked {
z = (x >>1) + (y >>1) + (x & y &1);
}
}
/// @dev Returns the absolute value of `x`.functionabs(int256 x) internalpurereturns (uint256 z) {
unchecked {
z = (uint256(x) +uint256(x >>255)) ^uint256(x >>255);
}
}
/// @dev Returns the absolute distance between `x` and `y`.functiondist(uint256 x, uint256 y) internalpurereturns (uint256 z) {
/// @solidity memory-safe-assemblyassembly {
z :=add(xor(sub(0, gt(x, y)), sub(y, x)), gt(x, y))
}
}
/// @dev Returns the absolute distance between `x` and `y`.functiondist(int256 x, int256 y) internalpurereturns (uint256 z) {
/// @solidity memory-safe-assemblyassembly {
z :=add(xor(sub(0, sgt(x, y)), sub(y, x)), sgt(x, y))
}
}
/// @dev Returns the minimum of `x` and `y`.functionmin(uint256 x, uint256 y) internalpurereturns (uint256 z) {
/// @solidity memory-safe-assemblyassembly {
z :=xor(x, mul(xor(x, y), lt(y, x)))
}
}
/// @dev Returns the minimum of `x` and `y`.functionmin(int256 x, int256 y) internalpurereturns (int256 z) {
/// @solidity memory-safe-assemblyassembly {
z :=xor(x, mul(xor(x, y), slt(y, x)))
}
}
/// @dev Returns the maximum of `x` and `y`.functionmax(uint256 x, uint256 y) internalpurereturns (uint256 z) {
/// @solidity memory-safe-assemblyassembly {
z :=xor(x, mul(xor(x, y), gt(y, x)))
}
}
/// @dev Returns the maximum of `x` and `y`.functionmax(int256 x, int256 y) internalpurereturns (int256 z) {
/// @solidity memory-safe-assemblyassembly {
z :=xor(x, mul(xor(x, y), sgt(y, x)))
}
}
/// @dev Returns `x`, bounded to `minValue` and `maxValue`.functionclamp(uint256 x, uint256 minValue, uint256 maxValue)
internalpurereturns (uint256 z)
{
/// @solidity memory-safe-assemblyassembly {
z :=xor(x, mul(xor(x, minValue), gt(minValue, x)))
z :=xor(z, mul(xor(z, maxValue), lt(maxValue, z)))
}
}
/// @dev Returns `x`, bounded to `minValue` and `maxValue`.functionclamp(int256 x, int256 minValue, int256 maxValue) internalpurereturns (int256 z) {
/// @solidity memory-safe-assemblyassembly {
z :=xor(x, mul(xor(x, minValue), sgt(minValue, x)))
z :=xor(z, mul(xor(z, maxValue), slt(maxValue, z)))
}
}
/// @dev Returns greatest common divisor of `x` and `y`.functiongcd(uint256 x, uint256 y) internalpurereturns (uint256 z) {
/// @solidity memory-safe-assemblyassembly {
for { z := x } y {} {
let t := y
y :=mod(z, y)
z := t
}
}
}
/// @dev Returns `a + (b - a) * (t - begin) / (end - begin)`,/// with `t` clamped between `begin` and `end` (inclusive)./// Agnostic to the order of (`a`, `b`) and (`end`, `begin`)./// If `begins == end`, returns `t <= begin ? a : b`.functionlerp(uint256 a, uint256 b, uint256 t, uint256 begin, uint256 end)
internalpurereturns (uint256)
{
if (begin > end) (t, begin, end) = (~t, ~begin, ~end);
if (t <= begin) return a;
if (t >= end) return b;
unchecked {
if (b >= a) return a + fullMulDiv(b - a, t - begin, end - begin);
return a - fullMulDiv(a - b, t - begin, end - begin);
}
}
/// @dev Returns `a + (b - a) * (t - begin) / (end - begin)`./// with `t` clamped between `begin` and `end` (inclusive)./// Agnostic to the order of (`a`, `b`) and (`end`, `begin`)./// If `begins == end`, returns `t <= begin ? a : b`.functionlerp(int256 a, int256 b, int256 t, int256 begin, int256 end)
internalpurereturns (int256)
{
if (begin > end) (t, begin, end) = (~t, ~begin, ~end);
if (t <= begin) return a;
if (t >= end) return b;
// forgefmt: disable-next-itemunchecked {
if (b >= a) returnint256(uint256(a) + fullMulDiv(uint256(b - a),
uint256(t - begin), uint256(end - begin)));
returnint256(uint256(a) - fullMulDiv(uint256(a - b),
uint256(t - begin), uint256(end - begin)));
}
}
/// @dev Returns if `x` is an even number. Some people may need this.functionisEven(uint256 x) internalpurereturns (bool) {
return x &uint256(1) ==uint256(0);
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* RAW NUMBER OPERATIONS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev Returns `x + y`, without checking for overflow.functionrawAdd(uint256 x, uint256 y) internalpurereturns (uint256 z) {
unchecked {
z = x + y;
}
}
/// @dev Returns `x + y`, without checking for overflow.functionrawAdd(int256 x, int256 y) internalpurereturns (int256 z) {
unchecked {
z = x + y;
}
}
/// @dev Returns `x - y`, without checking for underflow.functionrawSub(uint256 x, uint256 y) internalpurereturns (uint256 z) {
unchecked {
z = x - y;
}
}
/// @dev Returns `x - y`, without checking for underflow.functionrawSub(int256 x, int256 y) internalpurereturns (int256 z) {
unchecked {
z = x - y;
}
}
/// @dev Returns `x * y`, without checking for overflow.functionrawMul(uint256 x, uint256 y) internalpurereturns (uint256 z) {
unchecked {
z = x * y;
}
}
/// @dev Returns `x * y`, without checking for overflow.functionrawMul(int256 x, int256 y) internalpurereturns (int256 z) {
unchecked {
z = x * y;
}
}
/// @dev Returns `x / y`, returning 0 if `y` is zero.functionrawDiv(uint256 x, uint256 y) internalpurereturns (uint256 z) {
/// @solidity memory-safe-assemblyassembly {
z :=div(x, y)
}
}
/// @dev Returns `x / y`, returning 0 if `y` is zero.functionrawSDiv(int256 x, int256 y) internalpurereturns (int256 z) {
/// @solidity memory-safe-assemblyassembly {
z :=sdiv(x, y)
}
}
/// @dev Returns `x % y`, returning 0 if `y` is zero.functionrawMod(uint256 x, uint256 y) internalpurereturns (uint256 z) {
/// @solidity memory-safe-assemblyassembly {
z :=mod(x, y)
}
}
/// @dev Returns `x % y`, returning 0 if `y` is zero.functionrawSMod(int256 x, int256 y) internalpurereturns (int256 z) {
/// @solidity memory-safe-assemblyassembly {
z :=smod(x, y)
}
}
/// @dev Returns `(x + y) % d`, return 0 if `d` if zero.functionrawAddMod(uint256 x, uint256 y, uint256 d) internalpurereturns (uint256 z) {
/// @solidity memory-safe-assemblyassembly {
z :=addmod(x, y, d)
}
}
/// @dev Returns `(x * y) % d`, return 0 if `d` if zero.functionrawMulMod(uint256 x, uint256 y, uint256 d) internalpurereturns (uint256 z) {
/// @solidity memory-safe-assemblyassembly {
z :=mulmod(x, y, d)
}
}
}
Contract Source Code
File 4 of 12: IERC165.sol
// SPDX-License-Identifier: MITpragmasolidity >=0.6.2;interfaceIERC165{
/// @notice Query if a contract implements an interface/// @param interfaceID The interface identifier, as specified in ERC-165/// @dev Interface identification is specified in ERC-165. This function/// uses less than 30,000 gas./// @return `true` if the contract implements `interfaceID` and/// `interfaceID` is not 0xffffffff, `false` otherwisefunctionsupportsInterface(bytes4 interfaceID) externalviewreturns (bool);
}
Contract Source Code
File 5 of 12: IERC20.sol
// SPDX-License-Identifier: MITpragmasolidity >=0.6.2;/// @dev Interface of the ERC20 standard as defined in the EIP./// @dev This includes the optional name, symbol, and decimals metadata.interfaceIERC20{
/// @dev Emitted when `value` tokens are moved from one account (`from`) to another (`to`).eventTransfer(addressindexedfrom, addressindexed to, uint256 value);
/// @dev Emitted when the allowance of a `spender` for an `owner` is set, where `value`/// is the new allowance.eventApproval(addressindexed owner, addressindexed spender, uint256 value);
/// @notice Returns the amount of tokens in existence.functiontotalSupply() externalviewreturns (uint256);
/// @notice Returns the amount of tokens owned by `account`.functionbalanceOf(address account) externalviewreturns (uint256);
/// @notice Moves `amount` tokens from the caller's account to `to`.functiontransfer(address to, uint256 amount) externalreturns (bool);
/// @notice Returns the remaining number of tokens that `spender` is allowed/// to spend on behalf of `owner`functionallowance(address owner, address spender) externalviewreturns (uint256);
/// @notice Sets `amount` as the allowance of `spender` over the caller's tokens./// @dev Be aware of front-running risks: https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729functionapprove(address spender, uint256 amount) externalreturns (bool);
/// @notice Moves `amount` tokens from `from` to `to` using the allowance mechanism./// `amount` is then deducted from the caller's allowance.functiontransferFrom(addressfrom, address to, uint256 amount) externalreturns (bool);
/// @notice Returns the name of the token.functionname() externalviewreturns (stringmemory);
/// @notice Returns the symbol of the token.functionsymbol() externalviewreturns (stringmemory);
/// @notice Returns the decimals places of the token.functiondecimals() externalviewreturns (uint8);
}
Contract Source Code
File 6 of 12: IERC721.sol
// SPDX-License-Identifier: MITpragmasolidity >=0.6.2;import"./IERC165.sol";
/// @title ERC-721 Non-Fungible Token Standard/// @dev See https://eips.ethereum.org/EIPS/eip-721/// Note: the ERC-165 identifier for this interface is 0x80ac58cd.interfaceIERC721isIERC165{
/// @dev This emits when ownership of any NFT changes by any mechanism./// This event emits when NFTs are created (`from` == 0) and destroyed/// (`to` == 0). Exception: during contract creation, any number of NFTs/// may be created and assigned without emitting Transfer. At the time of/// any transfer, the approved address for that NFT (if any) is reset to none.eventTransfer(addressindexed _from, addressindexed _to, uint256indexed _tokenId);
/// @dev This emits when the approved address for an NFT is changed or/// reaffirmed. The zero address indicates there is no approved address./// When a Transfer event emits, this also indicates that the approved/// address for that NFT (if any) is reset to none.eventApproval(addressindexed _owner, addressindexed _approved, uint256indexed _tokenId);
/// @dev This emits when an operator is enabled or disabled for an owner./// The operator can manage all NFTs of the owner.eventApprovalForAll(addressindexed _owner, addressindexed _operator, bool _approved);
/// @notice Count all NFTs assigned to an owner/// @dev NFTs assigned to the zero address are considered invalid, and this/// function throws for queries about the zero address./// @param _owner An address for whom to query the balance/// @return The number of NFTs owned by `_owner`, possibly zerofunctionbalanceOf(address _owner) externalviewreturns (uint256);
/// @notice Find the owner of an NFT/// @dev NFTs assigned to zero address are considered invalid, and queries/// about them do throw./// @param _tokenId The identifier for an NFT/// @return The address of the owner of the NFTfunctionownerOf(uint256 _tokenId) externalviewreturns (address);
/// @notice Transfers the ownership of an NFT from one address to another address/// @dev Throws unless `msg.sender` is the current owner, an authorized/// operator, or the approved address for this NFT. Throws if `_from` is/// not the current owner. Throws if `_to` is the zero address. Throws if/// `_tokenId` is not a valid NFT. When transfer is complete, this function/// checks if `_to` is a smart contract (code size > 0). If so, it calls/// `onERC721Received` on `_to` and throws if the return value is not/// `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`./// @param _from The current owner of the NFT/// @param _to The new owner/// @param _tokenId The NFT to transfer/// @param data Additional data with no specified format, sent in call to `_to`functionsafeTransferFrom(address _from, address _to, uint256 _tokenId, bytescalldata data) externalpayable;
/// @notice Transfers the ownership of an NFT from one address to another address/// @dev This works identically to the other function with an extra data parameter,/// except this function just sets data to ""./// @param _from The current owner of the NFT/// @param _to The new owner/// @param _tokenId The NFT to transferfunctionsafeTransferFrom(address _from, address _to, uint256 _tokenId) externalpayable;
/// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE/// TO CONFIRM THAT `_to` IS CAPABLE OF RECEIVING NFTS OR ELSE/// THEY MAY BE PERMANENTLY LOST/// @dev Throws unless `msg.sender` is the current owner, an authorized/// operator, or the approved address for this NFT. Throws if `_from` is/// not the current owner. Throws if `_to` is the zero address. Throws if/// `_tokenId` is not a valid NFT./// @param _from The current owner of the NFT/// @param _to The new owner/// @param _tokenId The NFT to transferfunctiontransferFrom(address _from, address _to, uint256 _tokenId) externalpayable;
/// @notice Change or reaffirm the approved address for an NFT/// @dev The zero address indicates there is no approved address./// Throws unless `msg.sender` is the current NFT owner, or an authorized/// operator of the current owner./// @param _approved The new approved NFT controller/// @param _tokenId The NFT to approvefunctionapprove(address _approved, uint256 _tokenId) externalpayable;
/// @notice Enable or disable approval for a third party ("operator") to manage/// all of `msg.sender`'s assets/// @dev Emits the ApprovalForAll event. The contract MUST allow/// multiple operators per owner./// @param _operator Address to add to the set of authorized operators/// @param _approved True if the operator is approved, false to revoke approvalfunctionsetApprovalForAll(address _operator, bool _approved) external;
/// @notice Get the approved address for a single NFT/// @dev Throws if `_tokenId` is not a valid NFT./// @param _tokenId The NFT to find the approved address for/// @return The approved address for this NFT, or the zero address if there is nonefunctiongetApproved(uint256 _tokenId) externalviewreturns (address);
/// @notice Query if an address is an authorized operator for another address/// @param _owner The address that owns the NFTs/// @param _operator The address that acts on behalf of the owner/// @return True if `_operator` is an approved operator for `_owner`, false otherwisefunctionisApprovedForAll(address _owner, address _operator) externalviewreturns (bool);
}
/// @dev Note: the ERC-165 identifier for this interface is 0x150b7a02.interfaceIERC721TokenReceiver{
/// @notice Handle the receipt of an NFT/// @dev The ERC721 smart contract calls this function on the recipient/// after a `transfer`. This function MAY throw to revert and reject the/// transfer. Return of other than the magic value MUST result in the/// transaction being reverted./// Note: the contract address is always the message sender./// @param _operator The address which called `safeTransferFrom` function/// @param _from The address which previously owned the token/// @param _tokenId The NFT identifier which is being transferred/// @param _data Additional data with no specified format/// @return `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`/// unless throwingfunctiononERC721Received(address _operator, address _from, uint256 _tokenId, bytescalldata _data)
externalreturns (bytes4);
}
/// @title ERC-721 Non-Fungible Token Standard, optional metadata extension/// @dev See https://eips.ethereum.org/EIPS/eip-721/// Note: the ERC-165 identifier for this interface is 0x5b5e139f.interfaceIERC721MetadataisIERC721{
/// @notice A descriptive name for a collection of NFTs in this contractfunctionname() externalviewreturns (stringmemory _name);
/// @notice An abbreviated name for NFTs in this contractfunctionsymbol() externalviewreturns (stringmemory _symbol);
/// @notice A distinct Uniform Resource Identifier (URI) for a given asset./// @dev Throws if `_tokenId` is not a valid NFT. URIs are defined in RFC/// 3986. The URI may point to a JSON file that conforms to the "ERC721/// Metadata JSON Schema".functiontokenURI(uint256 _tokenId) externalviewreturns (stringmemory);
}
/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension/// @dev See https://eips.ethereum.org/EIPS/eip-721/// Note: the ERC-165 identifier for this interface is 0x780e9d63.interfaceIERC721EnumerableisIERC721{
/// @notice Count NFTs tracked by this contract/// @return A count of valid NFTs tracked by this contract, where each one of/// them has an assigned and queryable owner not equal to the zero addressfunctiontotalSupply() externalviewreturns (uint256);
/// @notice Enumerate valid NFTs/// @dev Throws if `_index` >= `totalSupply()`./// @param _index A counter less than `totalSupply()`/// @return The token identifier for the `_index`th NFT,/// (sort order not specified)functiontokenByIndex(uint256 _index) externalviewreturns (uint256);
/// @notice Enumerate NFTs assigned to an owner/// @dev Throws if `_index` >= `balanceOf(_owner)` or if/// `_owner` is the zero address, representing invalid NFTs./// @param _owner An address where we are interested in NFTs owned by them/// @param _index A counter less than `balanceOf(_owner)`/// @return The token identifier for the `_index`th NFT assigned to `_owner`,/// (sort order not specified)functiontokenOfOwnerByIndex(address _owner, uint256 _index) externalviewreturns (uint256);
}
// SPDX-License-Identifier: MITpragmasolidity ^0.8.20;interfaceIVaultManager{
eventAdded(uint256indexed id, addressindexed vault);
eventRemoved(uint256indexed id, addressindexed vault);
eventMintDyad(uint256indexed id, uint256 amount, addressindexed to);
eventBurnDyad(uint256indexed id, uint256 amount, addressindexedfrom);
eventRedeemDyad(uint256indexed id, addressindexed vault, uint256 amount, addressindexed to);
eventLiquidate(uint256indexed id, addressindexedfrom, uint256indexed to);
errorNotOwner();
errorNotLicensed();
errorVaultNotLicensed();
errorTooManyVaults();
errorVaultAlreadyAdded();
errorVaultNotAdded();
errorVaultHasAssets();
errorNotDNftVault();
errorInvalidDNft();
errorCrTooLow();
errorCrTooHigh();
errorCanNotWithdrawInSameBlock();
errorNotEnoughExoCollat();
errorVaultNotKerosene();
/**
* @notice Adds a vault to the dNFT position
* @param id The ID of the dNFT for which the vault is being added.
* @param vault The address of the vault contract to be added.
*/functionadd(uint256 id, address vault) external;
/**
* @notice Removes a vault from the dNFT position
* @param id The ID of the dNFT for which the vault is being removed.
* @param vault The address of the vault contract to be removed.
*/functionremove(uint256 id, address vault) external;
/**
* @notice Allows a dNFT owner to deposit collateral into a vault
* @param id The ID of the dNFT for which the deposit is being made.
* @param vault The vault where the assets will be deposited.
* @param amount The amount of assets to be deposited.
*/functiondeposit(uint256 id, address vault, uint256 amount) external;
/**
* @notice Allows a dNFT owner to withdraw collateral from a vault
* @param id The ID of the dNFT for which the withdraw is being made.
* @param vault The vault where the assets will be deposited.
* @param amount The amount of assets to be deposited.
* @param to The address where the assets will be sent.
*/functionwithdraw(uint256 id, address vault, uint256 amount, address to) external;
/**
* @notice Mint DYAD through a dNFT
* @param id The ID of the dNFT for which the DYAD is being minted.
* @param amount The amount of DYAD to be minted.
* @param to The address where the DYAD will be sent.
*/functionmintDyad(uint256 id, uint256 amount, address to) external;
/**
* @notice Burn DYAD through a dNFT
* @param id The ID of the dNFT for which the DYAD is being burned.
* @param amount The amount of DYAD to be burned.
*/functionburnDyad(uint256 id, uint256 amount) external;
/**
* @notice Redeem DYAD through a dNFT
* @param id The ID of the dNFT for which the DYAD is being redeemed.
* @param vault Address of the vault through which the DYAD is being redeemed
* for its underlying collateral.
* @param amount The amount of DYAD to be redeemed.
* @param to The address where the collateral will be sent.
* @return The amount of collateral that was redeemed.
*/functionredeemDyad(uint256 id, address vault, uint256 amount, address to) externalreturns (uint256);
/**
* @notice Liquidate a dNFT
* @param id The ID of the dNFT to be liquidated.
* @param to The address where the collateral will be sent.
*/// function liquidate(uint id, uint to, uint amount) external;
}
Contract Source Code
File 9 of 12: MerkleProofLib.sol
// SPDX-License-Identifier: MITpragmasolidity ^0.8.4;/// @notice Gas optimized verification of proof of inclusion for a leaf in a Merkle tree./// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/MerkleProofLib.sol)/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/MerkleProofLib.sol)/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/cryptography/MerkleProof.sol)libraryMerkleProofLib{
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* MERKLE PROOF VERIFICATION OPERATIONS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev Returns whether `leaf` exists in the Merkle tree with `root`, given `proof`.functionverify(bytes32[] memory proof, bytes32 root, bytes32 leaf)
internalpurereturns (bool isValid)
{
/// @solidity memory-safe-assemblyassembly {
ifmload(proof) {
// Initialize `offset` to the offset of `proof` elements in memory.let offset :=add(proof, 0x20)
// Left shift by 5 is equivalent to multiplying by 0x20.let end :=add(offset, shl(5, mload(proof)))
// Iterate over proof elements to compute root hash.for {} 1 {} {
// Slot of `leaf` in scratch space.// If the condition is true: 0x20, otherwise: 0x00.let scratch :=shl(5, gt(leaf, mload(offset)))
// Store elements to hash contiguously in scratch space.// Scratch space is 64 bytes (0x00 - 0x3f) and both elements are 32 bytes.mstore(scratch, leaf)
mstore(xor(scratch, 0x20), mload(offset))
// Reuse `leaf` to store the hash to reduce stack operations.
leaf :=keccak256(0x00, 0x40)
offset :=add(offset, 0x20)
ifiszero(lt(offset, end)) { break }
}
}
isValid :=eq(leaf, root)
}
}
/// @dev Returns whether `leaf` exists in the Merkle tree with `root`, given `proof`.functionverifyCalldata(bytes32[] calldata proof, bytes32 root, bytes32 leaf)
internalpurereturns (bool isValid)
{
/// @solidity memory-safe-assemblyassembly {
if proof.length {
// Left shift by 5 is equivalent to multiplying by 0x20.let end :=add(proof.offset, shl(5, proof.length))
// Initialize `offset` to the offset of `proof` in the calldata.let offset := proof.offset// Iterate over proof elements to compute root hash.for {} 1 {} {
// Slot of `leaf` in scratch space.// If the condition is true: 0x20, otherwise: 0x00.let scratch :=shl(5, gt(leaf, calldataload(offset)))
// Store elements to hash contiguously in scratch space.// Scratch space is 64 bytes (0x00 - 0x3f) and both elements are 32 bytes.mstore(scratch, leaf)
mstore(xor(scratch, 0x20), calldataload(offset))
// Reuse `leaf` to store the hash to reduce stack operations.
leaf :=keccak256(0x00, 0x40)
offset :=add(offset, 0x20)
ifiszero(lt(offset, end)) { break }
}
}
isValid :=eq(leaf, root)
}
}
/// @dev Returns whether all `leaves` exist in the Merkle tree with `root`,/// given `proof` and `flags`.////// Note:/// - Breaking the invariant `flags.length == (leaves.length - 1) + proof.length`/// will always return false./// - The sum of the lengths of `proof` and `leaves` must never overflow./// - Any non-zero word in the `flags` array is treated as true./// - The memory offset of `proof` must be non-zero/// (i.e. `proof` is not pointing to the scratch space).functionverifyMultiProof(bytes32[] memory proof,
bytes32 root,
bytes32[] memory leaves,
bool[] memory flags
) internalpurereturns (bool isValid) {
// Rebuilds the root by consuming and producing values on a queue.// The queue starts with the `leaves` array, and goes into a `hashes` array.// After the process, the last element on the queue is verified// to be equal to the `root`.//// The `flags` array denotes whether the sibling// should be popped from the queue (`flag == true`), or// should be popped from the `proof` (`flag == false`)./// @solidity memory-safe-assemblyassembly {
// Cache the lengths of the arrays.let leavesLength :=mload(leaves)
let proofLength :=mload(proof)
let flagsLength :=mload(flags)
// Advance the pointers of the arrays to point to the data.
leaves :=add(0x20, leaves)
proof :=add(0x20, proof)
flags :=add(0x20, flags)
// If the number of flags is correct.for {} eq(add(leavesLength, proofLength), add(flagsLength, 1)) {} {
// For the case where `proof.length + leaves.length == 1`.ifiszero(flagsLength) {
// `isValid = (proof.length == 1 ? proof[0] : leaves[0]) == root`.
isValid :=eq(mload(xor(leaves, mul(xor(proof, leaves), proofLength))), root)
break
}
// The required final proof offset if `flagsLength` is not zero, otherwise zero.let proofEnd :=add(proof, shl(5, proofLength))
// We can use the free memory space for the queue.// We don't need to allocate, since the queue is temporary.let hashesFront :=mload(0x40)
// Copy the leaves into the hashes.// Sometimes, a little memory expansion costs less than branching.// Should cost less, even with a high free memory offset of 0x7d00.
leavesLength :=shl(5, leavesLength)
for { let i :=0 } iszero(eq(i, leavesLength)) { i :=add(i, 0x20) } {
mstore(add(hashesFront, i), mload(add(leaves, i)))
}
// Compute the back of the hashes.let hashesBack :=add(hashesFront, leavesLength)
// This is the end of the memory for the queue.// We recycle `flagsLength` to save on stack variables (sometimes save gas).
flagsLength :=add(hashesBack, shl(5, flagsLength))
for {} 1 {} {
// Pop from `hashes`.let a :=mload(hashesFront)
// Pop from `hashes`.let b :=mload(add(hashesFront, 0x20))
hashesFront :=add(hashesFront, 0x40)
// If the flag is false, load the next proof,// else, pops from the queue.ifiszero(mload(flags)) {
// Loads the next proof.
b :=mload(proof)
proof :=add(proof, 0x20)
// Unpop from `hashes`.
hashesFront :=sub(hashesFront, 0x20)
}
// Advance to the next flag.
flags :=add(flags, 0x20)
// Slot of `a` in scratch space.// If the condition is true: 0x20, otherwise: 0x00.let scratch :=shl(5, gt(a, b))
// Hash the scratch space and push the result onto the queue.mstore(scratch, a)
mstore(xor(scratch, 0x20), b)
mstore(hashesBack, keccak256(0x00, 0x40))
hashesBack :=add(hashesBack, 0x20)
ifiszero(lt(hashesBack, flagsLength)) { break }
}
isValid :=and(
// Checks if the last value in the queue is same as the root.eq(mload(sub(hashesBack, 0x20)), root),
// And whether all the proofs are used, if required.eq(proofEnd, proof)
)
break
}
}
}
/// @dev Returns whether all `leaves` exist in the Merkle tree with `root`,/// given `proof` and `flags`.////// Note:/// - Breaking the invariant `flags.length == (leaves.length - 1) + proof.length`/// will always return false./// - Any non-zero word in the `flags` array is treated as true./// - The calldata offset of `proof` must be non-zero/// (i.e. `proof` is from a regular Solidity function with a 4-byte selector).functionverifyMultiProofCalldata(bytes32[] calldata proof,
bytes32 root,
bytes32[] calldata leaves,
bool[] calldata flags
) internalpurereturns (bool isValid) {
// Rebuilds the root by consuming and producing values on a queue.// The queue starts with the `leaves` array, and goes into a `hashes` array.// After the process, the last element on the queue is verified// to be equal to the `root`.//// The `flags` array denotes whether the sibling// should be popped from the queue (`flag == true`), or// should be popped from the `proof` (`flag == false`)./// @solidity memory-safe-assemblyassembly {
// If the number of flags is correct.for {} eq(add(leaves.length, proof.length), add(flags.length, 1)) {} {
// For the case where `proof.length + leaves.length == 1`.ifiszero(flags.length) {
// `isValid = (proof.length == 1 ? proof[0] : leaves[0]) == root`.// forgefmt: disable-next-item
isValid :=eq(
calldataload(
xor(leaves.offset, mul(xor(proof.offset, leaves.offset), proof.length))
),
root
)
break
}
// The required final proof offset if `flagsLength` is not zero, otherwise zero.let proofEnd :=add(proof.offset, shl(5, proof.length))
// We can use the free memory space for the queue.// We don't need to allocate, since the queue is temporary.let hashesFront :=mload(0x40)
// Copy the leaves into the hashes.// Sometimes, a little memory expansion costs less than branching.// Should cost less, even with a high free memory offset of 0x7d00.calldatacopy(hashesFront, leaves.offset, shl(5, leaves.length))
// Compute the back of the hashes.let hashesBack :=add(hashesFront, shl(5, leaves.length))
// This is the end of the memory for the queue.// We recycle `flagsLength` to save on stack variables (sometimes save gas).
flags.length:=add(hashesBack, shl(5, flags.length))
// We don't need to make a copy of `proof.offset` or `flags.offset`,// as they are pass-by-value (this trick may not always save gas).for {} 1 {} {
// Pop from `hashes`.let a :=mload(hashesFront)
// Pop from `hashes`.let b :=mload(add(hashesFront, 0x20))
hashesFront :=add(hashesFront, 0x40)
// If the flag is false, load the next proof,// else, pops from the queue.ifiszero(calldataload(flags.offset)) {
// Loads the next proof.
b :=calldataload(proof.offset)
proof.offset:=add(proof.offset, 0x20)
// Unpop from `hashes`.
hashesFront :=sub(hashesFront, 0x20)
}
// Advance to the next flag offset.
flags.offset:=add(flags.offset, 0x20)
// Slot of `a` in scratch space.// If the condition is true: 0x20, otherwise: 0x00.let scratch :=shl(5, gt(a, b))
// Hash the scratch space and push the result onto the queue.mstore(scratch, a)
mstore(xor(scratch, 0x20), b)
mstore(hashesBack, keccak256(0x00, 0x40))
hashesBack :=add(hashesBack, 0x20)
ifiszero(lt(hashesBack, flags.length)) { break }
}
isValid :=and(
// Checks if the last value in the queue is same as the root.eq(mload(sub(hashesBack, 0x20)), root),
// And whether all the proofs are used, if required.eq(proofEnd, proof.offset)
)
break
}
}
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* EMPTY CALLDATA HELPERS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev Returns an empty calldata bytes32 array.functionemptyProof() internalpurereturns (bytes32[] calldata proof) {
/// @solidity memory-safe-assemblyassembly {
proof.length:=0
}
}
/// @dev Returns an empty calldata bytes32 array.functionemptyLeaves() internalpurereturns (bytes32[] calldata leaves) {
/// @solidity memory-safe-assemblyassembly {
leaves.length:=0
}
}
/// @dev Returns an empty calldata bool array.functionemptyFlags() internalpurereturns (bool[] calldata flags) {
/// @solidity memory-safe-assemblyassembly {
flags.length:=0
}
}
}
Contract Source Code
File 10 of 12: Ownable.sol
// SPDX-License-Identifier: MITpragmasolidity ^0.8.4;/// @notice Simple single owner authorization mixin./// @author Solady (https://github.com/vectorized/solady/blob/main/src/auth/Ownable.sol)////// @dev Note:/// This implementation does NOT auto-initialize the owner to `msg.sender`./// You MUST call the `_initializeOwner` in the constructor / initializer.////// While the ownable portion follows/// [EIP-173](https://eips.ethereum.org/EIPS/eip-173) for compatibility,/// the nomenclature for the 2-step ownership handover may be unique to this codebase.abstractcontractOwnable{
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* CUSTOM ERRORS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev The caller is not authorized to call the function.errorUnauthorized();
/// @dev The `newOwner` cannot be the zero address.errorNewOwnerIsZeroAddress();
/// @dev The `pendingOwner` does not have a valid handover request.errorNoHandoverRequest();
/// @dev Cannot double-initialize.errorAlreadyInitialized();
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* EVENTS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev The ownership is transferred from `oldOwner` to `newOwner`./// This event is intentionally kept the same as OpenZeppelin's Ownable to be/// compatible with indexers and [EIP-173](https://eips.ethereum.org/EIPS/eip-173),/// despite it not being as lightweight as a single argument event.eventOwnershipTransferred(addressindexed oldOwner, addressindexed newOwner);
/// @dev An ownership handover to `pendingOwner` has been requested.eventOwnershipHandoverRequested(addressindexed pendingOwner);
/// @dev The ownership handover to `pendingOwner` has been canceled.eventOwnershipHandoverCanceled(addressindexed pendingOwner);
/// @dev `keccak256(bytes("OwnershipTransferred(address,address)"))`.uint256privateconstant _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE =0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0;
/// @dev `keccak256(bytes("OwnershipHandoverRequested(address)"))`.uint256privateconstant _OWNERSHIP_HANDOVER_REQUESTED_EVENT_SIGNATURE =0xdbf36a107da19e49527a7176a1babf963b4b0ff8cde35ee35d6cd8f1f9ac7e1d;
/// @dev `keccak256(bytes("OwnershipHandoverCanceled(address)"))`.uint256privateconstant _OWNERSHIP_HANDOVER_CANCELED_EVENT_SIGNATURE =0xfa7b8eab7da67f412cc9575ed43464468f9bfbae89d1675917346ca6d8fe3c92;
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* STORAGE *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev The owner slot is given by:/// `bytes32(~uint256(uint32(bytes4(keccak256("_OWNER_SLOT_NOT")))))`./// It is intentionally chosen to be a high value/// to avoid collision with lower slots./// The choice of manual storage layout is to enable compatibility/// with both regular and upgradeable contracts.bytes32internalconstant _OWNER_SLOT =0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927;
/// The ownership handover slot of `newOwner` is given by:/// ```/// mstore(0x00, or(shl(96, user), _HANDOVER_SLOT_SEED))/// let handoverSlot := keccak256(0x00, 0x20)/// ```/// It stores the expiry timestamp of the two-step ownership handover.uint256privateconstant _HANDOVER_SLOT_SEED =0x389a75e1;
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* INTERNAL FUNCTIONS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev Override to return true to make `_initializeOwner` prevent double-initialization.function_guardInitializeOwner() internalpurevirtualreturns (bool guard) {}
/// @dev Initializes the owner directly without authorization guard./// This function must be called upon initialization,/// regardless of whether the contract is upgradeable or not./// This is to enable generalization to both regular and upgradeable contracts,/// and to save gas in case the initial owner is not the caller./// For performance reasons, this function will not check if there/// is an existing owner.function_initializeOwner(address newOwner) internalvirtual{
if (_guardInitializeOwner()) {
/// @solidity memory-safe-assemblyassembly {
let ownerSlot := _OWNER_SLOT
ifsload(ownerSlot) {
mstore(0x00, 0x0dc149f0) // `AlreadyInitialized()`.revert(0x1c, 0x04)
}
// Clean the upper 96 bits.
newOwner :=shr(96, shl(96, newOwner))
// Store the new value.sstore(ownerSlot, or(newOwner, shl(255, iszero(newOwner))))
// Emit the {OwnershipTransferred} event.log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, 0, newOwner)
}
} else {
/// @solidity memory-safe-assemblyassembly {
// Clean the upper 96 bits.
newOwner :=shr(96, shl(96, newOwner))
// Store the new value.sstore(_OWNER_SLOT, newOwner)
// Emit the {OwnershipTransferred} event.log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, 0, newOwner)
}
}
}
/// @dev Sets the owner directly without authorization guard.function_setOwner(address newOwner) internalvirtual{
if (_guardInitializeOwner()) {
/// @solidity memory-safe-assemblyassembly {
let ownerSlot := _OWNER_SLOT
// Clean the upper 96 bits.
newOwner :=shr(96, shl(96, newOwner))
// Emit the {OwnershipTransferred} event.log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, sload(ownerSlot), newOwner)
// Store the new value.sstore(ownerSlot, or(newOwner, shl(255, iszero(newOwner))))
}
} else {
/// @solidity memory-safe-assemblyassembly {
let ownerSlot := _OWNER_SLOT
// Clean the upper 96 bits.
newOwner :=shr(96, shl(96, newOwner))
// Emit the {OwnershipTransferred} event.log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, sload(ownerSlot), newOwner)
// Store the new value.sstore(ownerSlot, newOwner)
}
}
}
/// @dev Throws if the sender is not the owner.function_checkOwner() internalviewvirtual{
/// @solidity memory-safe-assemblyassembly {
// If the caller is not the stored owner, revert.ifiszero(eq(caller(), sload(_OWNER_SLOT))) {
mstore(0x00, 0x82b42900) // `Unauthorized()`.revert(0x1c, 0x04)
}
}
}
/// @dev Returns how long a two-step ownership handover is valid for in seconds./// Override to return a different value if needed./// Made internal to conserve bytecode. Wrap it in a public function if needed.function_ownershipHandoverValidFor() internalviewvirtualreturns (uint64) {
return48*3600;
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* PUBLIC UPDATE FUNCTIONS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev Allows the owner to transfer the ownership to `newOwner`.functiontransferOwnership(address newOwner) publicpayablevirtualonlyOwner{
/// @solidity memory-safe-assemblyassembly {
ifiszero(shl(96, newOwner)) {
mstore(0x00, 0x7448fbae) // `NewOwnerIsZeroAddress()`.revert(0x1c, 0x04)
}
}
_setOwner(newOwner);
}
/// @dev Allows the owner to renounce their ownership.functionrenounceOwnership() publicpayablevirtualonlyOwner{
_setOwner(address(0));
}
/// @dev Request a two-step ownership handover to the caller./// The request will automatically expire in 48 hours (172800 seconds) by default.functionrequestOwnershipHandover() publicpayablevirtual{
unchecked {
uint256 expires =block.timestamp+ _ownershipHandoverValidFor();
/// @solidity memory-safe-assemblyassembly {
// Compute and set the handover slot to `expires`.mstore(0x0c, _HANDOVER_SLOT_SEED)
mstore(0x00, caller())
sstore(keccak256(0x0c, 0x20), expires)
// Emit the {OwnershipHandoverRequested} event.log2(0, 0, _OWNERSHIP_HANDOVER_REQUESTED_EVENT_SIGNATURE, caller())
}
}
}
/// @dev Cancels the two-step ownership handover to the caller, if any.functioncancelOwnershipHandover() publicpayablevirtual{
/// @solidity memory-safe-assemblyassembly {
// Compute and set the handover slot to 0.mstore(0x0c, _HANDOVER_SLOT_SEED)
mstore(0x00, caller())
sstore(keccak256(0x0c, 0x20), 0)
// Emit the {OwnershipHandoverCanceled} event.log2(0, 0, _OWNERSHIP_HANDOVER_CANCELED_EVENT_SIGNATURE, caller())
}
}
/// @dev Allows the owner to complete the two-step ownership handover to `pendingOwner`./// Reverts if there is no existing ownership handover requested by `pendingOwner`.functioncompleteOwnershipHandover(address pendingOwner) publicpayablevirtualonlyOwner{
/// @solidity memory-safe-assemblyassembly {
// Compute and set the handover slot to 0.mstore(0x0c, _HANDOVER_SLOT_SEED)
mstore(0x00, pendingOwner)
let handoverSlot :=keccak256(0x0c, 0x20)
// If the handover does not exist, or has expired.ifgt(timestamp(), sload(handoverSlot)) {
mstore(0x00, 0x6f5e8818) // `NoHandoverRequest()`.revert(0x1c, 0x04)
}
// Set the handover slot to 0.sstore(handoverSlot, 0)
}
_setOwner(pendingOwner);
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* PUBLIC READ FUNCTIONS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev Returns the owner of the contract.functionowner() publicviewvirtualreturns (address result) {
/// @solidity memory-safe-assemblyassembly {
result :=sload(_OWNER_SLOT)
}
}
/// @dev Returns the expiry timestamp for the two-step ownership handover to `pendingOwner`.functionownershipHandoverExpiresAt(address pendingOwner)
publicviewvirtualreturns (uint256 result)
{
/// @solidity memory-safe-assemblyassembly {
// Compute the handover slot.mstore(0x0c, _HANDOVER_SLOT_SEED)
mstore(0x00, pendingOwner)
// Load the handover slot.
result :=sload(keccak256(0x0c, 0x20))
}
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* MODIFIERS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev Marks a function as only callable by the owner.modifieronlyOwner() virtual{
_checkOwner();
_;
}
}
Contract Source Code
File 11 of 12: OwnableRoles.sol
// SPDX-License-Identifier: MITpragmasolidity ^0.8.4;import {Ownable} from"./Ownable.sol";
/// @notice Simple single owner and multiroles authorization mixin./// @author Solady (https://github.com/vectorized/solady/blob/main/src/auth/OwnableRoles.sol)////// @dev Note:/// This implementation does NOT auto-initialize the owner to `msg.sender`./// You MUST call the `_initializeOwner` in the constructor / initializer.////// While the ownable portion follows/// [EIP-173](https://eips.ethereum.org/EIPS/eip-173) for compatibility,/// the nomenclature for the 2-step ownership handover may be unique to this codebase.abstractcontractOwnableRolesisOwnable{
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* EVENTS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev The `user`'s roles is updated to `roles`./// Each bit of `roles` represents whether the role is set.eventRolesUpdated(addressindexed user, uint256indexed roles);
/// @dev `keccak256(bytes("RolesUpdated(address,uint256)"))`.uint256privateconstant _ROLES_UPDATED_EVENT_SIGNATURE =0x715ad5ce61fc9595c7b415289d59cf203f23a94fa06f04af7e489a0a76e1fe26;
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* STORAGE *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev The role slot of `user` is given by:/// ```/// mstore(0x00, or(shl(96, user), _ROLE_SLOT_SEED))/// let roleSlot := keccak256(0x00, 0x20)/// ```/// This automatically ignores the upper bits of the `user` in case/// they are not clean, as well as keep the `keccak256` under 32-bytes.////// Note: This is equivalent to `uint32(bytes4(keccak256("_OWNER_SLOT_NOT")))`.uint256privateconstant _ROLE_SLOT_SEED =0x8b78c6d8;
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* INTERNAL FUNCTIONS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev Overwrite the roles directly without authorization guard.function_setRoles(address user, uint256 roles) internalvirtual{
/// @solidity memory-safe-assemblyassembly {
mstore(0x0c, _ROLE_SLOT_SEED)
mstore(0x00, user)
// Store the new value.sstore(keccak256(0x0c, 0x20), roles)
// Emit the {RolesUpdated} event.log3(0, 0, _ROLES_UPDATED_EVENT_SIGNATURE, shr(96, mload(0x0c)), roles)
}
}
/// @dev Updates the roles directly without authorization guard./// If `on` is true, each set bit of `roles` will be turned on,/// otherwise, each set bit of `roles` will be turned off.function_updateRoles(address user, uint256 roles, bool on) internalvirtual{
/// @solidity memory-safe-assemblyassembly {
mstore(0x0c, _ROLE_SLOT_SEED)
mstore(0x00, user)
let roleSlot :=keccak256(0x0c, 0x20)
// Load the current value.let current :=sload(roleSlot)
// Compute the updated roles if `on` is true.let updated :=or(current, roles)
// Compute the updated roles if `on` is false.// Use `and` to compute the intersection of `current` and `roles`,// `xor` it with `current` to flip the bits in the intersection.ifiszero(on) { updated :=xor(current, and(current, roles)) }
// Then, store the new value.sstore(roleSlot, updated)
// Emit the {RolesUpdated} event.log3(0, 0, _ROLES_UPDATED_EVENT_SIGNATURE, shr(96, mload(0x0c)), updated)
}
}
/// @dev Grants the roles directly without authorization guard./// Each bit of `roles` represents the role to turn on.function_grantRoles(address user, uint256 roles) internalvirtual{
_updateRoles(user, roles, true);
}
/// @dev Removes the roles directly without authorization guard./// Each bit of `roles` represents the role to turn off.function_removeRoles(address user, uint256 roles) internalvirtual{
_updateRoles(user, roles, false);
}
/// @dev Throws if the sender does not have any of the `roles`.function_checkRoles(uint256 roles) internalviewvirtual{
/// @solidity memory-safe-assemblyassembly {
// Compute the role slot.mstore(0x0c, _ROLE_SLOT_SEED)
mstore(0x00, caller())
// Load the stored value, and if the `and` intersection// of the value and `roles` is zero, revert.ifiszero(and(sload(keccak256(0x0c, 0x20)), roles)) {
mstore(0x00, 0x82b42900) // `Unauthorized()`.revert(0x1c, 0x04)
}
}
}
/// @dev Throws if the sender is not the owner,/// and does not have any of the `roles`./// Checks for ownership first, then lazily checks for roles.function_checkOwnerOrRoles(uint256 roles) internalviewvirtual{
/// @solidity memory-safe-assemblyassembly {
// If the caller is not the stored owner.// Note: `_ROLE_SLOT_SEED` is equal to `_OWNER_SLOT_NOT`.ifiszero(eq(caller(), sload(not(_ROLE_SLOT_SEED)))) {
// Compute the role slot.mstore(0x0c, _ROLE_SLOT_SEED)
mstore(0x00, caller())
// Load the stored value, and if the `and` intersection// of the value and `roles` is zero, revert.ifiszero(and(sload(keccak256(0x0c, 0x20)), roles)) {
mstore(0x00, 0x82b42900) // `Unauthorized()`.revert(0x1c, 0x04)
}
}
}
}
/// @dev Throws if the sender does not have any of the `roles`,/// and is not the owner./// Checks for roles first, then lazily checks for ownership.function_checkRolesOrOwner(uint256 roles) internalviewvirtual{
/// @solidity memory-safe-assemblyassembly {
// Compute the role slot.mstore(0x0c, _ROLE_SLOT_SEED)
mstore(0x00, caller())
// Load the stored value, and if the `and` intersection// of the value and `roles` is zero, revert.ifiszero(and(sload(keccak256(0x0c, 0x20)), roles)) {
// If the caller is not the stored owner.// Note: `_ROLE_SLOT_SEED` is equal to `_OWNER_SLOT_NOT`.ifiszero(eq(caller(), sload(not(_ROLE_SLOT_SEED)))) {
mstore(0x00, 0x82b42900) // `Unauthorized()`.revert(0x1c, 0x04)
}
}
}
}
/// @dev Convenience function to return a `roles` bitmap from an array of `ordinals`./// This is meant for frontends like Etherscan, and is therefore not fully optimized./// Not recommended to be called on-chain./// Made internal to conserve bytecode. Wrap it in a public function if needed.function_rolesFromOrdinals(uint8[] memory ordinals) internalpurereturns (uint256 roles) {
/// @solidity memory-safe-assemblyassembly {
for { let i :=shl(5, mload(ordinals)) } i { i :=sub(i, 0x20) } {
// We don't need to mask the values of `ordinals`, as Solidity// cleans dirty upper bits when storing variables into memory.
roles :=or(shl(mload(add(ordinals, i)), 1), roles)
}
}
}
/// @dev Convenience function to return an array of `ordinals` from the `roles` bitmap./// This is meant for frontends like Etherscan, and is therefore not fully optimized./// Not recommended to be called on-chain./// Made internal to conserve bytecode. Wrap it in a public function if needed.function_ordinalsFromRoles(uint256 roles) internalpurereturns (uint8[] memory ordinals) {
/// @solidity memory-safe-assemblyassembly {
// Grab the pointer to the free memory.
ordinals :=mload(0x40)
let ptr :=add(ordinals, 0x20)
let o :=0// The absence of lookup tables, De Bruijn, etc., here is intentional for// smaller bytecode, as this function is not meant to be called on-chain.for { let t := roles } 1 {} {
mstore(ptr, o)
// `shr` 5 is equivalent to multiplying by 0x20.// Push back into the ordinals array if the bit is set.
ptr :=add(ptr, shl(5, and(t, 1)))
o :=add(o, 1)
t :=shr(o, roles)
ifiszero(t) { break }
}
// Store the length of `ordinals`.mstore(ordinals, shr(5, sub(ptr, add(ordinals, 0x20))))
// Allocate the memory.mstore(0x40, ptr)
}
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* PUBLIC UPDATE FUNCTIONS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev Allows the owner to grant `user` `roles`./// If the `user` already has a role, then it will be an no-op for the role.functiongrantRoles(address user, uint256 roles) publicpayablevirtualonlyOwner{
_grantRoles(user, roles);
}
/// @dev Allows the owner to remove `user` `roles`./// If the `user` does not have a role, then it will be an no-op for the role.functionrevokeRoles(address user, uint256 roles) publicpayablevirtualonlyOwner{
_removeRoles(user, roles);
}
/// @dev Allow the caller to remove their own roles./// If the caller does not have a role, then it will be an no-op for the role.functionrenounceRoles(uint256 roles) publicpayablevirtual{
_removeRoles(msg.sender, roles);
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* PUBLIC READ FUNCTIONS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev Returns the roles of `user`.functionrolesOf(address user) publicviewvirtualreturns (uint256 roles) {
/// @solidity memory-safe-assemblyassembly {
// Compute the role slot.mstore(0x0c, _ROLE_SLOT_SEED)
mstore(0x00, user)
// Load the stored value.
roles :=sload(keccak256(0x0c, 0x20))
}
}
/// @dev Returns whether `user` has any of `roles`.functionhasAnyRole(address user, uint256 roles) publicviewvirtualreturns (bool) {
return rolesOf(user) & roles !=0;
}
/// @dev Returns whether `user` has all of `roles`.functionhasAllRoles(address user, uint256 roles) publicviewvirtualreturns (bool) {
return rolesOf(user) & roles == roles;
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* MODIFIERS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev Marks a function as only callable by an account with `roles`.modifieronlyRoles(uint256 roles) virtual{
_checkRoles(roles);
_;
}
/// @dev Marks a function as only callable by the owner or by an account/// with `roles`. Checks for ownership first, then lazily checks for roles.modifieronlyOwnerOrRoles(uint256 roles) virtual{
_checkOwnerOrRoles(roles);
_;
}
/// @dev Marks a function as only callable by an account with `roles`/// or the owner. Checks for roles first, then lazily checks for ownership.modifieronlyRolesOrOwner(uint256 roles) virtual{
_checkRolesOrOwner(roles);
_;
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* ROLE CONSTANTS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/// IYKYKuint256internalconstant _ROLE_0 =1<<0;
uint256internalconstant _ROLE_1 =1<<1;
uint256internalconstant _ROLE_2 =1<<2;
uint256internalconstant _ROLE_3 =1<<3;
uint256internalconstant _ROLE_4 =1<<4;
uint256internalconstant _ROLE_5 =1<<5;
uint256internalconstant _ROLE_6 =1<<6;
uint256internalconstant _ROLE_7 =1<<7;
uint256internalconstant _ROLE_8 =1<<8;
uint256internalconstant _ROLE_9 =1<<9;
uint256internalconstant _ROLE_10 =1<<10;
uint256internalconstant _ROLE_11 =1<<11;
uint256internalconstant _ROLE_12 =1<<12;
uint256internalconstant _ROLE_13 =1<<13;
uint256internalconstant _ROLE_14 =1<<14;
uint256internalconstant _ROLE_15 =1<<15;
uint256internalconstant _ROLE_16 =1<<16;
uint256internalconstant _ROLE_17 =1<<17;
uint256internalconstant _ROLE_18 =1<<18;
uint256internalconstant _ROLE_19 =1<<19;
uint256internalconstant _ROLE_20 =1<<20;
uint256internalconstant _ROLE_21 =1<<21;
uint256internalconstant _ROLE_22 =1<<22;
uint256internalconstant _ROLE_23 =1<<23;
uint256internalconstant _ROLE_24 =1<<24;
uint256internalconstant _ROLE_25 =1<<25;
uint256internalconstant _ROLE_26 =1<<26;
uint256internalconstant _ROLE_27 =1<<27;
uint256internalconstant _ROLE_28 =1<<28;
uint256internalconstant _ROLE_29 =1<<29;
uint256internalconstant _ROLE_30 =1<<30;
uint256internalconstant _ROLE_31 =1<<31;
uint256internalconstant _ROLE_32 =1<<32;
uint256internalconstant _ROLE_33 =1<<33;
uint256internalconstant _ROLE_34 =1<<34;
uint256internalconstant _ROLE_35 =1<<35;
uint256internalconstant _ROLE_36 =1<<36;
uint256internalconstant _ROLE_37 =1<<37;
uint256internalconstant _ROLE_38 =1<<38;
uint256internalconstant _ROLE_39 =1<<39;
uint256internalconstant _ROLE_40 =1<<40;
uint256internalconstant _ROLE_41 =1<<41;
uint256internalconstant _ROLE_42 =1<<42;
uint256internalconstant _ROLE_43 =1<<43;
uint256internalconstant _ROLE_44 =1<<44;
uint256internalconstant _ROLE_45 =1<<45;
uint256internalconstant _ROLE_46 =1<<46;
uint256internalconstant _ROLE_47 =1<<47;
uint256internalconstant _ROLE_48 =1<<48;
uint256internalconstant _ROLE_49 =1<<49;
uint256internalconstant _ROLE_50 =1<<50;
uint256internalconstant _ROLE_51 =1<<51;
uint256internalconstant _ROLE_52 =1<<52;
uint256internalconstant _ROLE_53 =1<<53;
uint256internalconstant _ROLE_54 =1<<54;
uint256internalconstant _ROLE_55 =1<<55;
uint256internalconstant _ROLE_56 =1<<56;
uint256internalconstant _ROLE_57 =1<<57;
uint256internalconstant _ROLE_58 =1<<58;
uint256internalconstant _ROLE_59 =1<<59;
uint256internalconstant _ROLE_60 =1<<60;
uint256internalconstant _ROLE_61 =1<<61;
uint256internalconstant _ROLE_62 =1<<62;
uint256internalconstant _ROLE_63 =1<<63;
uint256internalconstant _ROLE_64 =1<<64;
uint256internalconstant _ROLE_65 =1<<65;
uint256internalconstant _ROLE_66 =1<<66;
uint256internalconstant _ROLE_67 =1<<67;
uint256internalconstant _ROLE_68 =1<<68;
uint256internalconstant _ROLE_69 =1<<69;
uint256internalconstant _ROLE_70 =1<<70;
uint256internalconstant _ROLE_71 =1<<71;
uint256internalconstant _ROLE_72 =1<<72;
uint256internalconstant _ROLE_73 =1<<73;
uint256internalconstant _ROLE_74 =1<<74;
uint256internalconstant _ROLE_75 =1<<75;
uint256internalconstant _ROLE_76 =1<<76;
uint256internalconstant _ROLE_77 =1<<77;
uint256internalconstant _ROLE_78 =1<<78;
uint256internalconstant _ROLE_79 =1<<79;
uint256internalconstant _ROLE_80 =1<<80;
uint256internalconstant _ROLE_81 =1<<81;
uint256internalconstant _ROLE_82 =1<<82;
uint256internalconstant _ROLE_83 =1<<83;
uint256internalconstant _ROLE_84 =1<<84;
uint256internalconstant _ROLE_85 =1<<85;
uint256internalconstant _ROLE_86 =1<<86;
uint256internalconstant _ROLE_87 =1<<87;
uint256internalconstant _ROLE_88 =1<<88;
uint256internalconstant _ROLE_89 =1<<89;
uint256internalconstant _ROLE_90 =1<<90;
uint256internalconstant _ROLE_91 =1<<91;
uint256internalconstant _ROLE_92 =1<<92;
uint256internalconstant _ROLE_93 =1<<93;
uint256internalconstant _ROLE_94 =1<<94;
uint256internalconstant _ROLE_95 =1<<95;
uint256internalconstant _ROLE_96 =1<<96;
uint256internalconstant _ROLE_97 =1<<97;
uint256internalconstant _ROLE_98 =1<<98;
uint256internalconstant _ROLE_99 =1<<99;
uint256internalconstant _ROLE_100 =1<<100;
uint256internalconstant _ROLE_101 =1<<101;
uint256internalconstant _ROLE_102 =1<<102;
uint256internalconstant _ROLE_103 =1<<103;
uint256internalconstant _ROLE_104 =1<<104;
uint256internalconstant _ROLE_105 =1<<105;
uint256internalconstant _ROLE_106 =1<<106;
uint256internalconstant _ROLE_107 =1<<107;
uint256internalconstant _ROLE_108 =1<<108;
uint256internalconstant _ROLE_109 =1<<109;
uint256internalconstant _ROLE_110 =1<<110;
uint256internalconstant _ROLE_111 =1<<111;
uint256internalconstant _ROLE_112 =1<<112;
uint256internalconstant _ROLE_113 =1<<113;
uint256internalconstant _ROLE_114 =1<<114;
uint256internalconstant _ROLE_115 =1<<115;
uint256internalconstant _ROLE_116 =1<<116;
uint256internalconstant _ROLE_117 =1<<117;
uint256internalconstant _ROLE_118 =1<<118;
uint256internalconstant _ROLE_119 =1<<119;
uint256internalconstant _ROLE_120 =1<<120;
uint256internalconstant _ROLE_121 =1<<121;
uint256internalconstant _ROLE_122 =1<<122;
uint256internalconstant _ROLE_123 =1<<123;
uint256internalconstant _ROLE_124 =1<<124;
uint256internalconstant _ROLE_125 =1<<125;
uint256internalconstant _ROLE_126 =1<<126;
uint256internalconstant _ROLE_127 =1<<127;
uint256internalconstant _ROLE_128 =1<<128;
uint256internalconstant _ROLE_129 =1<<129;
uint256internalconstant _ROLE_130 =1<<130;
uint256internalconstant _ROLE_131 =1<<131;
uint256internalconstant _ROLE_132 =1<<132;
uint256internalconstant _ROLE_133 =1<<133;
uint256internalconstant _ROLE_134 =1<<134;
uint256internalconstant _ROLE_135 =1<<135;
uint256internalconstant _ROLE_136 =1<<136;
uint256internalconstant _ROLE_137 =1<<137;
uint256internalconstant _ROLE_138 =1<<138;
uint256internalconstant _ROLE_139 =1<<139;
uint256internalconstant _ROLE_140 =1<<140;
uint256internalconstant _ROLE_141 =1<<141;
uint256internalconstant _ROLE_142 =1<<142;
uint256internalconstant _ROLE_143 =1<<143;
uint256internalconstant _ROLE_144 =1<<144;
uint256internalconstant _ROLE_145 =1<<145;
uint256internalconstant _ROLE_146 =1<<146;
uint256internalconstant _ROLE_147 =1<<147;
uint256internalconstant _ROLE_148 =1<<148;
uint256internalconstant _ROLE_149 =1<<149;
uint256internalconstant _ROLE_150 =1<<150;
uint256internalconstant _ROLE_151 =1<<151;
uint256internalconstant _ROLE_152 =1<<152;
uint256internalconstant _ROLE_153 =1<<153;
uint256internalconstant _ROLE_154 =1<<154;
uint256internalconstant _ROLE_155 =1<<155;
uint256internalconstant _ROLE_156 =1<<156;
uint256internalconstant _ROLE_157 =1<<157;
uint256internalconstant _ROLE_158 =1<<158;
uint256internalconstant _ROLE_159 =1<<159;
uint256internalconstant _ROLE_160 =1<<160;
uint256internalconstant _ROLE_161 =1<<161;
uint256internalconstant _ROLE_162 =1<<162;
uint256internalconstant _ROLE_163 =1<<163;
uint256internalconstant _ROLE_164 =1<<164;
uint256internalconstant _ROLE_165 =1<<165;
uint256internalconstant _ROLE_166 =1<<166;
uint256internalconstant _ROLE_167 =1<<167;
uint256internalconstant _ROLE_168 =1<<168;
uint256internalconstant _ROLE_169 =1<<169;
uint256internalconstant _ROLE_170 =1<<170;
uint256internalconstant _ROLE_171 =1<<171;
uint256internalconstant _ROLE_172 =1<<172;
uint256internalconstant _ROLE_173 =1<<173;
uint256internalconstant _ROLE_174 =1<<174;
uint256internalconstant _ROLE_175 =1<<175;
uint256internalconstant _ROLE_176 =1<<176;
uint256internalconstant _ROLE_177 =1<<177;
uint256internalconstant _ROLE_178 =1<<178;
uint256internalconstant _ROLE_179 =1<<179;
uint256internalconstant _ROLE_180 =1<<180;
uint256internalconstant _ROLE_181 =1<<181;
uint256internalconstant _ROLE_182 =1<<182;
uint256internalconstant _ROLE_183 =1<<183;
uint256internalconstant _ROLE_184 =1<<184;
uint256internalconstant _ROLE_185 =1<<185;
uint256internalconstant _ROLE_186 =1<<186;
uint256internalconstant _ROLE_187 =1<<187;
uint256internalconstant _ROLE_188 =1<<188;
uint256internalconstant _ROLE_189 =1<<189;
uint256internalconstant _ROLE_190 =1<<190;
uint256internalconstant _ROLE_191 =1<<191;
uint256internalconstant _ROLE_192 =1<<192;
uint256internalconstant _ROLE_193 =1<<193;
uint256internalconstant _ROLE_194 =1<<194;
uint256internalconstant _ROLE_195 =1<<195;
uint256internalconstant _ROLE_196 =1<<196;
uint256internalconstant _ROLE_197 =1<<197;
uint256internalconstant _ROLE_198 =1<<198;
uint256internalconstant _ROLE_199 =1<<199;
uint256internalconstant _ROLE_200 =1<<200;
uint256internalconstant _ROLE_201 =1<<201;
uint256internalconstant _ROLE_202 =1<<202;
uint256internalconstant _ROLE_203 =1<<203;
uint256internalconstant _ROLE_204 =1<<204;
uint256internalconstant _ROLE_205 =1<<205;
uint256internalconstant _ROLE_206 =1<<206;
uint256internalconstant _ROLE_207 =1<<207;
uint256internalconstant _ROLE_208 =1<<208;
uint256internalconstant _ROLE_209 =1<<209;
uint256internalconstant _ROLE_210 =1<<210;
uint256internalconstant _ROLE_211 =1<<211;
uint256internalconstant _ROLE_212 =1<<212;
uint256internalconstant _ROLE_213 =1<<213;
uint256internalconstant _ROLE_214 =1<<214;
uint256internalconstant _ROLE_215 =1<<215;
uint256internalconstant _ROLE_216 =1<<216;
uint256internalconstant _ROLE_217 =1<<217;
uint256internalconstant _ROLE_218 =1<<218;
uint256internalconstant _ROLE_219 =1<<219;
uint256internalconstant _ROLE_220 =1<<220;
uint256internalconstant _ROLE_221 =1<<221;
uint256internalconstant _ROLE_222 =1<<222;
uint256internalconstant _ROLE_223 =1<<223;
uint256internalconstant _ROLE_224 =1<<224;
uint256internalconstant _ROLE_225 =1<<225;
uint256internalconstant _ROLE_226 =1<<226;
uint256internalconstant _ROLE_227 =1<<227;
uint256internalconstant _ROLE_228 =1<<228;
uint256internalconstant _ROLE_229 =1<<229;
uint256internalconstant _ROLE_230 =1<<230;
uint256internalconstant _ROLE_231 =1<<231;
uint256internalconstant _ROLE_232 =1<<232;
uint256internalconstant _ROLE_233 =1<<233;
uint256internalconstant _ROLE_234 =1<<234;
uint256internalconstant _ROLE_235 =1<<235;
uint256internalconstant _ROLE_236 =1<<236;
uint256internalconstant _ROLE_237 =1<<237;
uint256internalconstant _ROLE_238 =1<<238;
uint256internalconstant _ROLE_239 =1<<239;
uint256internalconstant _ROLE_240 =1<<240;
uint256internalconstant _ROLE_241 =1<<241;
uint256internalconstant _ROLE_242 =1<<242;
uint256internalconstant _ROLE_243 =1<<243;
uint256internalconstant _ROLE_244 =1<<244;
uint256internalconstant _ROLE_245 =1<<245;
uint256internalconstant _ROLE_246 =1<<246;
uint256internalconstant _ROLE_247 =1<<247;
uint256internalconstant _ROLE_248 =1<<248;
uint256internalconstant _ROLE_249 =1<<249;
uint256internalconstant _ROLE_250 =1<<250;
uint256internalconstant _ROLE_251 =1<<251;
uint256internalconstant _ROLE_252 =1<<252;
uint256internalconstant _ROLE_253 =1<<253;
uint256internalconstant _ROLE_254 =1<<254;
uint256internalconstant _ROLE_255 =1<<255;
}
Contract Source Code
File 12 of 12: SafeTransferLib.sol
// SPDX-License-Identifier: MITpragmasolidity ^0.8.4;/// @notice Safe ETH and ERC20 transfer library that gracefully handles missing return values./// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/SafeTransferLib.sol)/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/SafeTransferLib.sol)/// @author Permit2 operations from (https://github.com/Uniswap/permit2/blob/main/src/libraries/Permit2Lib.sol)////// @dev Note:/// - For ETH transfers, please use `forceSafeTransferETH` for DoS protection./// - For ERC20s, this implementation won't check that a token has code,/// responsibility is delegated to the caller.librarySafeTransferLib{
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* CUSTOM ERRORS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev The ETH transfer has failed.errorETHTransferFailed();
/// @dev The ERC20 `transferFrom` has failed.errorTransferFromFailed();
/// @dev The ERC20 `transfer` has failed.errorTransferFailed();
/// @dev The ERC20 `approve` has failed.errorApproveFailed();
/// @dev The Permit2 operation has failed.errorPermit2Failed();
/// @dev The Permit2 amount must be less than `2**160 - 1`.errorPermit2AmountOverflow();
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* CONSTANTS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev Suggested gas stipend for contract receiving ETH that disallows any storage writes.uint256internalconstant GAS_STIPEND_NO_STORAGE_WRITES =2300;
/// @dev Suggested gas stipend for contract receiving ETH to perform a few/// storage reads and writes, but low enough to prevent griefing.uint256internalconstant GAS_STIPEND_NO_GRIEF =100000;
/// @dev The unique EIP-712 domain domain separator for the DAI token contract.bytes32internalconstant DAI_DOMAIN_SEPARATOR =0xdbb8cf42e1ecb028be3f3dbc922e1d878b963f411dc388ced501601c60f7c6f7;
/// @dev The address for the WETH9 contract on Ethereum mainnet.addressinternalconstant WETH9 =0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
/// @dev The canonical Permit2 address./// [Github](https://github.com/Uniswap/permit2)/// [Etherscan](https://etherscan.io/address/0x000000000022D473030F116dDEE9F6B43aC78BA3)addressinternalconstant PERMIT2 =0x000000000022D473030F116dDEE9F6B43aC78BA3;
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* ETH OPERATIONS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/// If the ETH transfer MUST succeed with a reasonable gas budget, use the force variants.//// The regular variants:// - Forwards all remaining gas to the target.// - Reverts if the target reverts.// - Reverts if the current contract has insufficient balance.//// The force variants:// - Forwards with an optional gas stipend// (defaults to `GAS_STIPEND_NO_GRIEF`, which is sufficient for most cases).// - If the target reverts, or if the gas stipend is exhausted,// creates a temporary contract to force send the ETH via `SELFDESTRUCT`.// Future compatible with `SENDALL`: https://eips.ethereum.org/EIPS/eip-4758.// - Reverts if the current contract has insufficient balance.//// The try variants:// - Forwards with a mandatory gas stipend.// - Instead of reverting, returns whether the transfer succeeded./// @dev Sends `amount` (in wei) ETH to `to`.functionsafeTransferETH(address to, uint256 amount) internal{
/// @solidity memory-safe-assemblyassembly {
ifiszero(call(gas(), to, amount, codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.revert(0x1c, 0x04)
}
}
}
/// @dev Sends all the ETH in the current contract to `to`.functionsafeTransferAllETH(address to) internal{
/// @solidity memory-safe-assemblyassembly {
// Transfer all the ETH and check if it succeeded or not.ifiszero(call(gas(), to, selfbalance(), codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.revert(0x1c, 0x04)
}
}
}
/// @dev Force sends `amount` (in wei) ETH to `to`, with a `gasStipend`.functionforceSafeTransferETH(address to, uint256 amount, uint256 gasStipend) internal{
/// @solidity memory-safe-assemblyassembly {
iflt(selfbalance(), amount) {
mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.revert(0x1c, 0x04)
}
ifiszero(call(gasStipend, to, amount, codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, to) // Store the address in scratch space.mstore8(0x0b, 0x73) // Opcode `PUSH20`.mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.ifiszero(create(amount, 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.
}
}
}
/// @dev Force sends all the ETH in the current contract to `to`, with a `gasStipend`.functionforceSafeTransferAllETH(address to, uint256 gasStipend) internal{
/// @solidity memory-safe-assemblyassembly {
ifiszero(call(gasStipend, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, to) // Store the address in scratch space.mstore8(0x0b, 0x73) // Opcode `PUSH20`.mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.ifiszero(create(selfbalance(), 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.
}
}
}
/// @dev Force sends `amount` (in wei) ETH to `to`, with `GAS_STIPEND_NO_GRIEF`.functionforceSafeTransferETH(address to, uint256 amount) internal{
/// @solidity memory-safe-assemblyassembly {
iflt(selfbalance(), amount) {
mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.revert(0x1c, 0x04)
}
ifiszero(call(GAS_STIPEND_NO_GRIEF, to, amount, codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, to) // Store the address in scratch space.mstore8(0x0b, 0x73) // Opcode `PUSH20`.mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.ifiszero(create(amount, 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.
}
}
}
/// @dev Force sends all the ETH in the current contract to `to`, with `GAS_STIPEND_NO_GRIEF`.functionforceSafeTransferAllETH(address to) internal{
/// @solidity memory-safe-assemblyassembly {
// forgefmt: disable-next-itemifiszero(call(GAS_STIPEND_NO_GRIEF, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, to) // Store the address in scratch space.mstore8(0x0b, 0x73) // Opcode `PUSH20`.mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.ifiszero(create(selfbalance(), 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.
}
}
}
/// @dev Sends `amount` (in wei) ETH to `to`, with a `gasStipend`.functiontrySafeTransferETH(address to, uint256 amount, uint256 gasStipend)
internalreturns (bool success)
{
/// @solidity memory-safe-assemblyassembly {
success :=call(gasStipend, to, amount, codesize(), 0x00, codesize(), 0x00)
}
}
/// @dev Sends all the ETH in the current contract to `to`, with a `gasStipend`.functiontrySafeTransferAllETH(address to, uint256 gasStipend)
internalreturns (bool success)
{
/// @solidity memory-safe-assemblyassembly {
success :=call(gasStipend, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)
}
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* ERC20 OPERATIONS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev Sends `amount` of ERC20 `token` from `from` to `to`./// Reverts upon failure.////// The `from` account must have at least `amount` approved for/// the current contract to manage.functionsafeTransferFrom(address token, addressfrom, address to, uint256 amount) internal{
/// @solidity memory-safe-assemblyassembly {
let m :=mload(0x40) // Cache the free memory pointer.mstore(0x60, amount) // Store the `amount` argument.mstore(0x40, to) // Store the `to` argument.mstore(0x2c, shl(96, from)) // Store the `from` argument.mstore(0x0c, 0x23b872dd000000000000000000000000) // `transferFrom(address,address,uint256)`.// Perform the transfer, reverting upon failure.ifiszero(
and( // The arguments of `and` are evaluated from right to left.or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)
)
) {
mstore(0x00, 0x7939f424) // `TransferFromFailed()`.revert(0x1c, 0x04)
}
mstore(0x60, 0) // Restore the zero slot to zero.mstore(0x40, m) // Restore the free memory pointer.
}
}
/// @dev Sends `amount` of ERC20 `token` from `from` to `to`.////// The `from` account must have at least `amount` approved for the current contract to manage.functiontrySafeTransferFrom(address token, addressfrom, address to, uint256 amount)
internalreturns (bool success)
{
/// @solidity memory-safe-assemblyassembly {
let m :=mload(0x40) // Cache the free memory pointer.mstore(0x60, amount) // Store the `amount` argument.mstore(0x40, to) // Store the `to` argument.mstore(0x2c, shl(96, from)) // Store the `from` argument.mstore(0x0c, 0x23b872dd000000000000000000000000) // `transferFrom(address,address,uint256)`.
success :=and( // The arguments of `and` are evaluated from right to left.or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)
)
mstore(0x60, 0) // Restore the zero slot to zero.mstore(0x40, m) // Restore the free memory pointer.
}
}
/// @dev Sends all of ERC20 `token` from `from` to `to`./// Reverts upon failure.////// The `from` account must have their entire balance approved for the current contract to manage.functionsafeTransferAllFrom(address token, addressfrom, address to)
internalreturns (uint256 amount)
{
/// @solidity memory-safe-assemblyassembly {
let m :=mload(0x40) // Cache the free memory pointer.mstore(0x40, to) // Store the `to` argument.mstore(0x2c, shl(96, from)) // Store the `from` argument.mstore(0x0c, 0x70a08231000000000000000000000000) // `balanceOf(address)`.// Read the balance, reverting upon failure.ifiszero(
and( // The arguments of `and` are evaluated from right to left.gt(returndatasize(), 0x1f), // At least 32 bytes returned.staticcall(gas(), token, 0x1c, 0x24, 0x60, 0x20)
)
) {
mstore(0x00, 0x7939f424) // `TransferFromFailed()`.revert(0x1c, 0x04)
}
mstore(0x00, 0x23b872dd) // `transferFrom(address,address,uint256)`.
amount :=mload(0x60) // The `amount` is already at 0x60. We'll need to return it.// Perform the transfer, reverting upon failure.ifiszero(
and( // The arguments of `and` are evaluated from right to left.or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)
)
) {
mstore(0x00, 0x7939f424) // `TransferFromFailed()`.revert(0x1c, 0x04)
}
mstore(0x60, 0) // Restore the zero slot to zero.mstore(0x40, m) // Restore the free memory pointer.
}
}
/// @dev Sends `amount` of ERC20 `token` from the current contract to `to`./// Reverts upon failure.functionsafeTransfer(address token, address to, uint256 amount) internal{
/// @solidity memory-safe-assemblyassembly {
mstore(0x14, to) // Store the `to` argument.mstore(0x34, amount) // Store the `amount` argument.mstore(0x00, 0xa9059cbb000000000000000000000000) // `transfer(address,uint256)`.// Perform the transfer, reverting upon failure.ifiszero(
and( // The arguments of `and` are evaluated from right to left.or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
)
) {
mstore(0x00, 0x90b8ec18) // `TransferFailed()`.revert(0x1c, 0x04)
}
mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.
}
}
/// @dev Sends all of ERC20 `token` from the current contract to `to`./// Reverts upon failure.functionsafeTransferAll(address token, address to) internalreturns (uint256 amount) {
/// @solidity memory-safe-assemblyassembly {
mstore(0x00, 0x70a08231) // Store the function selector of `balanceOf(address)`.mstore(0x20, address()) // Store the address of the current contract.// Read the balance, reverting upon failure.ifiszero(
and( // The arguments of `and` are evaluated from right to left.gt(returndatasize(), 0x1f), // At least 32 bytes returned.staticcall(gas(), token, 0x1c, 0x24, 0x34, 0x20)
)
) {
mstore(0x00, 0x90b8ec18) // `TransferFailed()`.revert(0x1c, 0x04)
}
mstore(0x14, to) // Store the `to` argument.
amount :=mload(0x34) // The `amount` is already at 0x34. We'll need to return it.mstore(0x00, 0xa9059cbb000000000000000000000000) // `transfer(address,uint256)`.// Perform the transfer, reverting upon failure.ifiszero(
and( // The arguments of `and` are evaluated from right to left.or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
)
) {
mstore(0x00, 0x90b8ec18) // `TransferFailed()`.revert(0x1c, 0x04)
}
mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.
}
}
/// @dev Sets `amount` of ERC20 `token` for `to` to manage on behalf of the current contract./// Reverts upon failure.functionsafeApprove(address token, address to, uint256 amount) internal{
/// @solidity memory-safe-assemblyassembly {
mstore(0x14, to) // Store the `to` argument.mstore(0x34, amount) // Store the `amount` argument.mstore(0x00, 0x095ea7b3000000000000000000000000) // `approve(address,uint256)`.// Perform the approval, reverting upon failure.ifiszero(
and( // The arguments of `and` are evaluated from right to left.or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
)
) {
mstore(0x00, 0x3e3f8f73) // `ApproveFailed()`.revert(0x1c, 0x04)
}
mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.
}
}
/// @dev Sets `amount` of ERC20 `token` for `to` to manage on behalf of the current contract./// If the initial attempt to approve fails, attempts to reset the approved amount to zero,/// then retries the approval again (some tokens, e.g. USDT, requires this)./// Reverts upon failure.functionsafeApproveWithRetry(address token, address to, uint256 amount) internal{
/// @solidity memory-safe-assemblyassembly {
mstore(0x14, to) // Store the `to` argument.mstore(0x34, amount) // Store the `amount` argument.mstore(0x00, 0x095ea7b3000000000000000000000000) // `approve(address,uint256)`.// Perform the approval, retrying upon failure.ifiszero(
and( // The arguments of `and` are evaluated from right to left.or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
)
) {
mstore(0x34, 0) // Store 0 for the `amount`.mstore(0x00, 0x095ea7b3000000000000000000000000) // `approve(address,uint256)`.pop(call(gas(), token, 0, 0x10, 0x44, codesize(), 0x00)) // Reset the approval.mstore(0x34, amount) // Store back the original `amount`.// Retry the approval, reverting upon failure.ifiszero(
and(
or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
)
) {
mstore(0x00, 0x3e3f8f73) // `ApproveFailed()`.revert(0x1c, 0x04)
}
}
mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.
}
}
/// @dev Returns the amount of ERC20 `token` owned by `account`./// Returns zero if the `token` does not exist.functionbalanceOf(address token, address account) internalviewreturns (uint256 amount) {
/// @solidity memory-safe-assemblyassembly {
mstore(0x14, account) // Store the `account` argument.mstore(0x00, 0x70a08231000000000000000000000000) // `balanceOf(address)`.
amount :=mul( // The arguments of `mul` are evaluated from right to left.mload(0x20),
and( // The arguments of `and` are evaluated from right to left.gt(returndatasize(), 0x1f), // At least 32 bytes returned.staticcall(gas(), token, 0x10, 0x24, 0x20, 0x20)
)
)
}
}
/// @dev Sends `amount` of ERC20 `token` from `from` to `to`./// If the initial attempt fails, try to use Permit2 to transfer the token./// Reverts upon failure.////// The `from` account must have at least `amount` approved for the current contract to manage.functionsafeTransferFrom2(address token, addressfrom, address to, uint256 amount) internal{
if (!trySafeTransferFrom(token, from, to, amount)) {
permit2TransferFrom(token, from, to, amount);
}
}
/// @dev Sends `amount` of ERC20 `token` from `from` to `to` via Permit2./// Reverts upon failure.functionpermit2TransferFrom(address token, addressfrom, address to, uint256 amount)
internal{
/// @solidity memory-safe-assemblyassembly {
let m :=mload(0x40)
mstore(add(m, 0x74), shr(96, shl(96, token)))
mstore(add(m, 0x54), amount)
mstore(add(m, 0x34), to)
mstore(add(m, 0x20), shl(96, from))
// `transferFrom(address,address,uint160,address)`.mstore(m, 0x36c78516000000000000000000000000)
let p := PERMIT2
let exists :=eq(chainid(), 1)
ifiszero(exists) { exists :=iszero(iszero(extcodesize(p))) }
ifiszero(and(call(gas(), p, 0, add(m, 0x10), 0x84, codesize(), 0x00), exists)) {
mstore(0x00, 0x7939f4248757f0fd) // `TransferFromFailed()` or `Permit2AmountOverflow()`.revert(add(0x18, shl(2, iszero(iszero(shr(160, amount))))), 0x04)
}
}
}
/// @dev Permit a user to spend a given amount of/// another user's tokens via native EIP-2612 permit if possible, falling/// back to Permit2 if native permit fails or is not implemented on the token.functionpermit2(address token,
address owner,
address spender,
uint256 amount,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) internal{
bool success;
/// @solidity memory-safe-assemblyassembly {
for {} shl(96, xor(token, WETH9)) {} {
mstore(0x00, 0x3644e515) // `DOMAIN_SEPARATOR()`.ifiszero(
and( // The arguments of `and` are evaluated from right to left.lt(iszero(mload(0x00)), eq(returndatasize(), 0x20)), // Returns 1 non-zero word.// Gas stipend to limit gas burn for tokens that don't refund gas when// an non-existing function is called. 5K should be enough for a SLOAD.staticcall(5000, token, 0x1c, 0x04, 0x00, 0x20)
)
) { break }
// After here, we can be sure that token is a contract.let m :=mload(0x40)
mstore(add(m, 0x34), spender)
mstore(add(m, 0x20), shl(96, owner))
mstore(add(m, 0x74), deadline)
ifeq(mload(0x00), DAI_DOMAIN_SEPARATOR) {
mstore(0x14, owner)
mstore(0x00, 0x7ecebe00000000000000000000000000) // `nonces(address)`.mstore(add(m, 0x94), staticcall(gas(), token, 0x10, 0x24, add(m, 0x54), 0x20))
mstore(m, 0x8fcbaf0c000000000000000000000000) // `IDAIPermit.permit`.// `nonces` is already at `add(m, 0x54)`.// `1` is already stored at `add(m, 0x94)`.mstore(add(m, 0xb4), and(0xff, v))
mstore(add(m, 0xd4), r)
mstore(add(m, 0xf4), s)
success :=call(gas(), token, 0, add(m, 0x10), 0x104, codesize(), 0x00)
break
}
mstore(m, 0xd505accf000000000000000000000000) // `IERC20Permit.permit`.mstore(add(m, 0x54), amount)
mstore(add(m, 0x94), and(0xff, v))
mstore(add(m, 0xb4), r)
mstore(add(m, 0xd4), s)
success :=call(gas(), token, 0, add(m, 0x10), 0xe4, codesize(), 0x00)
break
}
}
if (!success) simplePermit2(token, owner, spender, amount, deadline, v, r, s);
}
/// @dev Simple permit on the Permit2 contract.functionsimplePermit2(address token,
address owner,
address spender,
uint256 amount,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) internal{
/// @solidity memory-safe-assemblyassembly {
let m :=mload(0x40)
mstore(m, 0x927da105) // `allowance(address,address,address)`.
{
let addressMask :=shr(96, not(0))
mstore(add(m, 0x20), and(addressMask, owner))
mstore(add(m, 0x40), and(addressMask, token))
mstore(add(m, 0x60), and(addressMask, spender))
mstore(add(m, 0xc0), and(addressMask, spender))
}
let p :=mul(PERMIT2, iszero(shr(160, amount)))
ifiszero(
and( // The arguments of `and` are evaluated from right to left.gt(returndatasize(), 0x5f), // Returns 3 words: `amount`, `expiration`, `nonce`.staticcall(gas(), p, add(m, 0x1c), 0x64, add(m, 0x60), 0x60)
)
) {
mstore(0x00, 0x6b836e6b8757f0fd) // `Permit2Failed()` or `Permit2AmountOverflow()`.revert(add(0x18, shl(2, iszero(p))), 0x04)
}
mstore(m, 0x2b67b570) // `Permit2.permit` (PermitSingle variant).// `owner` is already `add(m, 0x20)`.// `token` is already at `add(m, 0x40)`.mstore(add(m, 0x60), amount)
mstore(add(m, 0x80), 0xffffffffffff) // `expiration = type(uint48).max`.// `nonce` is already at `add(m, 0xa0)`.// `spender` is already at `add(m, 0xc0)`.mstore(add(m, 0xe0), deadline)
mstore(add(m, 0x100), 0x100) // `signature` offset.mstore(add(m, 0x120), 0x41) // `signature` length.mstore(add(m, 0x140), r)
mstore(add(m, 0x160), s)
mstore(add(m, 0x180), shl(248, v))
ifiszero(call(gas(), p, 0, add(m, 0x1c), 0x184, codesize(), 0x00)) {
mstore(0x00, 0x6b836e6b) // `Permit2Failed()`.revert(0x1c, 0x04)
}
}
}
}
