Source Code
Overview
APE Balance
0 APEMore Info
ContractCreator
Multichain Info
N/A
Loading...
Loading
Contract Source Code Verified (Exact Match)
Contract Name:
LiquidityManager
Compiler Version
v0.8.28+commit.7893614a
Contract Source Code (Solidity)
/**
*Submitted for verification at curtis.apescan.io on 2025-09-10
*/
//SPDX-License-Identifier: MIT
pragma solidity 0.8.28;
/**
* @title ERC721 token receiver interface
* @dev Interface for any contract that wants to support safeTransfers
* from ERC721 asset contracts.
*/
interface IERC721Receiver {
/**
* @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
* by `operator` from `from`, this function is called.
*
* It must return its Solidity selector to confirm the token transfer.
* If any other value is returned or the interface is not implemented by the recipient, the transfer will be
* reverted.
*
* The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
*/
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
interface IV3Locker {
function lock(
uint256 nftId_,
address creator_,
address liquidNFTContract_
) external payable returns (uint256 lockId);
}
interface IV3Token {
function transfer(
address recipient,
uint256 amount
) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
function approve(
address spender,
uint256 amount
) external returns (bool);
function balanceOf(
address account
) external view returns (uint256);
function launch() external;
function getLiquidNFT() external view returns (address);
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function createPair(address tokenA, address tokenB) external returns (address pair);
function setFeeTo(address) external;
function setFeeToSetter(address) external;
}
interface INonfungiblePositionManager {
function createAndInitializePoolIfNecessary(
address token0,
address token1,
uint160 sqrtPriceX96
) external payable returns (address pool);
function approve(address to, uint256 tokenId) external;
struct MintParams {
address token0;
address token1;
int24 tickLower;
int24 tickUpper;
uint256 amount0Desired;
uint256 amount1Desired;
uint256 amount0Min;
uint256 amount1Min;
address recipient;
uint256 deadline;
}
function mint(MintParams calldata params) external payable returns (
uint256 tokenId,
uint128 liquidity,
uint256 amount0,
uint256 amount1
);
function refundNativeToken() external payable;
}
/**
* @dev Helper library for emitting standardized panic codes.
*
* ```solidity
* contract Example {
* using Panic for uint256;
*
* // Use any of the declared internal constants
* function foo() { Panic.GENERIC.panic(); }
*
* // Alternatively
* function foo() { Panic.panic(Panic.GENERIC); }
* }
* ```
*
* Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].
*
* _Available since v5.1._
*/
// slither-disable-next-line unused-state
library Panic {
/// @dev generic / unspecified error
uint256 internal constant GENERIC = 0x00;
/// @dev used by the assert() builtin
uint256 internal constant ASSERT = 0x01;
/// @dev arithmetic underflow or overflow
uint256 internal constant UNDER_OVERFLOW = 0x11;
/// @dev division or modulo by zero
uint256 internal constant DIVISION_BY_ZERO = 0x12;
/// @dev enum conversion error
uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;
/// @dev invalid encoding in storage
uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;
/// @dev empty array pop
uint256 internal constant EMPTY_ARRAY_POP = 0x31;
/// @dev array out of bounds access
uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;
/// @dev resource error (too large allocation or too large array)
uint256 internal constant RESOURCE_ERROR = 0x41;
/// @dev calling invalid internal function
uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;
/// @dev Reverts with a panic code. Recommended to use with
/// the internal constants with predefined codes.
function panic(uint256 code) internal pure {
assembly ("memory-safe") {
mstore(0x00, 0x4e487b71)
mstore(0x20, code)
revert(0x1c, 0x24)
}
}
}
/**
* @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow
* checks.
*
* Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
* easily result in undesired exploitation or bugs, since developers usually
* assume that overflows raise errors. `SafeCast` restores this intuition by
* reverting the transaction when such an operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
library SafeCast {
/**
* @dev Value doesn't fit in an uint of `bits` size.
*/
error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);
/**
* @dev An int value doesn't fit in an uint of `bits` size.
*/
error SafeCastOverflowedIntToUint(int256 value);
/**
* @dev Value doesn't fit in an int of `bits` size.
*/
error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);
/**
* @dev An uint value doesn't fit in an int of `bits` size.
*/
error SafeCastOverflowedUintToInt(uint256 value);
/**
* @dev Returns the downcasted uint248 from uint256, reverting on
* overflow (when the input is greater than largest uint248).
*
* Counterpart to Solidity's `uint248` operator.
*
* Requirements:
*
* - input must fit into 248 bits
*/
function toUint248(uint256 value) internal pure returns (uint248) {
if (value > type(uint248).max) {
revert SafeCastOverflowedUintDowncast(248, value);
}
return uint248(value);
}
/**
* @dev Returns the downcasted uint240 from uint256, reverting on
* overflow (when the input is greater than largest uint240).
*
* Counterpart to Solidity's `uint240` operator.
*
* Requirements:
*
* - input must fit into 240 bits
*/
function toUint240(uint256 value) internal pure returns (uint240) {
if (value > type(uint240).max) {
revert SafeCastOverflowedUintDowncast(240, value);
}
return uint240(value);
}
/**
* @dev Returns the downcasted uint232 from uint256, reverting on
* overflow (when the input is greater than largest uint232).
*
* Counterpart to Solidity's `uint232` operator.
*
* Requirements:
*
* - input must fit into 232 bits
*/
function toUint232(uint256 value) internal pure returns (uint232) {
if (value > type(uint232).max) {
revert SafeCastOverflowedUintDowncast(232, value);
}
return uint232(value);
}
/**
* @dev Returns the downcasted uint224 from uint256, reverting on
* overflow (when the input is greater than largest uint224).
*
* Counterpart to Solidity's `uint224` operator.
*
* Requirements:
*
* - input must fit into 224 bits
*/
function toUint224(uint256 value) internal pure returns (uint224) {
if (value > type(uint224).max) {
revert SafeCastOverflowedUintDowncast(224, value);
}
return uint224(value);
}
/**
* @dev Returns the downcasted uint216 from uint256, reverting on
* overflow (when the input is greater than largest uint216).
*
* Counterpart to Solidity's `uint216` operator.
*
* Requirements:
*
* - input must fit into 216 bits
*/
function toUint216(uint256 value) internal pure returns (uint216) {
if (value > type(uint216).max) {
revert SafeCastOverflowedUintDowncast(216, value);
}
return uint216(value);
}
/**
* @dev Returns the downcasted uint208 from uint256, reverting on
* overflow (when the input is greater than largest uint208).
*
* Counterpart to Solidity's `uint208` operator.
*
* Requirements:
*
* - input must fit into 208 bits
*/
function toUint208(uint256 value) internal pure returns (uint208) {
if (value > type(uint208).max) {
revert SafeCastOverflowedUintDowncast(208, value);
}
return uint208(value);
}
/**
* @dev Returns the downcasted uint200 from uint256, reverting on
* overflow (when the input is greater than largest uint200).
*
* Counterpart to Solidity's `uint200` operator.
*
* Requirements:
*
* - input must fit into 200 bits
*/
function toUint200(uint256 value) internal pure returns (uint200) {
if (value > type(uint200).max) {
revert SafeCastOverflowedUintDowncast(200, value);
}
return uint200(value);
}
/**
* @dev Returns the downcasted uint192 from uint256, reverting on
* overflow (when the input is greater than largest uint192).
*
* Counterpart to Solidity's `uint192` operator.
*
* Requirements:
*
* - input must fit into 192 bits
*/
function toUint192(uint256 value) internal pure returns (uint192) {
if (value > type(uint192).max) {
revert SafeCastOverflowedUintDowncast(192, value);
}
return uint192(value);
}
/**
* @dev Returns the downcasted uint184 from uint256, reverting on
* overflow (when the input is greater than largest uint184).
*
* Counterpart to Solidity's `uint184` operator.
*
* Requirements:
*
* - input must fit into 184 bits
*/
function toUint184(uint256 value) internal pure returns (uint184) {
if (value > type(uint184).max) {
revert SafeCastOverflowedUintDowncast(184, value);
}
return uint184(value);
}
/**
* @dev Returns the downcasted uint176 from uint256, reverting on
* overflow (when the input is greater than largest uint176).
*
* Counterpart to Solidity's `uint176` operator.
*
* Requirements:
*
* - input must fit into 176 bits
*/
function toUint176(uint256 value) internal pure returns (uint176) {
if (value > type(uint176).max) {
revert SafeCastOverflowedUintDowncast(176, value);
}
return uint176(value);
}
/**
* @dev Returns the downcasted uint168 from uint256, reverting on
* overflow (when the input is greater than largest uint168).
*
* Counterpart to Solidity's `uint168` operator.
*
* Requirements:
*
* - input must fit into 168 bits
*/
function toUint168(uint256 value) internal pure returns (uint168) {
if (value > type(uint168).max) {
revert SafeCastOverflowedUintDowncast(168, value);
}
return uint168(value);
}
/**
* @dev Returns the downcasted uint160 from uint256, reverting on
* overflow (when the input is greater than largest uint160).
*
* Counterpart to Solidity's `uint160` operator.
*
* Requirements:
*
* - input must fit into 160 bits
*/
function toUint160(uint256 value) internal pure returns (uint160) {
if (value > type(uint160).max) {
revert SafeCastOverflowedUintDowncast(160, value);
}
return uint160(value);
}
/**
* @dev Returns the downcasted uint152 from uint256, reverting on
* overflow (when the input is greater than largest uint152).
*
* Counterpart to Solidity's `uint152` operator.
*
* Requirements:
*
* - input must fit into 152 bits
*/
function toUint152(uint256 value) internal pure returns (uint152) {
if (value > type(uint152).max) {
revert SafeCastOverflowedUintDowncast(152, value);
}
return uint152(value);
}
/**
* @dev Returns the downcasted uint144 from uint256, reverting on
* overflow (when the input is greater than largest uint144).
*
* Counterpart to Solidity's `uint144` operator.
*
* Requirements:
*
* - input must fit into 144 bits
*/
function toUint144(uint256 value) internal pure returns (uint144) {
if (value > type(uint144).max) {
revert SafeCastOverflowedUintDowncast(144, value);
}
return uint144(value);
}
/**
* @dev Returns the downcasted uint136 from uint256, reverting on
* overflow (when the input is greater than largest uint136).
*
* Counterpart to Solidity's `uint136` operator.
*
* Requirements:
*
* - input must fit into 136 bits
*/
function toUint136(uint256 value) internal pure returns (uint136) {
if (value > type(uint136).max) {
revert SafeCastOverflowedUintDowncast(136, value);
}
return uint136(value);
}
/**
* @dev Returns the downcasted uint128 from uint256, reverting on
* overflow (when the input is greater than largest uint128).
*
* Counterpart to Solidity's `uint128` operator.
*
* Requirements:
*
* - input must fit into 128 bits
*/
function toUint128(uint256 value) internal pure returns (uint128) {
if (value > type(uint128).max) {
revert SafeCastOverflowedUintDowncast(128, value);
}
return uint128(value);
}
/**
* @dev Returns the downcasted uint120 from uint256, reverting on
* overflow (when the input is greater than largest uint120).
*
* Counterpart to Solidity's `uint120` operator.
*
* Requirements:
*
* - input must fit into 120 bits
*/
function toUint120(uint256 value) internal pure returns (uint120) {
if (value > type(uint120).max) {
revert SafeCastOverflowedUintDowncast(120, value);
}
return uint120(value);
}
/**
* @dev Returns the downcasted uint112 from uint256, reverting on
* overflow (when the input is greater than largest uint112).
*
* Counterpart to Solidity's `uint112` operator.
*
* Requirements:
*
* - input must fit into 112 bits
*/
function toUint112(uint256 value) internal pure returns (uint112) {
if (value > type(uint112).max) {
revert SafeCastOverflowedUintDowncast(112, value);
}
return uint112(value);
}
/**
* @dev Returns the downcasted uint104 from uint256, reverting on
* overflow (when the input is greater than largest uint104).
*
* Counterpart to Solidity's `uint104` operator.
*
* Requirements:
*
* - input must fit into 104 bits
*/
function toUint104(uint256 value) internal pure returns (uint104) {
if (value > type(uint104).max) {
revert SafeCastOverflowedUintDowncast(104, value);
}
return uint104(value);
}
/**
* @dev Returns the downcasted uint96 from uint256, reverting on
* overflow (when the input is greater than largest uint96).
*
* Counterpart to Solidity's `uint96` operator.
*
* Requirements:
*
* - input must fit into 96 bits
*/
function toUint96(uint256 value) internal pure returns (uint96) {
if (value > type(uint96).max) {
revert SafeCastOverflowedUintDowncast(96, value);
}
return uint96(value);
}
/**
* @dev Returns the downcasted uint88 from uint256, reverting on
* overflow (when the input is greater than largest uint88).
*
* Counterpart to Solidity's `uint88` operator.
*
* Requirements:
*
* - input must fit into 88 bits
*/
function toUint88(uint256 value) internal pure returns (uint88) {
if (value > type(uint88).max) {
revert SafeCastOverflowedUintDowncast(88, value);
}
return uint88(value);
}
/**
* @dev Returns the downcasted uint80 from uint256, reverting on
* overflow (when the input is greater than largest uint80).
*
* Counterpart to Solidity's `uint80` operator.
*
* Requirements:
*
* - input must fit into 80 bits
*/
function toUint80(uint256 value) internal pure returns (uint80) {
if (value > type(uint80).max) {
revert SafeCastOverflowedUintDowncast(80, value);
}
return uint80(value);
}
/**
* @dev Returns the downcasted uint72 from uint256, reverting on
* overflow (when the input is greater than largest uint72).
*
* Counterpart to Solidity's `uint72` operator.
*
* Requirements:
*
* - input must fit into 72 bits
*/
function toUint72(uint256 value) internal pure returns (uint72) {
if (value > type(uint72).max) {
revert SafeCastOverflowedUintDowncast(72, value);
}
return uint72(value);
}
/**
* @dev Returns the downcasted uint64 from uint256, reverting on
* overflow (when the input is greater than largest uint64).
*
* Counterpart to Solidity's `uint64` operator.
*
* Requirements:
*
* - input must fit into 64 bits
*/
function toUint64(uint256 value) internal pure returns (uint64) {
if (value > type(uint64).max) {
revert SafeCastOverflowedUintDowncast(64, value);
}
return uint64(value);
}
/**
* @dev Returns the downcasted uint56 from uint256, reverting on
* overflow (when the input is greater than largest uint56).
*
* Counterpart to Solidity's `uint56` operator.
*
* Requirements:
*
* - input must fit into 56 bits
*/
function toUint56(uint256 value) internal pure returns (uint56) {
if (value > type(uint56).max) {
revert SafeCastOverflowedUintDowncast(56, value);
}
return uint56(value);
}
/**
* @dev Returns the downcasted uint48 from uint256, reverting on
* overflow (when the input is greater than largest uint48).
*
* Counterpart to Solidity's `uint48` operator.
*
* Requirements:
*
* - input must fit into 48 bits
*/
function toUint48(uint256 value) internal pure returns (uint48) {
if (value > type(uint48).max) {
revert SafeCastOverflowedUintDowncast(48, value);
}
return uint48(value);
}
/**
* @dev Returns the downcasted uint40 from uint256, reverting on
* overflow (when the input is greater than largest uint40).
*
* Counterpart to Solidity's `uint40` operator.
*
* Requirements:
*
* - input must fit into 40 bits
*/
function toUint40(uint256 value) internal pure returns (uint40) {
if (value > type(uint40).max) {
revert SafeCastOverflowedUintDowncast(40, value);
}
return uint40(value);
}
/**
* @dev Returns the downcasted uint32 from uint256, reverting on
* overflow (when the input is greater than largest uint32).
*
* Counterpart to Solidity's `uint32` operator.
*
* Requirements:
*
* - input must fit into 32 bits
*/
function toUint32(uint256 value) internal pure returns (uint32) {
if (value > type(uint32).max) {
revert SafeCastOverflowedUintDowncast(32, value);
}
return uint32(value);
}
/**
* @dev Returns the downcasted uint24 from uint256, reverting on
* overflow (when the input is greater than largest uint24).
*
* Counterpart to Solidity's `uint24` operator.
*
* Requirements:
*
* - input must fit into 24 bits
*/
function toUint24(uint256 value) internal pure returns (uint24) {
if (value > type(uint24).max) {
revert SafeCastOverflowedUintDowncast(24, value);
}
return uint24(value);
}
/**
* @dev Returns the downcasted uint16 from uint256, reverting on
* overflow (when the input is greater than largest uint16).
*
* Counterpart to Solidity's `uint16` operator.
*
* Requirements:
*
* - input must fit into 16 bits
*/
function toUint16(uint256 value) internal pure returns (uint16) {
if (value > type(uint16).max) {
revert SafeCastOverflowedUintDowncast(16, value);
}
return uint16(value);
}
/**
* @dev Returns the downcasted uint8 from uint256, reverting on
* overflow (when the input is greater than largest uint8).
*
* Counterpart to Solidity's `uint8` operator.
*
* Requirements:
*
* - input must fit into 8 bits
*/
function toUint8(uint256 value) internal pure returns (uint8) {
if (value > type(uint8).max) {
revert SafeCastOverflowedUintDowncast(8, value);
}
return uint8(value);
}
/**
* @dev Converts a signed int256 into an unsigned uint256.
*
* Requirements:
*
* - input must be greater than or equal to 0.
*/
function toUint256(int256 value) internal pure returns (uint256) {
if (value < 0) {
revert SafeCastOverflowedIntToUint(value);
}
return uint256(value);
}
/**
* @dev Returns the downcasted int248 from int256, reverting on
* overflow (when the input is less than smallest int248 or
* greater than largest int248).
*
* Counterpart to Solidity's `int248` operator.
*
* Requirements:
*
* - input must fit into 248 bits
*/
function toInt248(int256 value) internal pure returns (int248 downcasted) {
downcasted = int248(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(248, value);
}
}
/**
* @dev Returns the downcasted int240 from int256, reverting on
* overflow (when the input is less than smallest int240 or
* greater than largest int240).
*
* Counterpart to Solidity's `int240` operator.
*
* Requirements:
*
* - input must fit into 240 bits
*/
function toInt240(int256 value) internal pure returns (int240 downcasted) {
downcasted = int240(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(240, value);
}
}
/**
* @dev Returns the downcasted int232 from int256, reverting on
* overflow (when the input is less than smallest int232 or
* greater than largest int232).
*
* Counterpart to Solidity's `int232` operator.
*
* Requirements:
*
* - input must fit into 232 bits
*/
function toInt232(int256 value) internal pure returns (int232 downcasted) {
downcasted = int232(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(232, value);
}
}
/**
* @dev Returns the downcasted int224 from int256, reverting on
* overflow (when the input is less than smallest int224 or
* greater than largest int224).
*
* Counterpart to Solidity's `int224` operator.
*
* Requirements:
*
* - input must fit into 224 bits
*/
function toInt224(int256 value) internal pure returns (int224 downcasted) {
downcasted = int224(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(224, value);
}
}
/**
* @dev Returns the downcasted int216 from int256, reverting on
* overflow (when the input is less than smallest int216 or
* greater than largest int216).
*
* Counterpart to Solidity's `int216` operator.
*
* Requirements:
*
* - input must fit into 216 bits
*/
function toInt216(int256 value) internal pure returns (int216 downcasted) {
downcasted = int216(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(216, value);
}
}
/**
* @dev Returns the downcasted int208 from int256, reverting on
* overflow (when the input is less than smallest int208 or
* greater than largest int208).
*
* Counterpart to Solidity's `int208` operator.
*
* Requirements:
*
* - input must fit into 208 bits
*/
function toInt208(int256 value) internal pure returns (int208 downcasted) {
downcasted = int208(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(208, value);
}
}
/**
* @dev Returns the downcasted int200 from int256, reverting on
* overflow (when the input is less than smallest int200 or
* greater than largest int200).
*
* Counterpart to Solidity's `int200` operator.
*
* Requirements:
*
* - input must fit into 200 bits
*/
function toInt200(int256 value) internal pure returns (int200 downcasted) {
downcasted = int200(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(200, value);
}
}
/**
* @dev Returns the downcasted int192 from int256, reverting on
* overflow (when the input is less than smallest int192 or
* greater than largest int192).
*
* Counterpart to Solidity's `int192` operator.
*
* Requirements:
*
* - input must fit into 192 bits
*/
function toInt192(int256 value) internal pure returns (int192 downcasted) {
downcasted = int192(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(192, value);
}
}
/**
* @dev Returns the downcasted int184 from int256, reverting on
* overflow (when the input is less than smallest int184 or
* greater than largest int184).
*
* Counterpart to Solidity's `int184` operator.
*
* Requirements:
*
* - input must fit into 184 bits
*/
function toInt184(int256 value) internal pure returns (int184 downcasted) {
downcasted = int184(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(184, value);
}
}
/**
* @dev Returns the downcasted int176 from int256, reverting on
* overflow (when the input is less than smallest int176 or
* greater than largest int176).
*
* Counterpart to Solidity's `int176` operator.
*
* Requirements:
*
* - input must fit into 176 bits
*/
function toInt176(int256 value) internal pure returns (int176 downcasted) {
downcasted = int176(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(176, value);
}
}
/**
* @dev Returns the downcasted int168 from int256, reverting on
* overflow (when the input is less than smallest int168 or
* greater than largest int168).
*
* Counterpart to Solidity's `int168` operator.
*
* Requirements:
*
* - input must fit into 168 bits
*/
function toInt168(int256 value) internal pure returns (int168 downcasted) {
downcasted = int168(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(168, value);
}
}
/**
* @dev Returns the downcasted int160 from int256, reverting on
* overflow (when the input is less than smallest int160 or
* greater than largest int160).
*
* Counterpart to Solidity's `int160` operator.
*
* Requirements:
*
* - input must fit into 160 bits
*/
function toInt160(int256 value) internal pure returns (int160 downcasted) {
downcasted = int160(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(160, value);
}
}
/**
* @dev Returns the downcasted int152 from int256, reverting on
* overflow (when the input is less than smallest int152 or
* greater than largest int152).
*
* Counterpart to Solidity's `int152` operator.
*
* Requirements:
*
* - input must fit into 152 bits
*/
function toInt152(int256 value) internal pure returns (int152 downcasted) {
downcasted = int152(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(152, value);
}
}
/**
* @dev Returns the downcasted int144 from int256, reverting on
* overflow (when the input is less than smallest int144 or
* greater than largest int144).
*
* Counterpart to Solidity's `int144` operator.
*
* Requirements:
*
* - input must fit into 144 bits
*/
function toInt144(int256 value) internal pure returns (int144 downcasted) {
downcasted = int144(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(144, value);
}
}
/**
* @dev Returns the downcasted int136 from int256, reverting on
* overflow (when the input is less than smallest int136 or
* greater than largest int136).
*
* Counterpart to Solidity's `int136` operator.
*
* Requirements:
*
* - input must fit into 136 bits
*/
function toInt136(int256 value) internal pure returns (int136 downcasted) {
downcasted = int136(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(136, value);
}
}
/**
* @dev Returns the downcasted int128 from int256, reverting on
* overflow (when the input is less than smallest int128 or
* greater than largest int128).
*
* Counterpart to Solidity's `int128` operator.
*
* Requirements:
*
* - input must fit into 128 bits
*/
function toInt128(int256 value) internal pure returns (int128 downcasted) {
downcasted = int128(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(128, value);
}
}
/**
* @dev Returns the downcasted int120 from int256, reverting on
* overflow (when the input is less than smallest int120 or
* greater than largest int120).
*
* Counterpart to Solidity's `int120` operator.
*
* Requirements:
*
* - input must fit into 120 bits
*/
function toInt120(int256 value) internal pure returns (int120 downcasted) {
downcasted = int120(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(120, value);
}
}
/**
* @dev Returns the downcasted int112 from int256, reverting on
* overflow (when the input is less than smallest int112 or
* greater than largest int112).
*
* Counterpart to Solidity's `int112` operator.
*
* Requirements:
*
* - input must fit into 112 bits
*/
function toInt112(int256 value) internal pure returns (int112 downcasted) {
downcasted = int112(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(112, value);
}
}
/**
* @dev Returns the downcasted int104 from int256, reverting on
* overflow (when the input is less than smallest int104 or
* greater than largest int104).
*
* Counterpart to Solidity's `int104` operator.
*
* Requirements:
*
* - input must fit into 104 bits
*/
function toInt104(int256 value) internal pure returns (int104 downcasted) {
downcasted = int104(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(104, value);
}
}
/**
* @dev Returns the downcasted int96 from int256, reverting on
* overflow (when the input is less than smallest int96 or
* greater than largest int96).
*
* Counterpart to Solidity's `int96` operator.
*
* Requirements:
*
* - input must fit into 96 bits
*/
function toInt96(int256 value) internal pure returns (int96 downcasted) {
downcasted = int96(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(96, value);
}
}
/**
* @dev Returns the downcasted int88 from int256, reverting on
* overflow (when the input is less than smallest int88 or
* greater than largest int88).
*
* Counterpart to Solidity's `int88` operator.
*
* Requirements:
*
* - input must fit into 88 bits
*/
function toInt88(int256 value) internal pure returns (int88 downcasted) {
downcasted = int88(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(88, value);
}
}
/**
* @dev Returns the downcasted int80 from int256, reverting on
* overflow (when the input is less than smallest int80 or
* greater than largest int80).
*
* Counterpart to Solidity's `int80` operator.
*
* Requirements:
*
* - input must fit into 80 bits
*/
function toInt80(int256 value) internal pure returns (int80 downcasted) {
downcasted = int80(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(80, value);
}
}
/**
* @dev Returns the downcasted int72 from int256, reverting on
* overflow (when the input is less than smallest int72 or
* greater than largest int72).
*
* Counterpart to Solidity's `int72` operator.
*
* Requirements:
*
* - input must fit into 72 bits
*/
function toInt72(int256 value) internal pure returns (int72 downcasted) {
downcasted = int72(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(72, value);
}
}
/**
* @dev Returns the downcasted int64 from int256, reverting on
* overflow (when the input is less than smallest int64 or
* greater than largest int64).
*
* Counterpart to Solidity's `int64` operator.
*
* Requirements:
*
* - input must fit into 64 bits
*/
function toInt64(int256 value) internal pure returns (int64 downcasted) {
downcasted = int64(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(64, value);
}
}
/**
* @dev Returns the downcasted int56 from int256, reverting on
* overflow (when the input is less than smallest int56 or
* greater than largest int56).
*
* Counterpart to Solidity's `int56` operator.
*
* Requirements:
*
* - input must fit into 56 bits
*/
function toInt56(int256 value) internal pure returns (int56 downcasted) {
downcasted = int56(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(56, value);
}
}
/**
* @dev Returns the downcasted int48 from int256, reverting on
* overflow (when the input is less than smallest int48 or
* greater than largest int48).
*
* Counterpart to Solidity's `int48` operator.
*
* Requirements:
*
* - input must fit into 48 bits
*/
function toInt48(int256 value) internal pure returns (int48 downcasted) {
downcasted = int48(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(48, value);
}
}
/**
* @dev Returns the downcasted int40 from int256, reverting on
* overflow (when the input is less than smallest int40 or
* greater than largest int40).
*
* Counterpart to Solidity's `int40` operator.
*
* Requirements:
*
* - input must fit into 40 bits
*/
function toInt40(int256 value) internal pure returns (int40 downcasted) {
downcasted = int40(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(40, value);
}
}
/**
* @dev Returns the downcasted int32 from int256, reverting on
* overflow (when the input is less than smallest int32 or
* greater than largest int32).
*
* Counterpart to Solidity's `int32` operator.
*
* Requirements:
*
* - input must fit into 32 bits
*/
function toInt32(int256 value) internal pure returns (int32 downcasted) {
downcasted = int32(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(32, value);
}
}
/**
* @dev Returns the downcasted int24 from int256, reverting on
* overflow (when the input is less than smallest int24 or
* greater than largest int24).
*
* Counterpart to Solidity's `int24` operator.
*
* Requirements:
*
* - input must fit into 24 bits
*/
function toInt24(int256 value) internal pure returns (int24 downcasted) {
downcasted = int24(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(24, value);
}
}
/**
* @dev Returns the downcasted int16 from int256, reverting on
* overflow (when the input is less than smallest int16 or
* greater than largest int16).
*
* Counterpart to Solidity's `int16` operator.
*
* Requirements:
*
* - input must fit into 16 bits
*/
function toInt16(int256 value) internal pure returns (int16 downcasted) {
downcasted = int16(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(16, value);
}
}
/**
* @dev Returns the downcasted int8 from int256, reverting on
* overflow (when the input is less than smallest int8 or
* greater than largest int8).
*
* Counterpart to Solidity's `int8` operator.
*
* Requirements:
*
* - input must fit into 8 bits
*/
function toInt8(int256 value) internal pure returns (int8 downcasted) {
downcasted = int8(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(8, value);
}
}
/**
* @dev Converts an unsigned uint256 into a signed int256.
*
* Requirements:
*
* - input must be less than or equal to maxInt256.
*/
function toInt256(uint256 value) internal pure returns (int256) {
// Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
if (value > uint256(type(int256).max)) {
revert SafeCastOverflowedUintToInt(value);
}
return int256(value);
}
/**
* @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.
*/
function toUint(bool b) internal pure returns (uint256 u) {
assembly ("memory-safe") {
u := iszero(iszero(b))
}
}
}
/**
* @dev Standard math utilities missing in the Solidity language.
*/
library Math {
enum Rounding {
Floor, // Toward negative infinity
Ceil, // Toward positive infinity
Trunc, // Toward zero
Expand // Away from zero
}
/**
* @dev Return the 512-bit addition of two uint256.
*
* The result is stored in two 256 variables such that sum = high * 2²⁵⁶ + low.
*/
function add512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {
assembly ("memory-safe") {
low := add(a, b)
high := lt(low, a)
}
}
/**
* @dev Return the 512-bit multiplication of two uint256.
*
* The result is stored in two 256 variables such that product = high * 2²⁵⁶ + low.
*/
function mul512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {
// 512-bit multiply [high low] = x * y. Compute the product mod 2²⁵⁶ and mod 2²⁵⁶ - 1, then use
// the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
// variables such that product = high * 2²⁵⁶ + low.
assembly ("memory-safe") {
let mm := mulmod(a, b, not(0))
low := mul(a, b)
high := sub(sub(mm, low), lt(mm, low))
}
}
/**
* @dev Returns the addition of two unsigned integers, with a success flag (no overflow).
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
unchecked {
uint256 c = a + b;
success = c >= a;
result = c * SafeCast.toUint(success);
}
}
/**
* @dev Returns the subtraction of two unsigned integers, with a success flag (no overflow).
*/
function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
unchecked {
uint256 c = a - b;
success = c <= a;
result = c * SafeCast.toUint(success);
}
}
/**
* @dev Returns the multiplication of two unsigned integers, with a success flag (no overflow).
*/
function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
unchecked {
uint256 c = a * b;
assembly ("memory-safe") {
// Only true when the multiplication doesn't overflow
// (c / a == b) || (a == 0)
success := or(eq(div(c, a), b), iszero(a))
}
// equivalent to: success ? c : 0
result = c * SafeCast.toUint(success);
}
}
/**
* @dev Returns the division of two unsigned integers, with a success flag (no division by zero).
*/
function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
unchecked {
success = b > 0;
assembly ("memory-safe") {
// The `DIV` opcode returns zero when the denominator is 0.
result := div(a, b)
}
}
}
/**
* @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).
*/
function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
unchecked {
success = b > 0;
assembly ("memory-safe") {
// The `MOD` opcode returns zero when the denominator is 0.
result := mod(a, b)
}
}
}
/**
* @dev Unsigned saturating addition, bounds to `2²⁵⁶ - 1` instead of overflowing.
*/
function saturatingAdd(uint256 a, uint256 b) internal pure returns (uint256) {
(bool success, uint256 result) = tryAdd(a, b);
return ternary(success, result, type(uint256).max);
}
/**
* @dev Unsigned saturating subtraction, bounds to zero instead of overflowing.
*/
function saturatingSub(uint256 a, uint256 b) internal pure returns (uint256) {
(, uint256 result) = trySub(a, b);
return result;
}
/**
* @dev Unsigned saturating multiplication, bounds to `2²⁵⁶ - 1` instead of overflowing.
*/
function saturatingMul(uint256 a, uint256 b) internal pure returns (uint256) {
(bool success, uint256 result) = tryMul(a, b);
return ternary(success, result, type(uint256).max);
}
/**
* @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.
*
* IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.
* However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute
* one branch when needed, making this function more expensive.
*/
function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {
unchecked {
// branchless ternary works because:
// b ^ (a ^ b) == a
// b ^ 0 == b
return b ^ ((a ^ b) * SafeCast.toUint(condition));
}
}
/**
* @dev Returns the largest of two numbers.
*/
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return ternary(a > b, a, b);
}
/**
* @dev Returns the smallest of two numbers.
*/
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return ternary(a < b, a, b);
}
/**
* @dev Returns the average of two numbers. The result is rounded towards
* zero.
*/
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow.
return (a & b) + (a ^ b) / 2;
}
/**
* @dev Returns the ceiling of the division of two numbers.
*
* This differs from standard division with `/` in that it rounds towards infinity instead
* of rounding towards zero.
*/
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
if (b == 0) {
// Guarantee the same behavior as in a regular Solidity division.
Panic.panic(Panic.DIVISION_BY_ZERO);
}
// The following calculation ensures accurate ceiling division without overflow.
// Since a is non-zero, (a - 1) / b will not overflow.
// The largest possible result occurs when (a - 1) / b is type(uint256).max,
// but the largest value we can obtain is type(uint256).max - 1, which happens
// when a = type(uint256).max and b = 1.
unchecked {
return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);
}
}
/**
* @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
* denominator == 0.
*
* Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by
* Uniswap Labs also under MIT license.
*/
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
(uint256 high, uint256 low) = mul512(x, y);
// Handle non-overflow cases, 256 by 256 division.
if (high == 0) {
// Solidity will revert if denominator == 0, unlike the div opcode on its own.
// The surrounding unchecked block does not change this fact.
// See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
return low / denominator;
}
// Make sure the result is less than 2²⁵⁶. Also prevents denominator == 0.
if (denominator <= high) {
Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));
}
///////////////////////////////////////////////
// 512 by 256 division.
///////////////////////////////////////////////
// Make division exact by subtracting the remainder from [high low].
uint256 remainder;
assembly ("memory-safe") {
// Compute remainder using mulmod.
remainder := mulmod(x, y, denominator)
// Subtract 256 bit number from 512 bit number.
high := sub(high, gt(remainder, low))
low := sub(low, remainder)
}
// Factor powers of two out of denominator and compute largest power of two divisor of denominator.
// Always >= 1. See https://cs.stackexchange.com/q/138556/92363.
uint256 twos = denominator & (0 - denominator);
assembly ("memory-safe") {
// Divide denominator by twos.
denominator := div(denominator, twos)
// Divide [high low] by twos.
low := div(low, twos)
// Flip twos such that it is 2²⁵⁶ / twos. If twos is zero, then it becomes one.
twos := add(div(sub(0, twos), twos), 1)
}
// Shift in bits from high into low.
low |= high * twos;
// Invert denominator mod 2²⁵⁶. Now that denominator is an odd number, it has an inverse modulo 2²⁵⁶ such
// that denominator * inv ≡ 1 mod 2²⁵⁶. Compute the inverse by starting with a seed that is correct for
// four bits. That is, denominator * inv ≡ 1 mod 2⁴.
uint256 inverse = (3 * denominator) ^ 2;
// Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also
// works in modular arithmetic, doubling the correct bits in each step.
inverse *= 2 - denominator * inverse; // inverse mod 2⁸
inverse *= 2 - denominator * inverse; // inverse mod 2¹⁶
inverse *= 2 - denominator * inverse; // inverse mod 2³²
inverse *= 2 - denominator * inverse; // inverse mod 2⁶⁴
inverse *= 2 - denominator * inverse; // inverse mod 2¹²⁸
inverse *= 2 - denominator * inverse; // inverse mod 2²⁵⁶
// Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
// This will give us the correct result modulo 2²⁵⁶. Since the preconditions guarantee that the outcome is
// less than 2²⁵⁶, this is the final result. We don't need to compute the high bits of the result and high
// is no longer required.
result = low * inverse;
return result;
}
}
/**
* @dev Calculates x * y / denominator with full precision, following the selected rounding direction.
*/
function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);
}
/**
* @dev Calculates floor(x * y >> n) with full precision. Throws if result overflows a uint256.
*/
function mulShr(uint256 x, uint256 y, uint8 n) internal pure returns (uint256 result) {
unchecked {
(uint256 high, uint256 low) = mul512(x, y);
if (high >= 1 << n) {
Panic.panic(Panic.UNDER_OVERFLOW);
}
return (high << (256 - n)) | (low >> n);
}
}
/**
* @dev Calculates x * y >> n with full precision, following the selected rounding direction.
*/
function mulShr(uint256 x, uint256 y, uint8 n, Rounding rounding) internal pure returns (uint256) {
return mulShr(x, y, n) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, 1 << n) > 0);
}
/**
* @dev Calculate the modular multiplicative inverse of a number in Z/nZ.
*
* If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.
* If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.
*
* If the input value is not inversible, 0 is returned.
*
* NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the
* inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.
*/
function invMod(uint256 a, uint256 n) internal pure returns (uint256) {
unchecked {
if (n == 0) return 0;
// The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)
// Used to compute integers x and y such that: ax + ny = gcd(a, n).
// When the gcd is 1, then the inverse of a modulo n exists and it's x.
// ax + ny = 1
// ax = 1 + (-y)n
// ax ≡ 1 (mod n) # x is the inverse of a modulo n
// If the remainder is 0 the gcd is n right away.
uint256 remainder = a % n;
uint256 gcd = n;
// Therefore the initial coefficients are:
// ax + ny = gcd(a, n) = n
// 0a + 1n = n
int256 x = 0;
int256 y = 1;
while (remainder != 0) {
uint256 quotient = gcd / remainder;
(gcd, remainder) = (
// The old remainder is the next gcd to try.
remainder,
// Compute the next remainder.
// Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd
// where gcd is at most n (capped to type(uint256).max)
gcd - remainder * quotient
);
(x, y) = (
// Increment the coefficient of a.
y,
// Decrement the coefficient of n.
// Can overflow, but the result is casted to uint256 so that the
// next value of y is "wrapped around" to a value between 0 and n - 1.
x - y * int256(quotient)
);
}
if (gcd != 1) return 0; // No inverse exists.
return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.
}
}
/**
* @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.
*
* From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is
* prime, then `a**(p-1) ≡ 1 mod p`. As a consequence, we have `a * a**(p-2) ≡ 1 mod p`, which means that
* `a**(p-2)` is the modular multiplicative inverse of a in Fp.
*
* NOTE: this function does NOT check that `p` is a prime greater than `2`.
*/
function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {
unchecked {
return Math.modExp(a, p - 2, p);
}
}
/**
* @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)
*
* Requirements:
* - modulus can't be zero
* - underlying staticcall to precompile must succeed
*
* IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make
* sure the chain you're using it on supports the precompiled contract for modular exponentiation
* at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,
* the underlying function will succeed given the lack of a revert, but the result may be incorrectly
* interpreted as 0.
*/
function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {
(bool success, uint256 result) = tryModExp(b, e, m);
if (!success) {
Panic.panic(Panic.DIVISION_BY_ZERO);
}
return result;
}
/**
* @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).
* It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying
* to operate modulo 0 or if the underlying precompile reverted.
*
* IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain
* you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in
* https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack
* of a revert, but the result may be incorrectly interpreted as 0.
*/
function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {
if (m == 0) return (false, 0);
assembly ("memory-safe") {
let ptr := mload(0x40)
// | Offset | Content | Content (Hex) |
// |-----------|------------|--------------------------------------------------------------------|
// | 0x00:0x1f | size of b | 0x0000000000000000000000000000000000000000000000000000000000000020 |
// | 0x20:0x3f | size of e | 0x0000000000000000000000000000000000000000000000000000000000000020 |
// | 0x40:0x5f | size of m | 0x0000000000000000000000000000000000000000000000000000000000000020 |
// | 0x60:0x7f | value of b | 0x<.............................................................b> |
// | 0x80:0x9f | value of e | 0x<.............................................................e> |
// | 0xa0:0xbf | value of m | 0x<.............................................................m> |
mstore(ptr, 0x20)
mstore(add(ptr, 0x20), 0x20)
mstore(add(ptr, 0x40), 0x20)
mstore(add(ptr, 0x60), b)
mstore(add(ptr, 0x80), e)
mstore(add(ptr, 0xa0), m)
// Given the result < m, it's guaranteed to fit in 32 bytes,
// so we can use the memory scratch space located at offset 0.
success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)
result := mload(0x00)
}
}
/**
* @dev Variant of {modExp} that supports inputs of arbitrary length.
*/
function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {
(bool success, bytes memory result) = tryModExp(b, e, m);
if (!success) {
Panic.panic(Panic.DIVISION_BY_ZERO);
}
return result;
}
/**
* @dev Variant of {tryModExp} that supports inputs of arbitrary length.
*/
function tryModExp(
bytes memory b,
bytes memory e,
bytes memory m
) internal view returns (bool success, bytes memory result) {
if (_zeroBytes(m)) return (false, new bytes(0));
uint256 mLen = m.length;
// Encode call args in result and move the free memory pointer
result = abi.encodePacked(b.length, e.length, mLen, b, e, m);
assembly ("memory-safe") {
let dataPtr := add(result, 0x20)
// Write result on top of args to avoid allocating extra memory.
success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)
// Overwrite the length.
// result.length > returndatasize() is guaranteed because returndatasize() == m.length
mstore(result, mLen)
// Set the memory pointer after the returned data.
mstore(0x40, add(dataPtr, mLen))
}
}
/**
* @dev Returns whether the provided byte array is zero.
*/
function _zeroBytes(bytes memory byteArray) private pure returns (bool) {
for (uint256 i = 0; i < byteArray.length; ++i) {
if (byteArray[i] != 0) {
return false;
}
}
return true;
}
/**
* @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
* towards zero.
*
* This method is based on Newton's method for computing square roots; the algorithm is restricted to only
* using integer operations.
*/
function sqrt(uint256 a) internal pure returns (uint256) {
unchecked {
// Take care of easy edge cases when a == 0 or a == 1
if (a <= 1) {
return a;
}
// In this function, we use Newton's method to get a root of `f(x) := x² - a`. It involves building a
// sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between
// the current value as `ε_n = | x_n - sqrt(a) |`.
//
// For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root
// of the target. (i.e. `2**(e-1) ≤ sqrt(a) < 2**e`). We know that `e ≤ 128` because `(2¹²⁸)² = 2²⁵⁶` is
// bigger than any uint256.
//
// By noticing that
// `2**(e-1) ≤ sqrt(a) < 2**e → (2**(e-1))² ≤ a < (2**e)² → 2**(2*e-2) ≤ a < 2**(2*e)`
// we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar
// to the msb function.
uint256 aa = a;
uint256 xn = 1;
if (aa >= (1 << 128)) {
aa >>= 128;
xn <<= 64;
}
if (aa >= (1 << 64)) {
aa >>= 64;
xn <<= 32;
}
if (aa >= (1 << 32)) {
aa >>= 32;
xn <<= 16;
}
if (aa >= (1 << 16)) {
aa >>= 16;
xn <<= 8;
}
if (aa >= (1 << 8)) {
aa >>= 8;
xn <<= 4;
}
if (aa >= (1 << 4)) {
aa >>= 4;
xn <<= 2;
}
if (aa >= (1 << 2)) {
xn <<= 1;
}
// We now have x_n such that `x_n = 2**(e-1) ≤ sqrt(a) < 2**e = 2 * x_n`. This implies ε_n ≤ 2**(e-1).
//
// We can refine our estimation by noticing that the middle of that interval minimizes the error.
// If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to ε_n ≤ 2**(e-2).
// This is going to be our x_0 (and ε_0)
xn = (3 * xn) >> 1; // ε_0 := | x_0 - sqrt(a) | ≤ 2**(e-2)
// From here, Newton's method give us:
// x_{n+1} = (x_n + a / x_n) / 2
//
// One should note that:
// x_{n+1}² - a = ((x_n + a / x_n) / 2)² - a
// = ((x_n² + a) / (2 * x_n))² - a
// = (x_n⁴ + 2 * a * x_n² + a²) / (4 * x_n²) - a
// = (x_n⁴ + 2 * a * x_n² + a² - 4 * a * x_n²) / (4 * x_n²)
// = (x_n⁴ - 2 * a * x_n² + a²) / (4 * x_n²)
// = (x_n² - a)² / (2 * x_n)²
// = ((x_n² - a) / (2 * x_n))²
// ≥ 0
// Which proves that for all n ≥ 1, sqrt(a) ≤ x_n
//
// This gives us the proof of quadratic convergence of the sequence:
// ε_{n+1} = | x_{n+1} - sqrt(a) |
// = | (x_n + a / x_n) / 2 - sqrt(a) |
// = | (x_n² + a - 2*x_n*sqrt(a)) / (2 * x_n) |
// = | (x_n - sqrt(a))² / (2 * x_n) |
// = | ε_n² / (2 * x_n) |
// = ε_n² / | (2 * x_n) |
//
// For the first iteration, we have a special case where x_0 is known:
// ε_1 = ε_0² / | (2 * x_0) |
// ≤ (2**(e-2))² / (2 * (2**(e-1) + 2**(e-2)))
// ≤ 2**(2*e-4) / (3 * 2**(e-1))
// ≤ 2**(e-3) / 3
// ≤ 2**(e-3-log2(3))
// ≤ 2**(e-4.5)
//
// For the following iterations, we use the fact that, 2**(e-1) ≤ sqrt(a) ≤ x_n:
// ε_{n+1} = ε_n² / | (2 * x_n) |
// ≤ (2**(e-k))² / (2 * 2**(e-1))
// ≤ 2**(2*e-2*k) / 2**e
// ≤ 2**(e-2*k)
xn = (xn + a / xn) >> 1; // ε_1 := | x_1 - sqrt(a) | ≤ 2**(e-4.5) -- special case, see above
xn = (xn + a / xn) >> 1; // ε_2 := | x_2 - sqrt(a) | ≤ 2**(e-9) -- general case with k = 4.5
xn = (xn + a / xn) >> 1; // ε_3 := | x_3 - sqrt(a) | ≤ 2**(e-18) -- general case with k = 9
xn = (xn + a / xn) >> 1; // ε_4 := | x_4 - sqrt(a) | ≤ 2**(e-36) -- general case with k = 18
xn = (xn + a / xn) >> 1; // ε_5 := | x_5 - sqrt(a) | ≤ 2**(e-72) -- general case with k = 36
xn = (xn + a / xn) >> 1; // ε_6 := | x_6 - sqrt(a) | ≤ 2**(e-144) -- general case with k = 72
// Because e ≤ 128 (as discussed during the first estimation phase), we know have reached a precision
// ε_6 ≤ 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either
// sqrt(a) or sqrt(a) + 1.
return xn - SafeCast.toUint(xn > a / xn);
}
}
/**
* @dev Calculates sqrt(a), following the selected rounding direction.
*/
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);
}
}
/**
* @dev Return the log in base 2 of a positive value rounded towards zero.
* Returns 0 if given 0.
*/
function log2(uint256 x) internal pure returns (uint256 r) {
// If value has upper 128 bits set, log2 result is at least 128
r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;
// If upper 64 bits of 128-bit half set, add 64 to result
r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;
// If upper 32 bits of 64-bit half set, add 32 to result
r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;
// If upper 16 bits of 32-bit half set, add 16 to result
r |= SafeCast.toUint((x >> r) > 0xffff) << 4;
// If upper 8 bits of 16-bit half set, add 8 to result
r |= SafeCast.toUint((x >> r) > 0xff) << 3;
// If upper 4 bits of 8-bit half set, add 4 to result
r |= SafeCast.toUint((x >> r) > 0xf) << 2;
// Shifts value right by the current result and use it as an index into this lookup table:
//
// | x (4 bits) | index | table[index] = MSB position |
// |------------|---------|-----------------------------|
// | 0000 | 0 | table[0] = 0 |
// | 0001 | 1 | table[1] = 0 |
// | 0010 | 2 | table[2] = 1 |
// | 0011 | 3 | table[3] = 1 |
// | 0100 | 4 | table[4] = 2 |
// | 0101 | 5 | table[5] = 2 |
// | 0110 | 6 | table[6] = 2 |
// | 0111 | 7 | table[7] = 2 |
// | 1000 | 8 | table[8] = 3 |
// | 1001 | 9 | table[9] = 3 |
// | 1010 | 10 | table[10] = 3 |
// | 1011 | 11 | table[11] = 3 |
// | 1100 | 12 | table[12] = 3 |
// | 1101 | 13 | table[13] = 3 |
// | 1110 | 14 | table[14] = 3 |
// | 1111 | 15 | table[15] = 3 |
//
// The lookup table is represented as a 32-byte value with the MSB positions for 0-15 in the last 16 bytes.
assembly ("memory-safe") {
r := or(r, byte(shr(r, x), 0x0000010102020202030303030303030300000000000000000000000000000000))
}
}
/**
* @dev Return the log in base 2, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);
}
}
/**
* @dev Return the log in base 10 of a positive value rounded towards zero.
* Returns 0 if given 0.
*/
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 10, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);
}
}
/**
* @dev Return the log in base 256 of a positive value rounded towards zero.
* Returns 0 if given 0.
*
* Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
*/
function log256(uint256 x) internal pure returns (uint256 r) {
// If value has upper 128 bits set, log2 result is at least 128
r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;
// If upper 64 bits of 128-bit half set, add 64 to result
r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;
// If upper 32 bits of 64-bit half set, add 32 to result
r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;
// If upper 16 bits of 32-bit half set, add 16 to result
r |= SafeCast.toUint((x >> r) > 0xffff) << 4;
// Add 1 if upper 8 bits of 16-bit half set, and divide accumulated result by 8
return (r >> 3) | SafeCast.toUint((x >> r) > 0xff);
}
/**
* @dev Return the log in base 256, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);
}
}
/**
* @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
*/
function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
return uint8(rounding) % 2 == 1;
}
}
/// @title IFeeDistributor: Bare minimum interface for FeeDistributor contract.
interface IFeeDistributor {
function distribute() external payable;
}
contract LiquidityManager is IERC721Receiver {
// V2 Router
address public constant routerV2 = 0x18E621B64d7808c3C47bccbbD7485d23F257D26f;
// V3 Router
address public constant routerV3 = 0xC216fCdEb961EEF95657Cb45dEe20e379C7624B8;
/// @dev The minimum tick that may be passed to #getSqrtRatioAtTick computed from log base 1.0001 of 2**-128
int24 internal constant MIN_TICK = -887220;
/// @dev The maximum tick that may be passed to #getSqrtRatioAtTick computed from log base 1.0001 of 2**128
int24 internal constant MAX_TICK = -MIN_TICK;
// Wrapped Ape Asset
address private constant WAPE = 0x7e03a497f6719d883E441f1C31b82Dc2bB096CCE; //0x48b62137EdfA95a428D35C09E44256a739F6B557;
// V3 Locker contract address
IV3Locker public constant v3Locker = IV3Locker(0x034a17fb73aD8dd486b7901c11a153B039add190);
function addLiquidity(address router, IV3Token token, uint256 amountToken, address feeDistributor, address creator) external payable returns (address pair, address token0) {
uint256 received = _transferIn(token, amountToken);
if (router == routerV2) {
return _addLiquidityV2(router, token, received);
} else if (router == routerV3) {
return _addLiquidityV3(router, token, received, feeDistributor, creator);
} else {
revert("Unsupported Router");
}
}
function _addLiquidityV2(address router, IV3Token token, uint256 amount) internal returns (address pair, address token0) {
// approve router to spend amount
token.approve(router, amount);
// add V2 liquidity and auto-burn it
IUniswapV2Router02(router).addLiquidityETH{value: msg.value}(
address(token),
amount,
0,
0,
address(0),
block.timestamp
);
// fetch and return pair
pair = IUniswapV2Factory(IUniswapV2Router02(router).factory()).getPair(address(token), WAPE);
if (address(token) < WAPE) {
token0 = address(token);
} else {
token0 = WAPE;
}
}
function _addLiquidityV3(address router, IV3Token token, uint256 amount, address feeDistributor, address creator) internal returns (address pair, address token0) {
// approve router to spend the token
token.approve(router, amount);
// Determine token order and calculate sqrtPriceX96
address token1;
uint256 amount0;
uint256 amount1;
// The token with the lower address is token0
if (address(token) < WAPE) {
token0 = address(token);
token1 = WAPE;
amount0 = amount;
amount1 = msg.value;
} else {
token0 = WAPE;
token1 = address(token);
amount0 = msg.value;
amount1 = amount;
}
uint160 initialSqrtPriceX96 = getSqrtPriceX96(amount1, amount0);
// create and initialize pair
pair = INonfungiblePositionManager(router).createAndInitializePoolIfNecessary(
token0,
token1,
initialSqrtPriceX96
);
// mint the liquidity
(uint256 tokenId,,,) = INonfungiblePositionManager(router).mint{value: msg.value}(
INonfungiblePositionManager.MintParams({
token0: token0,
token1: token1,
tickLower: MIN_TICK,
tickUpper: MAX_TICK,
amount0Desired: amount0,
amount1Desired: amount1,
amount0Min: 0, // we don't care about slippage here, as we are adding liquidity
amount1Min: 0, // we don't care about slippage here, as we are adding liquidity
recipient: address(this),
deadline: block.timestamp + 60 // 1 minute deadline
})
);
// call refundNativeToken to refund any excess native tokens sent
uint256 balBefore = address(this).balance;
INonfungiblePositionManager(router).refundNativeToken();
if (address(this).balance > balBefore) {
IFeeDistributor(feeDistributor).distribute{value: address(this).balance - balBefore}();
}
// approve liquidity for locker
INonfungiblePositionManager(router).approve(address(v3Locker), tokenId);
// now lock liquidity in our locker passing in the NFT address for rewards
v3Locker.lock(tokenId, creator, token.getLiquidNFT());
}
function _transferIn(IV3Token token, uint256 amountToken) internal returns (uint256 received) {
uint256 balBefore = token.balanceOf(address(this));
token.transferFrom(msg.sender, address(this), amountToken);
uint256 balAfter = token.balanceOf(address(this));
require(balAfter > balBefore, 'Zero Received');
unchecked {
received = balAfter - balBefore;
}
}
/**
* @notice Calculates sqrtPriceX96 from two amounts with high precision,
* preventing integer truncation and overflow.
* @dev This is the definitive, safe method for on-chain initial price calculation.
*/
function getSqrtPriceX96(uint256 amount1, uint256 amount0) public pure returns (uint160) {
require(amount0 > 0, "AMOUNT0_ZERO");
// This robust formula prevents the massive precision loss from integer truncation.
// 1. Calculate the price ratio in Q96 format safely using mulDiv.
// mulDiv(amount1, 2**96, amount0) calculates (amount1 * 2**96) / amount0
uint256 ratioX96 = Math.mulDiv(amount1, 1 << 96, amount0);
// 2. Take the square root of the Q96 price ratio. The result is in Q48 format.
// sqrt(price * 2**96) = sqrt(price) * 2**48
uint256 sqrtRatioX48 = Math.sqrt(ratioX96);
// 3. Convert the result from Q48 to Q96 by multiplying by 2**48.
// (sqrt(price) * 2**48) * 2**48 = sqrt(price) * 2**96
return uint160(sqrtRatioX48 << 48);
}
function onERC721Received(
address,
address,
uint256,
bytes calldata data
) external override returns (bytes4) {
data;
return IERC721Receiver.onERC721Received.selector;
}
receive() external payable {}
}Contract ABI
API[{"inputs":[{"internalType":"address","name":"router","type":"address"},{"internalType":"contract IV3Token","name":"token","type":"address"},{"internalType":"uint256","name":"amountToken","type":"uint256"},{"internalType":"address","name":"feeDistributor","type":"address"},{"internalType":"address","name":"creator","type":"address"}],"name":"addLiquidity","outputs":[{"internalType":"address","name":"pair","type":"address"},{"internalType":"address","name":"token0","type":"address"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount1","type":"uint256"},{"internalType":"uint256","name":"amount0","type":"uint256"}],"name":"getSqrtPriceX96","outputs":[{"internalType":"uint160","name":"","type":"uint160"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"routerV2","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"routerV3","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"v3Locker","outputs":[{"internalType":"contract IV3Locker","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]Contract Creation Code
6080604052348015600f57600080fd5b506110fe8061001f6000396000f3fe6080604052600436106100595760003560e01c8063150b7a02146100655780633d228b13146100af578063502f7446146100ef578063878cdde814610117578063b359d6361461014a578063f2b3b4671461016a57600080fd5b3661006057005b600080fd5b34801561007157600080fd5b50610091610080366004610da4565b630a85bd0160e11b95945050505050565b6040516001600160e01b031990911681526020015b60405180910390f35b3480156100bb57600080fd5b506100d773034a17fb73ad8dd486b7901c11a153b039add19081565b6040516001600160a01b0390911681526020016100a6565b3480156100fb57600080fd5b506100d77318e621b64d7808c3c47bccbbd7485d23f257d26f81565b61012a610125366004610e45565b610192565b604080516001600160a01b039384168152929091166020830152016100a6565b34801561015657600080fd5b506100d7610165366004610ead565b61025b565b34801561017657600080fd5b506100d773c216fcdeb961eef95657cb45dee20e379c7624b881565b60008060006101a187876102c7565b90507318e621b64d7808c3c47bccbbd7485d23f257d26e196001600160a01b038916016101dd576101d3888883610463565b9250925050610251565b73c216fcdeb961eef95657cb45dee20e379c7624b7196001600160a01b0389160161020f576101d388888388886106a4565b60405162461bcd60e51b81526020600482015260126024820152712ab739bab83837b93a32b2102937baba32b960711b60448201526064015b60405180910390fd5b9550959350505050565b600080821161029b5760405162461bcd60e51b815260206004820152600c60248201526b414d4f554e54305f5a45524f60a01b6044820152606401610248565b60006102ac84600160601b85610b4d565b905060006102b982610c03565b60301b925050505b92915050565b6040516370a0823160e01b815230600482015260009081906001600160a01b038516906370a0823190602401602060405180830381865afa158015610310573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906103349190610ecf565b6040516323b872dd60e01b8152336004820152306024820152604481018590529091506001600160a01b038516906323b872dd906064016020604051808303816000875af115801561038a573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906103ae9190610ee8565b506040516370a0823160e01b81523060048201526000906001600160a01b038616906370a0823190602401602060405180830381865afa1580156103f6573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061041a9190610ecf565b905081811161045b5760405162461bcd60e51b815260206004820152600d60248201526c16995c9bc8149958d95a5d9959609a1b6044820152606401610248565b039392505050565b60405163095ea7b360e01b81526001600160a01b03848116600483015260248201839052600091829185169063095ea7b3906044016020604051808303816000875af11580156104b7573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906104db9190610ee8565b5060405163f305d71960e01b81526001600160a01b038581166004830152602482018590526000604483018190526064830181905260848301524260a483015286169063f305d71990349060c40160606040518083038185885af1158015610547573d6000803e3d6000fd5b50505050506040513d601f19601f8201168201806040525081019061056c9190610f0a565b505050846001600160a01b031663c45a01556040518163ffffffff1660e01b8152600401602060405180830381865afa1580156105ad573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906105d19190610f38565b60405163e6a4390560e01b81526001600160a01b038681166004830152737e03a497f6719d883e441f1c31b82dc2bb096cce6024830152919091169063e6a4390590604401602060405180830381865afa158015610633573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906106579190610f38565b9150737e03a497f6719d883e441f1c31b82dc2bb096cce6001600160a01b038516101561068557508261069c565b50737e03a497f6719d883e441f1c31b82dc2bb096cce5b935093915050565b60405163095ea7b360e01b81526001600160a01b03868116600483015260248201859052600091829187169063095ea7b3906044016020604051808303816000875af11580156106f8573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061071c9190610ee8565b5060008080737e03a497f6719d883e441f1c31b82dc2bb096cce6001600160a01b038a16101561076a5750879250737e03a497f6719d883e441f1c31b82dc2bb096cce91508690503461078a565b50737e03a497f6719d883e441f1c31b82dc2bb096cce9250879150349050865b6000610796828461025b565b60405163289236b760e11b81526001600160a01b03878116600483015286811660248301528083166044830152919250908c16906351246d6e906064016020604051808303816000875af11580156107f2573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906108169190610f38565b955060008b6001600160a01b0316639cc1a283346040518061014001604052808a6001600160a01b03168152602001896001600160a01b03168152602001620d89b31960020b8152602001620d89b31961086f90610f6b565b60020b8152602081018990526040810188905260006060820181905260808201523060a082015260c0016108a442603c610f8d565b8152506040518363ffffffff1660e01b81526004016108c39190610fa0565b60806040518083038185885af11580156108e1573d6000803e3d6000fd5b50505050506040513d601f19601f82011682018060405250810190610906919061104b565b505050905060004790508c6001600160a01b031663418652706040518163ffffffff1660e01b8152600401600060405180830381600087803b15801561094b57600080fd5b505af115801561095f573d6000803e3d6000fd5b50505050804711156109c9576001600160a01b038a1663e4fc6b6d610984834761109f565b6040518263ffffffff1660e01b81526004016000604051808303818588803b1580156109af57600080fd5b505af11580156109c3573d6000803e3d6000fd5b50505050505b60405163095ea7b360e01b815273034a17fb73ad8dd486b7901c11a153b039add1906004820152602481018390526001600160a01b038e169063095ea7b390604401600060405180830381600087803b158015610a2557600080fd5b505af1158015610a39573d6000803e3d6000fd5b5050505073034a17fb73ad8dd486b7901c11a153b039add1906001600160a01b031663ecd1eb6c838b8f6001600160a01b031663b9a268766040518163ffffffff1660e01b8152600401602060405180830381865afa158015610aa0573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610ac49190610f38565b6040516001600160e01b031960e086901b16815260048101939093526001600160a01b0391821660248401521660448201526064016020604051808303816000875af1158015610b18573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610b3c9190610ecf565b505050505050509550959350505050565b6000806000610b5c8686610d5c565b9150915081600003610b8157838181610b7757610b776110b2565b0492505050610bfc565b818411610b9857610b986003851502601118610d7a565b6000848688096000868103871696879004966002600389028118808a02820302808a02820302808a02820302808a02820302808a02820302808a02909103029181900381900460010185841190960395909502919093039390930492909217029150505b9392505050565b600060018211610c11575090565b816001600160801b8210610c2a5760809190911c9060401b5b680100000000000000008210610c455760409190911c9060201b5b6401000000008210610c5c5760209190911c9060101b5b620100008210610c715760109190911c9060081b5b6101008210610c855760089190911c9060041b5b60108210610c985760049190911c9060021b5b60048210610ca45760011b5b600302600190811c90818581610cbc57610cbc6110b2565b048201901c90506001818581610cd457610cd46110b2565b048201901c90506001818581610cec57610cec6110b2565b048201901c90506001818581610d0457610d046110b2565b048201901c90506001818581610d1c57610d1c6110b2565b048201901c90506001818581610d3457610d346110b2565b048201901c9050610d53818581610d4d57610d4d6110b2565b04821190565b90039392505050565b60008060001983850993909202808410938190039390930393915050565b634e487b71600052806020526024601cfd5b6001600160a01b0381168114610da157600080fd5b50565b600080600080600060808688031215610dbc57600080fd5b8535610dc781610d8c565b94506020860135610dd781610d8c565b935060408601359250606086013567ffffffffffffffff811115610dfa57600080fd5b8601601f81018813610e0b57600080fd5b803567ffffffffffffffff811115610e2257600080fd5b886020828401011115610e3457600080fd5b959894975092955050506020019190565b600080600080600060a08688031215610e5d57600080fd5b8535610e6881610d8c565b94506020860135610e7881610d8c565b9350604086013592506060860135610e8f81610d8c565b91506080860135610e9f81610d8c565b809150509295509295909350565b60008060408385031215610ec057600080fd5b50508035926020909101359150565b600060208284031215610ee157600080fd5b5051919050565b600060208284031215610efa57600080fd5b81518015158114610bfc57600080fd5b600080600060608486031215610f1f57600080fd5b5050815160208301516040909301519094929350919050565b600060208284031215610f4a57600080fd5b8151610bfc81610d8c565b634e487b7160e01b600052601160045260246000fd5b60008160020b627fffff198103610f8457610f84610f55565b60000392915050565b808201808211156102c1576102c1610f55565b81516001600160a01b0316815261014081016020830151610fcc60208401826001600160a01b03169052565b506040830151610fe1604084018260020b9052565b506060830151610ff6606084018260020b9052565b506080830151608083015260a083015160a083015260c083015160c083015260e083015160e083015261010083015161103b6101008401826001600160a01b03169052565b5061012092830151919092015290565b6000806000806080858703121561106157600080fd5b845160208601519094506fffffffffffffffffffffffffffffffff8116811461108957600080fd5b6040860151606090960151949790965092505050565b818103818111156102c1576102c1610f55565b634e487b7160e01b600052601260045260246000fdfea2646970667358221220358e1f01eef27b8bf2153ee78145aa4d429a97ef2294b3ba93c1e595706bf26364736f6c634300081c0033
Deployed Bytecode
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
Deployed Bytecode Sourcemap
78635:6476:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;84837:234;;;;;;;;;;-1:-1:-1;84837:234:0;;;;;:::i;:::-;-1:-1:-1;;;84837:234:0;;;;;;;;;;;-1:-1:-1;;;;;;1300:33:1;;;1282:52;;1270:2;1255:18;84837:234:0;;;;;;;;79416:90;;;;;;;;;;;;79463:42;79416:90;;;;;-1:-1:-1;;;;;1525:32:1;;;1507:51;;1495:2;1480:18;79416:90:0;1345:219:1;78707:77:0;;;;;;;;;;;;78742:42;78707:77;;79517:543;;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;2890:32:1;;;2872:51;;2959:32;;;;2954:2;2939:18;;2932:60;2845:18;79517:543:0;2698:300:1;83962:867:0;;;;;;;;;;-1:-1:-1;83962:867:0;;;;;:::i;:::-;;:::i;78811:77::-;;;;;;;;;;;;78846:42;78811:77;;79517:543;79659:12;79673:14;79702:16;79721:31;79733:5;79740:11;79721;:31::i;:::-;79702:50;-1:-1:-1;;;;;;;;79769:18:0;;;79765:288;;79811:40;79827:6;79835:5;79842:8;79811:15;:40::i;:::-;79804:47;;;;;;;79765:288;-1:-1:-1;;;;;;;79873:18:0;;;79869:184;;79915:65;79931:6;79939:5;79946:8;79956:14;79972:7;79915:15;:65::i;79869:184::-;80013:28;;-1:-1:-1;;;80013:28:0;;3764:2:1;80013:28:0;;;3746:21:1;3803:2;3783:18;;;3776:30;-1:-1:-1;;;3822:18:1;;;3815:48;3880:18;;80013:28:0;;;;;;;;79517:543;;;;;;;;;:::o;83962:867::-;84042:7;84080:1;84070:7;:11;84062:36;;;;-1:-1:-1;;;84062:36:0;;4111:2:1;84062:36:0;;;4093:21:1;4150:2;4130:18;;;4123:30;-1:-1:-1;;;4169:18:1;;;4162:42;4221:18;;84062:36:0;3909:336:1;84062:36:0;84366:16;84385:38;84397:7;-1:-1:-1;;;84415:7:0;84385:11;:38::i;:::-;84366:57;;84582:20;84605:19;84615:8;84605:9;:19::i;:::-;84818:2;84802:18;;-1:-1:-1;;;83962:867:0;;;;;:::o;83294:427::-;83419:30;;-1:-1:-1;;;83419:30:0;;83443:4;83419:30;;;1507:51:1;83370:16:0;;;;-1:-1:-1;;;;;83419:15:0;;;;;1480:18:1;;83419:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;83460:58;;-1:-1:-1;;;83460:58:0;;83479:10;83460:58;;;4687:51:1;83499:4:0;4754:18:1;;;4747:60;4823:18;;;4816:34;;;83399:50:0;;-1:-1:-1;;;;;;83460:18:0;;;;;4660::1;;83460:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;83548:30:0;;-1:-1:-1;;;83548:30:0;;83572:4;83548:30;;;1507:51:1;83529:16:0;;-1:-1:-1;;;;;83548:15:0;;;;;1480:18:1;;83548:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;83529:49;;83608:9;83597:8;:20;83589:46;;;;-1:-1:-1;;;83589:46:0;;5345:2:1;83589:46:0;;;5327:21:1;5384:2;5364:18;;;5357:30;-1:-1:-1;;;5403:18:1;;;5396:43;5456:18;;83589:46:0;5143:337:1;83589:46:0;83682:20;;83294:427;-1:-1:-1;;;83294:427:0:o;80068:761::-;80253:29;;-1:-1:-1;;;80253:29:0;;-1:-1:-1;;;;;5677:32:1;;;80253:29:0;;;5659:51:1;5726:18;;;5719:34;;;80159:12:0;;;;80253:13;;;;;5632:18:1;;80253:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;80341:208:0;;-1:-1:-1;;;80341:208:0;;-1:-1:-1;;;;;6085:32:1;;;80341:208:0;;;6067:51:1;6134:18;;;6127:34;;;80466:1:0;6177:18:1;;;6170:34;;;6220:18;;;6213:34;;;6263:19;;;6256:61;80523:15:0;6333:19:1;;;6326:35;80341:42:0;;;;;80391:9;;6039:19:1;;80341:208:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;80640:6;-1:-1:-1;;;;;80621:34:0;;:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;80603:85;;-1:-1:-1;;;80603:85:0;;-1:-1:-1;;;;;2890:32:1;;;80603:85:0;;;2872:51:1;79284:42:0;2939:18:1;;;2932:60;80603:63:0;;;;;;;2845:18:1;;80603:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;80596:92;-1:-1:-1;79284:42:0;-1:-1:-1;;;;;80703:21:0;;;80699:123;;;-1:-1:-1;80758:5:0;80699:123;;;-1:-1:-1;79284:42:0;80699:123;80068:761;;;;;;:::o;80837:2447::-;81058:29;;-1:-1:-1;;;81058:29:0;;-1:-1:-1;;;;;5677:32:1;;;81058:29:0;;;5659:51:1;5726:18;;;5719:34;;;80969:12:0;;;;81058:13;;;;;5632:18:1;;81058:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;81161:14:0;;;79284:42;-1:-1:-1;;;;;81299:21:0;;;81295:319;;;-1:-1:-1;81354:5:0;;-1:-1:-1;79284:42:0;;-1:-1:-1;81413:6:0;;-1:-1:-1;81444:9:0;81295:319;;;-1:-1:-1;79284:42:0;;-1:-1:-1;81531:5:0;;-1:-1:-1;81562:9:0;;-1:-1:-1;81596:6:0;81295:319;81626:27;81656:33;81672:7;81681;81656:15;:33::i;:::-;81748:157;;-1:-1:-1;;;81748:157:0;;-1:-1:-1;;;;;7309:32:1;;;81748:157:0;;;7291:51:1;7378:32;;;7358:18;;;7351:60;7447:32;;;7427:18;;;7420:60;81626:63:0;;-1:-1:-1;81748:70:0;;;;;;7264:18:1;;81748:157:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;81741:164;;81950:15;82000:6;-1:-1:-1;;;;;81972:40:0;;82020:9;82045:588;;;;;;;;82111:6;-1:-1:-1;;;;;82045:588:0;;;;;82144:6;-1:-1:-1;;;;;82045:588:0;;;;;-1:-1:-1;;82045:588:0;;;;;;-1:-1:-1;;79208:9:0;;;:::i;:::-;82045:588;;;;;;;;;;;;;;;;-1:-1:-1;82045:588:0;;;;;;;;;;82542:4;82045:588;;;;;;82576:20;:15;82594:2;82576:20;:::i;:::-;82045:588;;;81972:672;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;81949:695;;;;;82732:17;82752:21;82732:41;;82812:6;-1:-1:-1;;;;;82784:53:0;;:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;82878:9;82854:21;:33;82850:152;;;-1:-1:-1;;;;;82904:42:0;;;82954:33;82978:9;82954:21;:33;:::i;:::-;82904:86;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;82850:152;83055:71;;-1:-1:-1;;;83055:71:0;;79463:42;83055:71;;;5659:51:1;5726:18;;;5719:34;;;-1:-1:-1;;;;;83055:43:0;;;;;5632:18:1;;83055:71:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;79463:42;-1:-1:-1;;;;;83223:13:0;;83237:7;83246;83255:5;-1:-1:-1;;;;;83255:18:0;;:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;83223:53;;-1:-1:-1;;;;;;83223:53:0;;;;;;;;;;10076:25:1;;;;-1:-1:-1;;;;;10137:32:1;;;10117:18;;;10110:60;10206:32;10186:18;;;10179:60;10049:18;;83223:53:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;80999:2285;;;;;;80837:2447;;;;;;;;:::o;53024:3754::-;53106:14;53159:12;53173:11;53188:12;53195:1;53198;53188:6;:12::i;:::-;53158:42;;;;53285:4;53293:1;53285:9;53281:370;;53624:11;53618:3;:17;;;;;:::i;:::-;;53611:24;;;;;;53281:370;53779:4;53764:11;:19;53760:144;;53804:84;51038:5;53824:16;;51037:36;8850:4;51032:42;53804:11;:84::i;:::-;54163:17;54317:11;54314:1;54311;54304:25;54719:12;54749:15;;;54734:31;;54887:22;;;;;55635:1;55616;:15;;55615:21;;55872;;;55868:25;;55857:36;55943:21;;;55939:25;;55928:36;56016:21;;;56012:25;;56001:36;56088:21;;;56084:25;;56073:36;56162:21;;;56158:25;;56147:36;56237:21;;;56233:25;;;56222:36;55135:12;;;;55131:23;;;55156:1;55127:31;54432:18;;;54422:29;;;55246:11;;;;54476:19;;;;54983:14;;;;55239:18;;;;56718:13;;-1:-1:-1;;53024:3754:0;;;;;;:::o;66637:5285::-;66685:7;66806:1;66801;:6;66797:55;;-1:-1:-1;66835:1:0;66637:5285::o;66797:55::-;67806:1;67835;-1:-1:-1;;;67857:16:0;;67853:95;;67901:3;67894:10;;;;;67930:2;67923:9;67853:95;67973:7;67966:2;:15;67962:93;;68009:2;68002:9;;;;;68037:2;68030:9;67962:93;68080:7;68073:2;:15;68069:93;;68116:2;68109:9;;;;;68144:2;68137:9;68069:93;68187:7;68180:2;:15;68176:92;;68223:2;68216:9;;;;;68251:1;68244:8;68176:92;68293:6;68286:2;:14;68282:90;;68328:1;68321:8;;;;;68355:1;68348:8;68282:90;68397:6;68390:2;:14;68386:90;;68432:1;68425:8;;;;;68459:1;68452:8;68386:90;68501:6;68494:2;:14;68490:63;;68536:1;68529:8;68490:63;68986:1;:6;68997:1;68985:13;;;;;70933:1;68985:13;70933:6;;;;:::i;:::-;;70928:2;:11;70927:18;;70922:23;;71054:1;71047:2;71043:1;:6;;;;;:::i;:::-;;71038:2;:11;71037:18;;71032:23;;71166:1;71159:2;71155:1;:6;;;;;:::i;:::-;;71150:2;:11;71149:18;;71144:23;;71276:1;71269:2;71265:1;:6;;;;;:::i;:::-;;71260:2;:11;71259:18;;71254:23;;71387:1;71380:2;71376:1;:6;;;;;:::i;:::-;;71371:2;:11;71370:18;;71365:23;;71498:1;71491:2;71487:1;:6;;;;;:::i;:::-;;71482:2;:11;71481:18;;71476:23;;71875:28;71900:2;71896:1;:6;;;;;:::i;:::-;;71891:11;;;45638:149;71875:28;71870:33;;;66637:5285;-1:-1:-1;;;66637:5285:0:o;46642:559::-;46703:12;;-1:-1:-1;;47091:1:0;47088;47081:20;47122:9;;;;47171:11;;;47157:12;;;;47153:30;;;;;46642:559;-1:-1:-1;;46642:559:0:o;9704:200::-;9811:10;9805:4;9798:24;9849:4;9843;9836:18;9881:4;9875;9868:18;14:131:1;-1:-1:-1;;;;;89:31:1;;79:42;;69:70;;135:1;132;125:12;69:70;14:131;:::o;150:983::-;247:6;255;263;271;279;332:3;320:9;311:7;307:23;303:33;300:53;;;349:1;346;339:12;300:53;388:9;375:23;407:31;432:5;407:31;:::i;:::-;457:5;-1:-1:-1;514:2:1;499:18;;486:32;527:33;486:32;527:33;:::i;:::-;579:7;-1:-1:-1;659:2:1;644:18;;631:32;;-1:-1:-1;740:2:1;725:18;;712:32;767:18;756:30;;753:50;;;799:1;796;789:12;753:50;822:22;;875:4;867:13;;863:27;-1:-1:-1;853:55:1;;904:1;901;894:12;853:55;944:2;931:16;970:18;962:6;959:30;956:50;;;1002:1;999;992:12;956:50;1047:7;1042:2;1033:6;1029:2;1025:15;1021:24;1018:37;1015:57;;;1068:1;1065;1058:12;1015:57;150:983;;;;-1:-1:-1;150:983:1;;-1:-1:-1;;;1099:2:1;1091:11;;1121:6;150:983::o;1886:807::-;1996:6;2004;2012;2020;2028;2081:3;2069:9;2060:7;2056:23;2052:33;2049:53;;;2098:1;2095;2088:12;2049:53;2137:9;2124:23;2156:31;2181:5;2156:31;:::i;:::-;2206:5;-1:-1:-1;2263:2:1;2248:18;;2235:32;2276:33;2235:32;2276:33;:::i;:::-;2328:7;-1:-1:-1;2408:2:1;2393:18;;2380:32;;-1:-1:-1;2490:2:1;2475:18;;2462:32;2503:33;2462:32;2503:33;:::i;:::-;2555:7;-1:-1:-1;2614:3:1;2599:19;;2586:33;2628;2586;2628;:::i;:::-;2680:7;2670:17;;;1886:807;;;;;;;;:::o;3003:346::-;3071:6;3079;3132:2;3120:9;3111:7;3107:23;3103:32;3100:52;;;3148:1;3145;3138:12;3100:52;-1:-1:-1;;3193:23:1;;;3313:2;3298:18;;;3285:32;;-1:-1:-1;3003:346:1:o;4250:230::-;4320:6;4373:2;4361:9;4352:7;4348:23;4344:32;4341:52;;;4389:1;4386;4379:12;4341:52;-1:-1:-1;4434:16:1;;4250:230;-1:-1:-1;4250:230:1:o;4861:277::-;4928:6;4981:2;4969:9;4960:7;4956:23;4952:32;4949:52;;;4997:1;4994;4987:12;4949:52;5029:9;5023:16;5082:5;5075:13;5068:21;5061:5;5058:32;5048:60;;5104:1;5101;5094:12;6372:456;6460:6;6468;6476;6529:2;6517:9;6508:7;6504:23;6500:32;6497:52;;;6545:1;6542;6535:12;6497:52;-1:-1:-1;;6590:16:1;;6696:2;6681:18;;6675:25;6792:2;6777:18;;;6771:25;6590:16;;6675:25;;-1:-1:-1;6771:25:1;6372:456;-1:-1:-1;6372:456:1:o;6833:251::-;6903:6;6956:2;6944:9;6935:7;6931:23;6927:32;6924:52;;;6972:1;6969;6962:12;6924:52;7004:9;6998:16;7023:31;7048:5;7023:31;:::i;7491:127::-;7552:10;7547:3;7543:20;7540:1;7533:31;7583:4;7580:1;7573:15;7607:4;7604:1;7597:15;7623:184;7657:3;7704:5;7701:1;7690:20;7738:7;7734:12;7725:7;7722:25;7719:51;;7750:18;;:::i;:::-;7790:1;7786:15;;7623:184;-1:-1:-1;;7623:184:1:o;7812:125::-;7877:9;;;7898:10;;;7895:36;;;7911:18;;:::i;8038:1046::-;8258:13;;-1:-1:-1;;;;;1635:31:1;1623:44;;8226:3;8211:19;;8330:4;8322:6;8318:17;8312:24;8345:54;8393:4;8382:9;8378:20;8364:12;-1:-1:-1;;;;;1635:31:1;1623:44;;1569:104;8345:54;;8448:4;8440:6;8436:17;8430:24;8463:54;8511:4;8500:9;8496:20;8480:14;8017:1;8006:20;7994:33;;7942:91;8463:54;;8566:4;8558:6;8554:17;8548:24;8581:54;8629:4;8618:9;8614:20;8598:14;8017:1;8006:20;7994:33;;7942:91;8581:54;;8691:4;8683:6;8679:17;8673:24;8666:4;8655:9;8651:20;8644:54;8754:4;8746:6;8742:17;8736:24;8729:4;8718:9;8714:20;8707:54;8817:4;8809:6;8805:17;8799:24;8792:4;8781:9;8777:20;8770:54;8880:4;8872:6;8868:17;8862:24;8855:4;8844:9;8840:20;8833:54;8936:6;8928;8924:19;8918:26;8953:58;9003:6;8992:9;8988:22;8972:14;-1:-1:-1;;;;;1635:31:1;1623:44;;1569:104;8953:58;-1:-1:-1;9069:6:1;9057:19;;;9051:26;9027:22;;;;9020:58;8038:1046;:::o;9089:647::-;9186:6;9194;9202;9210;9263:3;9251:9;9242:7;9238:23;9234:33;9231:53;;;9280:1;9277;9270:12;9231:53;9325:16;;9410:2;9395:18;;9389:25;9325:16;;-1:-1:-1;9458:34:1;9445:48;;9433:61;;9423:89;;9508:1;9505;9498:12;9423:89;9604:2;9589:18;;9583:25;9700:2;9685:18;;;9679:25;9089:647;;9531:7;;-1:-1:-1;9089:647:1;-1:-1:-1;;;9089:647:1:o;9741:128::-;9808:9;;;9829:11;;;9826:37;;;9843:18;;:::i;10250:127::-;10311:10;10306:3;10302:20;10299:1;10292:31;10342:4;10339:1;10332:15;10366:4;10363:1;10356:15
Swarm Source
ipfs://358e1f01eef27b8bf2153ee78145aa4d429a97ef2294b3ba93c1e595706bf263
Loading...
Loading
Loading...
Loading
0x7B53Ec7A5e1C30D4b91D2c3Ec0472a6E4818a657
Loading...
Loading
Loading...
Loading
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.