Sponsored
MoonPay
Buy, sell and swap Ethereum with MoonPay.Buy Now!
20M+ users trust MoonPay worldwide. Checkout with your preferred payment method.
MetaMask
Manage your web3 everything with MetaMask Portfolio. Try Now!
Ready to onboard to Ethereum? With MetaMask Portfolio, you're in control.
eToro
One-stop crypto shop: trusted, simple & safe.
Don’t invest unless you’re prepared to lose all the money you invest.
Sponsored
Сoins.game
100 free spins for registration. Spin now!
Everyday giveaways up to 100 ETH, Lucky Spins. Deposit BONUS 300% and Cashbacks!
BC.GAME
- The Best ETH Casino Claim Now!
5000+ Slots & Live Casino Games, 50+cryptos. Register with Etherscan and get 760% deposit bonus. Win Big$, withdraw it fast.
Stake
200% Bonus, 100K Daily Giveaways, Instant Withdrawals Play Now!
Slots, Roulette, Poker & more - Proud sponsors of UFC, Everton & StakeF1 team!
Sponsored
BC.GAME
- The Best ETH Casino Claim Now!
5000+ Slots & Live Casino Games, 50+cryptos. Register with Etherscan and get 760% deposit bonus. Win Big$, withdraw it fast.
CryptoSlots
Play & Get 25 Free Spins at CryptoSlots Play Now
Anonymous play on awesome games - sign up now for 25 free jackpot spins - worth $100s!
CryptoWins
200% More Funds to Play on Us up to 4 BTC! Claim Now!
100s of games, generous bonuses, 20+ years of trusted gaming. Join CryptoWins & start winning today!
Overview
ETH Balance
0 ETH
Eth Value
$0.00Token Holdings
- ERC-20 Tokens (5)3.0240835 CVX
Convex Token (CVX)$9.53@3.14971,012.86936388 FXS
Frax Share (FXS)$2,643.59@2.6111.69752497 stkcvxankrfrxETH-f-frax
Staked Curve... (stkcvx...)431.89607502 CRV
Curve DAO To... (CRV)$221.84@0.51372,382.23 TokenERC-20 TOKEN*[Suspicious]Official Authorize credential
FRAX: Airdrop NFT VoucherERC-1155claim rewards on fraxprotocol.comfraxprotocol.comERC-1155
More Info
Private Name Tags
ContractCreator
Latest 8 from a total of 8 transactions
| Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
|---|---|---|---|---|---|---|---|---|---|
| Sync | 20602144 | 90 days ago | IN | 0 ETH | 0.00075758 | ||||
| Sync | 20530582 | 100 days ago | IN | 0 ETH | 0.00178799 | ||||
| Sync | 19756396 | 208 days ago | IN | 0 ETH | 0.0008137 | ||||
| Sync | 19073435 | 304 days ago | IN | 0 ETH | 0.00142219 | ||||
| Sync | 18752007 | 349 days ago | IN | 0 ETH | 0.01896547 | ||||
| Sync | 18114141 | 439 days ago | IN | 0 ETH | 0.00494551 | ||||
| Sync | 17736249 | 491 days ago | IN | 0 ETH | 0.01716923 | ||||
| 0x60806040 | 17574632 | 514 days ago | IN | 0 ETH | 0.1091101 |
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Similar Match Source Code This contract matches the deployed Bytecode of the Source Code for Contract 0xa8A58C6e...5A48Cb4C3 The constructor portion of the code might be different and could alter the actual behaviour of the contract
Contract Name:
FraxUnifiedFarm_ERC20_Convex_frxETH
Compiler Version
v0.8.19+commit.7dd6d404
Contract Source Code (Solidity)
/**
*Submitted for verification at Etherscan.io on 2023-06-28
*/
// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.8.0;
// Sources flattened with hardhat v2.14.0 https://hardhat.org
// File contracts/Common/Context.sol
/*
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with GSN meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return payable(msg.sender);
}
function _msgData() internal view virtual returns (bytes memory) {
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
return msg.data;
}
}
// File contracts/Math/SafeMath.sol
/**
* @dev Wrappers over Solidity's arithmetic operations with added overflow
* checks.
*
* Arithmetic operations in Solidity wrap on overflow. This can easily result
* in bugs, because programmers usually assume that an overflow raises an
* error, which is the standard behavior in high level programming languages.
* `SafeMath` restores this intuition by reverting the transaction when 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 SafeMath {
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*
* _Available since v2.4.0._
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*
* _Available since v2.4.0._
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*
* _Available since v2.4.0._
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
// File contracts/ERC20/IERC20.sol
/**
* @dev Interface of the ERC20 standard as defined in the EIP. Does not include
* the optional functions; to access them see {ERC20Detailed}.
*/
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
// File contracts/Uniswap_V3/pool/IUniswapV3PoolActions.sol
/// @title Permissionless pool actions
/// @notice Contains pool methods that can be called by anyone
interface IUniswapV3PoolActions {
/// @notice Sets the initial price for the pool
/// @dev Price is represented as a sqrt(amountToken1/amountToken0) Q64.96 value
/// @param sqrtPriceX96 the initial sqrt price of the pool as a Q64.96
function initialize(uint160 sqrtPriceX96) external;
/// @notice Adds liquidity for the given recipient/tickLower/tickUpper position
/// @dev The caller of this method receives a callback in the form of IUniswapV3MintCallback#uniswapV3MintCallback
/// in which they must pay any token0 or token1 owed for the liquidity. The amount of token0/token1 due depends
/// on tickLower, tickUpper, the amount of liquidity, and the current price.
/// @param recipient The address for which the liquidity will be created
/// @param tickLower The lower tick of the position in which to add liquidity
/// @param tickUpper The upper tick of the position in which to add liquidity
/// @param amount The amount of liquidity to mint
/// @param data Any data that should be passed through to the callback
/// @return amount0 The amount of token0 that was paid to mint the given amount of liquidity. Matches the value in the callback
/// @return amount1 The amount of token1 that was paid to mint the given amount of liquidity. Matches the value in the callback
function mint(
address recipient,
int24 tickLower,
int24 tickUpper,
uint128 amount,
bytes calldata data
) external returns (uint256 amount0, uint256 amount1);
/// @notice Collects tokens owed to a position
/// @dev Does not recompute fees earned, which must be done either via mint or burn of any amount of liquidity.
/// Collect must be called by the position owner. To withdraw only token0 or only token1, amount0Requested or
/// amount1Requested may be set to zero. To withdraw all tokens owed, caller may pass any value greater than the
/// actual tokens owed, e.g. type(uint128).max. Tokens owed may be from accumulated swap fees or burned liquidity.
/// @param recipient The address which should receive the fees collected
/// @param tickLower The lower tick of the position for which to collect fees
/// @param tickUpper The upper tick of the position for which to collect fees
/// @param amount0Requested How much token0 should be withdrawn from the fees owed
/// @param amount1Requested How much token1 should be withdrawn from the fees owed
/// @return amount0 The amount of fees collected in token0
/// @return amount1 The amount of fees collected in token1
function collect(
address recipient,
int24 tickLower,
int24 tickUpper,
uint128 amount0Requested,
uint128 amount1Requested
) external returns (uint128 amount0, uint128 amount1);
/// @notice Burn liquidity from the sender and account tokens owed for the liquidity to the position
/// @dev Can be used to trigger a recalculation of fees owed to a position by calling with an amount of 0
/// @dev Fees must be collected separately via a call to #collect
/// @param tickLower The lower tick of the position for which to burn liquidity
/// @param tickUpper The upper tick of the position for which to burn liquidity
/// @param amount How much liquidity to burn
/// @return amount0 The amount of token0 sent to the recipient
/// @return amount1 The amount of token1 sent to the recipient
function burn(
int24 tickLower,
int24 tickUpper,
uint128 amount
) external returns (uint256 amount0, uint256 amount1);
/// @notice Swap token0 for token1, or token1 for token0
/// @dev The caller of this method receives a callback in the form of IUniswapV3SwapCallback#uniswapV3SwapCallback
/// @param recipient The address to receive the output of the swap
/// @param zeroForOne The direction of the swap, true for token0 to token1, false for token1 to token0
/// @param amountSpecified The amount of the swap, which implicitly configures the swap as exact input (positive), or exact output (negative)
/// @param sqrtPriceLimitX96 The Q64.96 sqrt price limit. If zero for one, the price cannot be less than this
/// value after the swap. If one for zero, the price cannot be greater than this value after the swap
/// @param data Any data to be passed through to the callback
/// @return amount0 The delta of the balance of token0 of the pool, exact when negative, minimum when positive
/// @return amount1 The delta of the balance of token1 of the pool, exact when negative, minimum when positive
function swap(
address recipient,
bool zeroForOne,
int256 amountSpecified,
uint160 sqrtPriceLimitX96,
bytes calldata data
) external returns (int256 amount0, int256 amount1);
/// @notice Receive token0 and/or token1 and pay it back, plus a fee, in the callback
/// @dev The caller of this method receives a callback in the form of IUniswapV3FlashCallback#uniswapV3FlashCallback
/// @dev Can be used to donate underlying tokens pro-rata to currently in-range liquidity providers by calling
/// with 0 amount{0,1} and sending the donation amount(s) from the callback
/// @param recipient The address which will receive the token0 and token1 amounts
/// @param amount0 The amount of token0 to send
/// @param amount1 The amount of token1 to send
/// @param data Any data to be passed through to the callback
function flash(
address recipient,
uint256 amount0,
uint256 amount1,
bytes calldata data
) external;
/// @notice Increase the maximum number of price and liquidity observations that this pool will store
/// @dev This method is no-op if the pool already has an observationCardinalityNext greater than or equal to
/// the input observationCardinalityNext.
/// @param observationCardinalityNext The desired minimum number of observations for the pool to store
function increaseObservationCardinalityNext(uint16 observationCardinalityNext) external;
}
// File contracts/Uniswap_V3/pool/IUniswapV3PoolDerivedState.sol
/// @title Pool state that is not stored
/// @notice Contains view functions to provide information about the pool that is computed rather than stored on the
/// blockchain. The functions here may have variable gas costs.
interface IUniswapV3PoolDerivedState {
/// @notice Returns the cumulative tick and liquidity as of each timestamp `secondsAgo` from the current block timestamp
/// @dev To get a time weighted average tick or liquidity-in-range, you must call this with two values, one representing
/// the beginning of the period and another for the end of the period. E.g., to get the last hour time-weighted average tick,
/// you must call it with secondsAgos = [3600, 0].
/// @dev The time weighted average tick represents the geometric time weighted average price of the pool, in
/// log base sqrt(1.0001) of token1 / token0. The TickMath library can be used to go from a tick value to a ratio.
/// @param secondsAgos From how long ago each cumulative tick and liquidity value should be returned
/// @return tickCumulatives Cumulative tick values as of each `secondsAgos` from the current block timestamp
/// @return secondsPerLiquidityCumulativeX128s Cumulative seconds per liquidity-in-range value as of each `secondsAgos` from the current block
/// timestamp
function observe(uint32[] calldata secondsAgos)
external
view
returns (int56[] memory tickCumulatives, uint160[] memory secondsPerLiquidityCumulativeX128s);
/// @notice Returns a snapshot of the tick cumulative, seconds per liquidity and seconds inside a tick range
/// @dev Snapshots must only be compared to other snapshots, taken over a period for which a position existed.
/// I.e., snapshots cannot be compared if a position is not held for the entire period between when the first
/// snapshot is taken and the second snapshot is taken.
/// @param tickLower The lower tick of the range
/// @param tickUpper The upper tick of the range
/// @return tickCumulativeInside The snapshot of the tick accumulator for the range
/// @return secondsPerLiquidityInsideX128 The snapshot of seconds per liquidity for the range
/// @return secondsInside The snapshot of seconds per liquidity for the range
function snapshotCumulativesInside(int24 tickLower, int24 tickUpper)
external
view
returns (
int56 tickCumulativeInside,
uint160 secondsPerLiquidityInsideX128,
uint32 secondsInside
);
}
// File contracts/Uniswap_V3/pool/IUniswapV3PoolEvents.sol
/// @title Events emitted by a pool
/// @notice Contains all events emitted by the pool
interface IUniswapV3PoolEvents {
/// @notice Emitted exactly once by a pool when #initialize is first called on the pool
/// @dev Mint/Burn/Swap cannot be emitted by the pool before Initialize
/// @param sqrtPriceX96 The initial sqrt price of the pool, as a Q64.96
/// @param tick The initial tick of the pool, i.e. log base 1.0001 of the starting price of the pool
event Initialize(uint160 sqrtPriceX96, int24 tick);
/// @notice Emitted when liquidity is minted for a given position
/// @param sender The address that minted the liquidity
/// @param owner The owner of the position and recipient of any minted liquidity
/// @param tickLower The lower tick of the position
/// @param tickUpper The upper tick of the position
/// @param amount The amount of liquidity minted to the position range
/// @param amount0 How much token0 was required for the minted liquidity
/// @param amount1 How much token1 was required for the minted liquidity
event Mint(
address sender,
address indexed owner,
int24 indexed tickLower,
int24 indexed tickUpper,
uint128 amount,
uint256 amount0,
uint256 amount1
);
/// @notice Emitted when fees are collected by the owner of a position
/// @dev Collect events may be emitted with zero amount0 and amount1 when the caller chooses not to collect fees
/// @param owner The owner of the position for which fees are collected
/// @param tickLower The lower tick of the position
/// @param tickUpper The upper tick of the position
/// @param amount0 The amount of token0 fees collected
/// @param amount1 The amount of token1 fees collected
event Collect(
address indexed owner,
address recipient,
int24 indexed tickLower,
int24 indexed tickUpper,
uint128 amount0,
uint128 amount1
);
/// @notice Emitted when a position's liquidity is removed
/// @dev Does not withdraw any fees earned by the liquidity position, which must be withdrawn via #collect
/// @param owner The owner of the position for which liquidity is removed
/// @param tickLower The lower tick of the position
/// @param tickUpper The upper tick of the position
/// @param amount The amount of liquidity to remove
/// @param amount0 The amount of token0 withdrawn
/// @param amount1 The amount of token1 withdrawn
event Burn(
address indexed owner,
int24 indexed tickLower,
int24 indexed tickUpper,
uint128 amount,
uint256 amount0,
uint256 amount1
);
/// @notice Emitted by the pool for any swaps between token0 and token1
/// @param sender The address that initiated the swap call, and that received the callback
/// @param recipient The address that received the output of the swap
/// @param amount0 The delta of the token0 balance of the pool
/// @param amount1 The delta of the token1 balance of the pool
/// @param sqrtPriceX96 The sqrt(price) of the pool after the swap, as a Q64.96
/// @param liquidity The liquidity of the pool after the swap
/// @param tick The log base 1.0001 of price of the pool after the swap
event Swap(
address indexed sender,
address indexed recipient,
int256 amount0,
int256 amount1,
uint160 sqrtPriceX96,
uint128 liquidity,
int24 tick
);
/// @notice Emitted by the pool for any flashes of token0/token1
/// @param sender The address that initiated the swap call, and that received the callback
/// @param recipient The address that received the tokens from flash
/// @param amount0 The amount of token0 that was flashed
/// @param amount1 The amount of token1 that was flashed
/// @param paid0 The amount of token0 paid for the flash, which can exceed the amount0 plus the fee
/// @param paid1 The amount of token1 paid for the flash, which can exceed the amount1 plus the fee
event Flash(
address indexed sender,
address indexed recipient,
uint256 amount0,
uint256 amount1,
uint256 paid0,
uint256 paid1
);
/// @notice Emitted by the pool for increases to the number of observations that can be stored
/// @dev observationCardinalityNext is not the observation cardinality until an observation is written at the index
/// just before a mint/swap/burn.
/// @param observationCardinalityNextOld The previous value of the next observation cardinality
/// @param observationCardinalityNextNew The updated value of the next observation cardinality
event IncreaseObservationCardinalityNext(
uint16 observationCardinalityNextOld,
uint16 observationCardinalityNextNew
);
/// @notice Emitted when the protocol fee is changed by the pool
/// @param feeProtocol0Old The previous value of the token0 protocol fee
/// @param feeProtocol1Old The previous value of the token1 protocol fee
/// @param feeProtocol0New The updated value of the token0 protocol fee
/// @param feeProtocol1New The updated value of the token1 protocol fee
event SetFeeProtocol(uint8 feeProtocol0Old, uint8 feeProtocol1Old, uint8 feeProtocol0New, uint8 feeProtocol1New);
/// @notice Emitted when the collected protocol fees are withdrawn by the factory owner
/// @param sender The address that collects the protocol fees
/// @param recipient The address that receives the collected protocol fees
/// @param amount0 The amount of token0 protocol fees that is withdrawn
/// @param amount0 The amount of token1 protocol fees that is withdrawn
event CollectProtocol(address indexed sender, address indexed recipient, uint128 amount0, uint128 amount1);
}
// File contracts/Uniswap_V3/pool/IUniswapV3PoolImmutables.sol
/// @title Pool state that never changes
/// @notice These parameters are fixed for a pool forever, i.e., the methods will always return the same values
interface IUniswapV3PoolImmutables {
/// @notice The contract that deployed the pool, which must adhere to the IUniswapV3Factory interface
/// @return The contract address
function factory() external view returns (address);
/// @notice The first of the two tokens of the pool, sorted by address
/// @return The token contract address
function token0() external view returns (address);
/// @notice The second of the two tokens of the pool, sorted by address
/// @return The token contract address
function token1() external view returns (address);
/// @notice The pool's fee in hundredths of a bip, i.e. 1e-6
/// @return The fee
function fee() external view returns (uint24);
/// @notice The pool tick spacing
/// @dev Ticks can only be used at multiples of this value, minimum of 1 and always positive
/// e.g.: a tickSpacing of 3 means ticks can be initialized every 3rd tick, i.e., ..., -6, -3, 0, 3, 6, ...
/// This value is an int24 to avoid casting even though it is always positive.
/// @return The tick spacing
function tickSpacing() external view returns (int24);
/// @notice The maximum amount of position liquidity that can use any tick in the range
/// @dev This parameter is enforced per tick to prevent liquidity from overflowing a uint128 at any point, and
/// also prevents out-of-range liquidity from being used to prevent adding in-range liquidity to a pool
/// @return The max amount of liquidity per tick
function maxLiquidityPerTick() external view returns (uint128);
}
// File contracts/Uniswap_V3/pool/IUniswapV3PoolOwnerActions.sol
/// @title Permissioned pool actions
/// @notice Contains pool methods that may only be called by the factory owner
interface IUniswapV3PoolOwnerActions {
/// @notice Set the denominator of the protocol's % share of the fees
/// @param feeProtocol0 new protocol fee for token0 of the pool
/// @param feeProtocol1 new protocol fee for token1 of the pool
function setFeeProtocol(uint8 feeProtocol0, uint8 feeProtocol1) external;
/// @notice Collect the protocol fee accrued to the pool
/// @param recipient The address to which collected protocol fees should be sent
/// @param amount0Requested The maximum amount of token0 to send, can be 0 to collect fees in only token1
/// @param amount1Requested The maximum amount of token1 to send, can be 0 to collect fees in only token0
/// @return amount0 The protocol fee collected in token0
/// @return amount1 The protocol fee collected in token1
function collectProtocol(
address recipient,
uint128 amount0Requested,
uint128 amount1Requested
) external returns (uint128 amount0, uint128 amount1);
}
// File contracts/Uniswap_V3/pool/IUniswapV3PoolState.sol
/// @title Pool state that can change
/// @notice These methods compose the pool's state, and can change with any frequency including multiple times
/// per transaction
interface IUniswapV3PoolState {
/// @notice The 0th storage slot in the pool stores many values, and is exposed as a single method to save gas
/// when accessed externally.
/// @return sqrtPriceX96 The current price of the pool as a sqrt(token1/token0) Q64.96 value
/// tick The current tick of the pool, i.e. according to the last tick transition that was run.
/// This value may not always be equal to SqrtTickMath.getTickAtSqrtRatio(sqrtPriceX96) if the price is on a tick
/// boundary.
/// observationIndex The index of the last oracle observation that was written,
/// observationCardinality The current maximum number of observations stored in the pool,
/// observationCardinalityNext The next maximum number of observations, to be updated when the observation.
/// feeProtocol The protocol fee for both tokens of the pool.
/// Encoded as two 4 bit values, where the protocol fee of token1 is shifted 4 bits and the protocol fee of token0
/// is the lower 4 bits. Used as the denominator of a fraction of the swap fee, e.g. 4 means 1/4th of the swap fee.
/// unlocked Whether the pool is currently locked to reentrancy
function slot0()
external
view
returns (
uint160 sqrtPriceX96,
int24 tick,
uint16 observationIndex,
uint16 observationCardinality,
uint16 observationCardinalityNext,
uint8 feeProtocol,
bool unlocked
);
/// @notice The fee growth as a Q128.128 fees of token0 collected per unit of liquidity for the entire life of the pool
/// @dev This value can overflow the uint256
function feeGrowthGlobal0X128() external view returns (uint256);
/// @notice The fee growth as a Q128.128 fees of token1 collected per unit of liquidity for the entire life of the pool
/// @dev This value can overflow the uint256
function feeGrowthGlobal1X128() external view returns (uint256);
/// @notice The amounts of token0 and token1 that are owed to the protocol
/// @dev Protocol fees will never exceed uint128 max in either token
function protocolFees() external view returns (uint128 token0, uint128 token1);
/// @notice The currently in range liquidity available to the pool
/// @dev This value has no relationship to the total liquidity across all ticks
function liquidity() external view returns (uint128);
/// @notice Look up information about a specific tick in the pool
/// @param tick The tick to look up
/// @return liquidityGross the total amount of position liquidity that uses the pool either as tick lower or
/// tick upper,
/// liquidityNet how much liquidity changes when the pool price crosses the tick,
/// feeGrowthOutside0X128 the fee growth on the other side of the tick from the current tick in token0,
/// feeGrowthOutside1X128 the fee growth on the other side of the tick from the current tick in token1,
/// tickCumulativeOutside the cumulative tick value on the other side of the tick from the current tick
/// secondsPerLiquidityOutsideX128 the seconds spent per liquidity on the other side of the tick from the current tick,
/// secondsOutside the seconds spent on the other side of the tick from the current tick,
/// initialized Set to true if the tick is initialized, i.e. liquidityGross is greater than 0, otherwise equal to false.
/// Outside values can only be used if the tick is initialized, i.e. if liquidityGross is greater than 0.
/// In addition, these values are only relative and must be used only in comparison to previous snapshots for
/// a specific position.
function ticks(int24 tick)
external
view
returns (
uint128 liquidityGross,
int128 liquidityNet,
uint256 feeGrowthOutside0X128,
uint256 feeGrowthOutside1X128,
int56 tickCumulativeOutside,
uint160 secondsPerLiquidityOutsideX128,
uint32 secondsOutside,
bool initialized
);
/// @notice Returns 256 packed tick initialized boolean values. See TickBitmap for more information
function tickBitmap(int16 wordPosition) external view returns (uint256);
/// @notice Returns the information about a position by the position's key
/// @param key The position's key is a hash of a preimage composed by the owner, tickLower and tickUpper
/// @return _liquidity The amount of liquidity in the position,
/// Returns feeGrowthInside0LastX128 fee growth of token0 inside the tick range as of the last mint/burn/poke,
/// Returns feeGrowthInside1LastX128 fee growth of token1 inside the tick range as of the last mint/burn/poke,
/// Returns tokensOwed0 the computed amount of token0 owed to the position as of the last mint/burn/poke,
/// Returns tokensOwed1 the computed amount of token1 owed to the position as of the last mint/burn/poke
function positions(bytes32 key)
external
view
returns (
uint128 _liquidity,
uint256 feeGrowthInside0LastX128,
uint256 feeGrowthInside1LastX128,
uint128 tokensOwed0,
uint128 tokensOwed1
);
/// @notice Returns data about a specific observation index
/// @param index The element of the observations array to fetch
/// @dev You most likely want to use #observe() instead of this method to get an observation as of some amount of time
/// ago, rather than at a specific index in the array.
/// @return blockTimestamp The timestamp of the observation,
/// Returns tickCumulative the tick multiplied by seconds elapsed for the life of the pool as of the observation timestamp,
/// Returns secondsPerLiquidityCumulativeX128 the seconds per in range liquidity for the life of the pool as of the observation timestamp,
/// Returns initialized whether the observation has been initialized and the values are safe to use
function observations(uint256 index)
external
view
returns (
uint32 blockTimestamp,
int56 tickCumulative,
uint160 secondsPerLiquidityCumulativeX128,
bool initialized
);
}
// File contracts/Uniswap_V3/IUniswapV3Pool.sol
/// @title The interface for a Uniswap V3 Pool
/// @notice A Uniswap pool facilitates swapping and automated market making between any two assets that strictly conform
/// to the ERC20 specification
/// @dev The pool interface is broken up into many smaller pieces
interface IUniswapV3Pool is
IUniswapV3PoolImmutables,
IUniswapV3PoolState,
IUniswapV3PoolDerivedState,
IUniswapV3PoolActions,
IUniswapV3PoolOwnerActions,
IUniswapV3PoolEvents
{
}
// File contracts/Misc_AMOs/bunni/IBunniLens.sol
interface IBunniLens {
struct BunniKey {
IUniswapV3Pool pool;
int24 tickLower;
int24 tickUpper;
}
function getReserves (BunniKey calldata key) external view returns (uint112 reserve0, uint112 reserve1);
function hub () external view returns (address);
function pricePerFullShare (BunniKey calldata key) external view returns (uint128 liquidity, uint256 amount0, uint256 amount1);
}
// File contracts/Curve/ICurvefrxETHETHPool.sol
interface ICurvefrxETHETHPool {
function A() external view returns (uint256);
function A_precise() external view returns (uint256);
function get_p() external view returns (uint256);
function price_oracle() external view returns (uint256);
function get_virtual_price() external view returns (uint256);
function calc_token_amount(uint256[2] memory _amounts, bool _is_deposit) external view returns (uint256);
function add_liquidity(uint256[2] memory _amounts, uint256 _min_mint_amount) external returns (uint256);
function get_dy(int128 i, int128 j, uint256 _dx) external view returns (uint256);
function exchange(int128 i, int128 j, uint256 _dx, uint256 _min_dy) external payable returns (uint256);
function remove_liquidity(uint256 _amount, uint256[2] memory _min_amounts) external returns (uint256[2] memory);
function remove_liquidity_imbalance(uint256[2] memory _amounts, uint256 _max_burn_amount) external returns (uint256);
function calc_withdraw_one_coin(uint256 _token_amount, int128 i) external view returns (uint256);
function remove_liquidity_one_coin(uint256 _token_amount, int128 i, uint256 _min_amount) external returns (uint256);
function ramp_A(uint256 _future_A, uint256 _future_time) external;
function stop_ramp_A() external;
function commit_new_fee(uint256 _new_fee, uint256 _new_admin_fee) external;
function apply_new_fee() external;
function revert_new_parameters() external;
function set_ma_exp_time(uint256 _ma_exp_time) external;
function commit_transfer_ownership(address _owner) external;
function apply_transfer_ownership() external;
function revert_transfer_ownership() external;
function admin_balances(uint256 i) external view returns (uint256);
function withdraw_admin_fees() external;
function donate_admin_fees() external;
function kill_me() external;
function unkill_me() external;
function coins(uint256 arg0) external view returns (address);
function balances(uint256 arg0) external view returns (uint256);
function fee() external view returns (uint256);
function admin_fee() external view returns (uint256);
function owner() external view returns (address);
function lp_token() external view returns (address);
function initial_A() external view returns (uint256);
function future_A() external view returns (uint256);
function initial_A_time() external view returns (uint256);
function future_A_time() external view returns (uint256);
function admin_actions_deadline() external view returns (uint256);
function transfer_ownership_deadline() external view returns (uint256);
function future_fee() external view returns (uint256);
function future_admin_fee() external view returns (uint256);
function future_owner() external view returns (address);
function ma_exp_time() external view returns (uint256);
function ma_last_time() external view returns (uint256);
}
// File contracts/Misc_AMOs/bunni/IBunniGauge.sol
interface IBunniGauge {
function deposit ( uint256 _value ) external;
function deposit ( uint256 _value, address _addr ) external;
function deposit ( uint256 _value, address _addr, bool _claim_rewards ) external;
function withdraw ( uint256 _value ) external;
function withdraw ( uint256 _value, bool _claim_rewards ) external;
function claim_rewards ( ) external;
function claim_rewards ( address _addr ) external;
function claim_rewards ( address _addr, address _receiver ) external;
function transferFrom ( address _from, address _to, uint256 _value ) external returns ( bool );
function transfer ( address _to, uint256 _value ) external returns ( bool );
function approve ( address _spender, uint256 _value ) external returns ( bool );
function permit ( address _owner, address _spender, uint256 _value, uint256 _deadline, uint8 _v, bytes32 _r, bytes32 _s ) external returns ( bool );
function increaseAllowance ( address _spender, uint256 _added_value ) external returns ( bool );
function decreaseAllowance ( address _spender, uint256 _subtracted_value ) external returns ( bool );
function user_checkpoint ( address addr ) external returns ( bool );
function set_rewards_receiver ( address _receiver ) external;
function kick ( address addr ) external;
function deposit_reward_token ( address _reward_token, uint256 _amount ) external;
function add_reward ( address _reward_token, address _distributor ) external;
function set_reward_distributor ( address _reward_token, address _distributor ) external;
function makeGaugePermissionless ( ) external;
function killGauge ( ) external;
function unkillGauge ( ) external;
function change_pending_admin ( address new_pending_admin ) external;
function claim_admin ( ) external;
function set_tokenless_production ( uint8 new_tokenless_production ) external;
function claimed_reward ( address _addr, address _token ) external view returns ( uint256 );
function claimable_reward ( address _user, address _reward_token ) external view returns ( uint256 );
function claimable_tokens ( address addr ) external returns ( uint256 );
function integrate_checkpoint ( ) external view returns ( uint256 );
function future_epoch_time ( ) external view returns ( uint256 );
function inflation_rate ( ) external view returns ( uint256 );
function decimals ( ) external view returns ( uint256 );
function version ( ) external view returns ( string memory );
function allowance ( address owner, address spender ) external view returns ( uint256 );
function is_killed ( ) external view returns ( bool );
function initialize ( address _lp_token, uint256 relative_weight_cap, address _voting_escrow_delegation, address _admin, bytes32 _position_key ) external;
function setRelativeWeightCap ( uint256 relative_weight_cap ) external;
function getRelativeWeightCap ( ) external view returns ( uint256 );
function getCappedRelativeWeight ( uint256 time ) external view returns ( uint256 );
function getMaxRelativeWeightCap ( ) external pure returns ( uint256 );
function tokenless_production ( ) external view returns ( uint8 );
function pending_admin ( ) external view returns ( address );
function admin ( ) external view returns ( address );
function voting_escrow_delegation ( ) external view returns ( address );
function balanceOf ( address arg0 ) external view returns ( uint256 );
function totalSupply ( ) external view returns ( uint256 );
function name ( ) external view returns ( string memory );
function symbol ( ) external view returns ( string memory );
function DOMAIN_SEPARATOR ( ) external view returns ( bytes32 );
function nonces ( address arg0 ) external view returns ( uint256 );
function lp_token ( ) external view returns ( address );
function gauge_state ( ) external view returns ( uint8 );
function position_key ( ) external view returns ( bytes32 );
function reward_count ( ) external view returns ( uint256 );
// function reward_data ( address arg0 ) external view returns ( tuple );
function rewards_receiver ( address arg0 ) external view returns ( address );
function reward_integral_for ( address arg0, address arg1 ) external view returns ( uint256 );
function working_balances ( address arg0 ) external view returns ( uint256 );
function working_supply ( ) external view returns ( uint256 );
function integrate_inv_supply_of ( address arg0 ) external view returns ( uint256 );
function integrate_checkpoint_of ( address arg0 ) external view returns ( uint256 );
function integrate_fraction ( address arg0 ) external view returns ( uint256 );
function period ( ) external view returns ( int128 );
function reward_tokens ( uint256 arg0 ) external view returns ( address );
function period_timestamp ( uint256 arg0 ) external view returns ( uint256 );
function integrate_inv_supply ( uint256 arg0 ) external view returns ( uint256 );
}
// File contracts/Misc_AMOs/convex/IConvexStakingWrapperFrax.sol
interface IConvexStakingWrapperFrax {
function addRewards() external;
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
function collateralVault() external view returns (address);
function convexBooster() external view returns (address);
function convexPool() external view returns (address);
function convexPoolId() external view returns (uint256);
function convexToken() external view returns (address);
function crv() external view returns (address);
function curveToken() external view returns (address);
function cvx() external view returns (address);
function decimals() external view returns (uint8);
function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool);
function deposit(uint256 _amount, address _to) external;
// function earned(address _account) external view returns (tuple[] memory claimable);
function getReward(address _account, address _forwardTo) external;
function getReward(address _account) external;
function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
function initialize(address _curveToken, address _convexToken, address _convexPool, uint256 _poolId, address _vault) external;
function isInit() external view returns (bool);
function isShutdown() external view returns (bool);
function name() external view returns (string memory);
function owner() external view returns (address);
function registeredRewards(address) external view returns (uint256);
function renounceOwnership() external;
function rewardLength() external view returns (uint256);
function rewards(uint256) external view returns (address reward_token, address reward_pool, uint128 reward_integral, uint128 reward_remaining);
function setApprovals() external;
function setVault(address _vault) external;
function shutdown() external;
function stake(uint256 _amount, address _to) external;
function symbol() external view returns (string memory);
function totalBalanceOf(address _account) external view returns (uint256);
function totalSupply() external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function transferOwnership(address newOwner) external;
function user_checkpoint(address _account) external returns (bool);
function user_checkpoint(address[2] memory _accounts) external returns (bool);
function withdraw(uint256 _amount) external;
function withdrawAndUnwrap(uint256 _amount) external;
}
// File contracts/Misc_AMOs/curve/I2pool.sol
interface I2pool {
function decimals() external view returns (uint256);
function transfer(address _to, uint256 _value) external returns (bool);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool);
function approve(address _spender, uint256 _value) external returns (bool);
function A() external view returns (uint256);
function A_precise() external view returns (uint256);
function get_virtual_price() external view returns (uint256);
function lp_price() external view returns (uint256);
function price_oracle() external view returns (uint256);
function calc_token_amount(uint256[2] memory _amounts, bool _is_deposit) external view returns (uint256);
function add_liquidity(uint256[2] memory _amounts, uint256 _min_mint_amount) external returns (uint256);
function get_dy(int128 i, int128 j, uint256 _dx) external view returns (uint256);
function exchange(int128 i, int128 j, uint256 _dx, uint256 _min_dy) external returns (uint256);
function remove_liquidity(uint256 _amount, uint256[2] memory _min_amounts) external returns (uint256[2] memory);
function remove_liquidity_imbalance(uint256[2] memory _amounts, uint256 _max_burn_amount) external returns (uint256);
function calc_withdraw_one_coin(uint256 _token_amount, int128 i) external view returns (uint256);
function remove_liquidity_one_coin(uint256 _token_amount, int128 i, uint256 _min_amount) external returns (uint256);
function ramp_A(uint256 _future_A, uint256 _future_time) external;
function stop_ramp_A() external;
function commit_new_fee(uint256 _new_fee, uint256 _new_admin_fee) external;
function apply_new_fee() external;
function revert_new_parameters() external;
function commit_transfer_ownership(address _owner) external;
function apply_transfer_ownership() external;
function revert_transfer_ownership() external;
function admin_balances(uint256 i) external view returns (uint256);
function withdraw_admin_fees() external;
function donate_admin_fees() external;
function kill_me() external;
function unkill_me() external;
function coins(uint256 arg0) external view returns (address);
function balances(uint256 arg0) external view returns (uint256);
function fee() external view returns (uint256);
function admin_fee() external view returns (uint256);
function owner() external view returns (address);
function initial_A() external view returns (uint256);
function future_A() external view returns (uint256);
function initial_A_time() external view returns (uint256);
function future_A_time() external view returns (uint256);
function admin_actions_deadline() external view returns (uint256);
function transfer_ownership_deadline() external view returns (uint256);
function future_fee() external view returns (uint256);
function future_admin_fee() external view returns (uint256);
function future_owner() external view returns (address);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function balanceOf(address arg0) external view returns (uint256);
function allowance(address arg0, address arg1) external view returns (uint256);
function totalSupply() external view returns (uint256);
}
// File contracts/Misc_AMOs/curve/I2poolToken.sol
interface I2poolToken {
function decimals() external view returns (uint256);
function transfer(address _to, uint256 _value) external returns (bool);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool);
function approve(address _spender, uint256 _value) external returns (bool);
function increaseAllowance(address _spender, uint256 _added_value) external returns (bool);
function decreaseAllowance(address _spender, uint256 _subtracted_value) external returns (bool);
function mint(address _to, uint256 _value) external returns (bool);
function burnFrom(address _to, uint256 _value) external returns (bool);
function set_minter(address _minter) external;
function set_name(string memory _name, string memory _symbol) external;
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function balanceOf(address arg0) external view returns (uint256);
function allowance(address arg0, address arg1) external view returns (uint256);
function totalSupply() external view returns (uint256);
function minter() external view returns (address);
}
// File contracts/Curve/IFraxGaugeController.sol
// https://github.com/swervefi/swerve/edit/master/packages/swerve-contracts/interfaces/IGaugeController.sol
interface IFraxGaugeController {
struct Point {
uint256 bias;
uint256 slope;
}
struct VotedSlope {
uint256 slope;
uint256 power;
uint256 end;
}
// Public variables
function admin() external view returns (address);
function future_admin() external view returns (address);
function token() external view returns (address);
function voting_escrow() external view returns (address);
function n_gauge_types() external view returns (int128);
function n_gauges() external view returns (int128);
function gauge_type_names(int128) external view returns (string memory);
function gauges(uint256) external view returns (address);
function vote_user_slopes(address, address)
external
view
returns (VotedSlope memory);
function vote_user_power(address) external view returns (uint256);
function last_user_vote(address, address) external view returns (uint256);
function points_weight(address, uint256)
external
view
returns (Point memory);
function time_weight(address) external view returns (uint256);
function points_sum(int128, uint256) external view returns (Point memory);
function time_sum(uint256) external view returns (uint256);
function points_total(uint256) external view returns (uint256);
function time_total() external view returns (uint256);
function points_type_weight(int128, uint256)
external
view
returns (uint256);
function time_type_weight(uint256) external view returns (uint256);
// Getter functions
function gauge_types(address) external view returns (int128);
function gauge_relative_weight(address) external view returns (uint256);
function gauge_relative_weight(address, uint256) external view returns (uint256);
function get_gauge_weight(address) external view returns (uint256);
function get_type_weight(int128) external view returns (uint256);
function get_total_weight() external view returns (uint256);
function get_weights_sum_per_type(int128) external view returns (uint256);
// External functions
function commit_transfer_ownership(address) external;
function apply_transfer_ownership() external;
function add_gauge(
address,
int128,
uint256
) external;
function checkpoint() external;
function checkpoint_gauge(address) external;
function global_emission_rate() external view returns (uint256);
function gauge_relative_weight_write(address)
external
returns (uint256);
function gauge_relative_weight_write(address, uint256)
external
returns (uint256);
function add_type(string memory, uint256) external;
function change_type_weight(int128, uint256) external;
function change_gauge_weight(address, uint256) external;
function change_global_emission_rate(uint256) external;
function vote_for_gauge_weights(address, uint256) external;
}
// File contracts/Curve/IFraxGaugeFXSRewardsDistributor.sol
interface IFraxGaugeFXSRewardsDistributor {
function acceptOwnership() external;
function curator_address() external view returns(address);
function currentReward(address gauge_address) external view returns(uint256 reward_amount);
function distributeReward(address gauge_address) external returns(uint256 weeks_elapsed, uint256 reward_tally);
function distributionsOn() external view returns(bool);
function gauge_whitelist(address) external view returns(bool);
function is_middleman(address) external view returns(bool);
function last_time_gauge_paid(address) external view returns(uint256);
function nominateNewOwner(address _owner) external;
function nominatedOwner() external view returns(address);
function owner() external view returns(address);
function recoverERC20(address tokenAddress, uint256 tokenAmount) external;
function setCurator(address _new_curator_address) external;
function setGaugeController(address _gauge_controller_address) external;
function setGaugeState(address _gauge_address, bool _is_middleman, bool _is_active) external;
function setTimelock(address _new_timelock) external;
function timelock_address() external view returns(address);
function toggleDistributions() external;
}
// File contracts/Curve/IveFXS.sol
interface IveFXS {
struct LockedBalance {
int128 amount;
uint256 end;
}
function commit_transfer_ownership(address addr) external;
function apply_transfer_ownership() external;
function commit_smart_wallet_checker(address addr) external;
function apply_smart_wallet_checker() external;
function toggleEmergencyUnlock() external;
function recoverERC20(address token_addr, uint256 amount) external;
function get_last_user_slope(address addr) external view returns (int128);
function user_point_history__ts(address _addr, uint256 _idx) external view returns (uint256);
function locked__end(address _addr) external view returns (uint256);
function checkpoint() external;
function deposit_for(address _addr, uint256 _value) external;
function create_lock(uint256 _value, uint256 _unlock_time) external;
function increase_amount(uint256 _value) external;
function increase_unlock_time(uint256 _unlock_time) external;
function withdraw() external;
function balanceOf(address addr) external view returns (uint256);
function balanceOf(address addr, uint256 _t) external view returns (uint256);
function balanceOfAt(address addr, uint256 _block) external view returns (uint256);
function totalSupply() external view returns (uint256);
function totalSupply(uint256 t) external view returns (uint256);
function totalSupplyAt(uint256 _block) external view returns (uint256);
function totalFXSSupply() external view returns (uint256);
function totalFXSSupplyAt(uint256 _block) external view returns (uint256);
function changeController(address _newController) external;
function token() external view returns (address);
function supply() external view returns (uint256);
function locked(address addr) external view returns (LockedBalance memory);
function epoch() external view returns (uint256);
function point_history(uint256 arg0) external view returns (int128 bias, int128 slope, uint256 ts, uint256 blk, uint256 fxs_amt);
function user_point_history(address arg0, uint256 arg1) external view returns (int128 bias, int128 slope, uint256 ts, uint256 blk, uint256 fxs_amt);
function user_point_epoch(address arg0) external view returns (uint256);
function slope_changes(uint256 arg0) external view returns (int128);
function controller() external view returns (address);
function transfersEnabled() external view returns (bool);
function emergencyUnlockActive() external view returns (bool);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function version() external view returns (string memory);
function decimals() external view returns (uint256);
function future_smart_wallet_checker() external view returns (address);
function smart_wallet_checker() external view returns (address);
function admin() external view returns (address);
function future_admin() external view returns (address);
}
// File contracts/Math/Math.sol
/**
* @dev Standard math utilities missing in the Solidity language.
*/
library Math {
/**
* @dev Returns the largest of two numbers.
*/
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
/**
* @dev Returns the smallest of two numbers.
*/
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
/**
* @dev Returns the average of two numbers. The result is rounded towards
* zero.
*/
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow, so we distribute
return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
}
// babylonian method (https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method)
function sqrt(uint y) internal pure returns (uint z) {
if (y > 3) {
z = y;
uint x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
// File contracts/Misc_AMOs/bunni/IBunniMinter.sol
interface IBunniMinter {
function allowed_to_mint_for ( address minter, address user ) external view returns ( bool );
function getGaugeController ( ) external view returns ( address );
function getMinterApproval ( address minter, address user ) external view returns ( bool );
function getToken ( ) external view returns ( address );
function getTokenAdmin ( ) external view returns ( address );
function mint ( address gauge ) external returns ( uint256 );
function mintFor ( address gauge, address user ) external returns ( uint256 );
function mintMany ( address[] memory gauges ) external returns ( uint256 );
function mintManyFor ( address[] memory gauges, address user ) external returns ( uint256 );
function mint_for ( address gauge, address user ) external;
function mint_many ( address[8] memory gauges ) external;
function minted ( address user, address gauge ) external view returns ( uint256 );
function setMinterApproval ( address minter, bool approval ) external;
function toggle_approve_mint ( address minter ) external;
}
// File contracts/Staking/Owned.sol
// https://docs.synthetix.io/contracts/Owned
contract Owned {
address public owner;
address public nominatedOwner;
constructor (address _owner) public {
require(_owner != address(0), "Owner address cannot be 0");
owner = _owner;
emit OwnerChanged(address(0), _owner);
}
function nominateNewOwner(address _owner) external onlyOwner {
nominatedOwner = _owner;
emit OwnerNominated(_owner);
}
function acceptOwnership() external {
require(msg.sender == nominatedOwner, "You must be nominated before you can accept ownership");
emit OwnerChanged(owner, nominatedOwner);
owner = nominatedOwner;
nominatedOwner = address(0);
}
modifier onlyOwner {
require(msg.sender == owner, "Only the contract owner may perform this action");
_;
}
event OwnerNominated(address newOwner);
event OwnerChanged(address oldOwner, address newOwner);
}
// File contracts/Uniswap/TransferHelper.sol
// helper methods for interacting with ERC20 tokens and sending ETH that do not consistently return true/false
library TransferHelper {
function safeApprove(address token, address to, uint value) internal {
// bytes4(keccak256(bytes('approve(address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: APPROVE_FAILED');
}
function safeTransfer(address token, address to, uint value) internal {
// bytes4(keccak256(bytes('transfer(address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FAILED');
}
function safeTransferFrom(address token, address from, address to, uint value) internal {
// bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FROM_FAILED');
}
function safeTransferETH(address to, uint value) internal {
(bool success,) = to.call{value:value}(new bytes(0));
require(success, 'TransferHelper: ETH_TRANSFER_FAILED');
}
}
// File contracts/Utils/ReentrancyGuard.sol
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor () internal {
_status = _NOT_ENTERED;
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and make it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
}
// File contracts/Staking/FraxUnifiedFarmTemplate.sol
// ====================================================================
// | ______ _______ |
// | / _____________ __ __ / ____(_____ ____ _____ ________ |
// | / /_ / ___/ __ `| |/_/ / /_ / / __ \/ __ `/ __ \/ ___/ _ \ |
// | / __/ / / / /_/ _> < / __/ / / / / / /_/ / / / / /__/ __/ |
// | /_/ /_/ \__,_/_/|_| /_/ /_/_/ /_/\__,_/_/ /_/\___/\___/ |
// | |
// ====================================================================
// ====================== FraxUnifiedFarmTemplate =====================
// ====================================================================
// Farming contract that accounts for veFXS
// Overrideable for UniV3, ERC20s, etc
// New for V2
// - Multiple reward tokens possible
// - Can add to existing locked stakes
// - Contract is aware of proxied veFXS
// - veFXS multiplier formula changed
// Apes together strong
// Frax Finance: https://github.com/FraxFinance
// Primary Author(s)
// Travis Moore: https://github.com/FortisFortuna
// Reviewer(s) / Contributor(s)
// Jason Huan: https://github.com/jasonhuan
// Sam Kazemian: https://github.com/samkazemian
// Dennis: github.com/denett
// Originally inspired by Synthetix.io, but heavily modified by the Frax team
// (Locked, veFXS, and UniV3 portions are new)
// https://raw.githubusercontent.com/Synthetixio/synthetix/develop/contracts/StakingRewards.sol
// Extra rewards
// import "../Misc_AMOs/convex/IConvexBaseRewardPool.sol";
contract FraxUnifiedFarmTemplate is Owned, ReentrancyGuard {
// -------------------- VARIES --------------------
// // Bunni
// IBunniGauge public stakingToken;
// IBunniLens public lens = IBunniLens(0xb73F303472C4fD4FF3B9f59ce0F9b13E47fbfD19);
// IBunniMinter public minter = IBunniMinter(0xF087521Ffca0Fa8A43F5C445773aB37C5f574DA0);
/* ========== STATE VARIABLES ========== */
// Instances
IveFXS private constant veFXS = IveFXS(0xc8418aF6358FFddA74e09Ca9CC3Fe03Ca6aDC5b0);
// Frax related
address internal constant frax_address = 0x853d955aCEf822Db058eb8505911ED77F175b99e;
/// @notice fraxPerLPToken is a public view function, although doesn't show the stored value
uint256 public fraxPerLPStored;
// Constant for various precisions
uint256 internal constant MULTIPLIER_PRECISION = 1e18;
// Time tracking
/// @notice Ending timestamp for the current period
uint256 public periodFinish;
/// @notice Timestamp of the last update - when this period started
uint256 public lastUpdateTime;
// Lock time and multiplier settings
uint256 public lock_max_multiplier = uint256(2e18); // E18. 1x = e18
uint256 public lock_time_for_max_multiplier = 1 * 1095 * 86400; // 3 years
// uint256 public lock_time_for_max_multiplier = 2 * 86400; // 2 days
uint256 public lock_time_min = 594000; // 6.875 * 86400 (~7 day)
// veFXS related
uint256 public vefxs_boost_scale_factor = uint256(4e18); // E18. 4x = 4e18; 100 / scale_factor = % vefxs supply needed for max boost
uint256 public vefxs_max_multiplier = uint256(2e18); // E18. 1x = 1e18
uint256 public vefxs_per_frax_for_max_boost = uint256(4e18); // E18. 2e18 means 2 veFXS must be held by the staker per 1 FRAX
mapping(address => uint256) internal _vefxsMultiplierStored;
mapping(address => bool) internal valid_vefxs_proxies;
mapping(address => mapping(address => bool)) internal proxy_allowed_stakers;
// Reward addresses, gauge addresses, reward rates, and reward managers
/// @notice token addr -> manager addr
mapping(address => address) public rewardManagers;
address[] internal rewardTokens;
address[] internal gaugeControllers;
address[] internal rewardDistributors;
uint256[] internal rewardRatesManual;
mapping(address => bool) internal isRewardToken;
/// @notice token addr -> token index
mapping(address => uint256) public rewardTokenAddrToIdx;
// Reward period
uint256 public constant rewardsDuration = 604800; // 7 * 86400 (7 days)
// Reward tracking
uint256[] private rewardsPerTokenStored;
mapping(address => mapping(uint256 => uint256)) private userRewardsPerTokenPaid; // staker addr -> token id -> paid amount
mapping(address => mapping(uint256 => uint256)) private rewards; // staker addr -> token id -> reward amount
mapping(address => uint256) public lastRewardClaimTime; // staker addr -> timestamp
// Gauge tracking
uint256[] private last_gauge_relative_weights;
uint256[] private last_gauge_time_totals;
// Balance tracking
uint256 internal _total_liquidity_locked;
uint256 internal _total_combined_weight;
mapping(address => uint256) internal _locked_liquidity;
mapping(address => uint256) internal _combined_weights;
/// @notice Keeps track of LP balances proxy-wide. Needed to make sure the proxy boost is kept in line
mapping(address => uint256) public proxy_lp_balances;
/// @notice Stakers set which proxy(s) they want to use
/// @dev Keep public so users can see on the frontend if they have a proxy
mapping(address => address) public staker_designated_proxies;
// Admin booleans for emergencies and overrides
bool public stakesUnlocked; // Release locked stakes in case of emergency
bool internal withdrawalsPaused; // For emergencies
bool internal rewardsCollectionPaused; // For emergencies
bool internal stakingPaused; // For emergencies
bool internal collectRewardsOnWithdrawalPaused; // For emergencies if a token is overemitted
/* ========== STRUCTS ========== */
// In children...
/* ========== MODIFIERS ========== */
modifier onlyByOwnGov() {
require(msg.sender == owner || msg.sender == 0x8412ebf45bAC1B340BbE8F318b928C466c4E39CA, "Not owner or timelock");
_;
}
modifier onlyTknMgrs(address reward_token_address) {
require(msg.sender == owner || isTokenManagerFor(msg.sender, reward_token_address), "Not owner or tkn mgr");
_;
}
modifier updateRewardAndBalanceMdf(address account, bool sync_too) {
_updateRewardAndBalance(account, sync_too, false);
_;
}
/* ========== CONSTRUCTOR ========== */
constructor (
address _owner,
address[] memory _rewardTokens,
address[] memory _rewardManagers,
uint256[] memory _rewardRatesManual,
address[] memory _gaugeControllers,
address[] memory _rewardDistributors
) Owned(_owner) {
// Address arrays
rewardTokens = _rewardTokens;
gaugeControllers = _gaugeControllers;
rewardDistributors = _rewardDistributors;
rewardRatesManual = _rewardRatesManual;
for (uint256 i = 0; i < _rewardTokens.length; i++){
// For fast token address -> token ID lookups later
rewardTokenAddrToIdx[_rewardTokens[i]] = i;
// Add to the mapping
isRewardToken[_rewardTokens[i]] = true;
// Initialize the stored rewards
rewardsPerTokenStored.push(0);
// Initialize the reward managers
rewardManagers[_rewardTokens[i]] = _rewardManagers[i];
// Push in empty relative weights to initialize the array
last_gauge_relative_weights.push(0);
// Push in empty time totals to initialize the array
last_gauge_time_totals.push(0);
}
// Other booleans
stakesUnlocked = false;
// Initialization
lastUpdateTime = block.timestamp;
// Sync the first period finish here with the gauge's
// periodFinish = IFraxGaugeController(gaugeControllers[0]).time_total();
periodFinish = IFraxGaugeController(0x3669C421b77340B2979d1A00a792CC2ee0FcE737).time_total();
}
/* ============= VIEWS ============= */
// ------ REWARD RELATED ------
/// @notice Checks if the caller is a manager for the reward token
/// @param caller_addr The address of the caller
/// @param reward_token_addr The address of the reward token
/// @return bool True if the caller is a manager for the reward token
function isTokenManagerFor(address caller_addr, address reward_token_addr) public view returns (bool){
if (!isRewardToken[reward_token_addr]) return false;
else if (caller_addr == address(0) || reward_token_addr == address(0)) return false;
else if (caller_addr == owner) return true; // Contract owner
else if (rewardManagers[reward_token_addr] == caller_addr) return true; // Reward manager
return false;
}
/// @notice Gets all the reward tokens this contract handles
/// @return rewardTokens_ The reward tokens array
function getAllRewardTokens() external view returns (address[] memory) {
return rewardTokens;
}
// Last time the reward was applicable
function lastTimeRewardApplicable() internal view returns (uint256) {
return Math.min(block.timestamp, periodFinish);
}
/// @notice The amount of reward tokens being paid out per second this period
/// @param token_idx The index of the reward token
/// @return rwd_rate The reward rate
function rewardRates(uint256 token_idx) public view returns (uint256 rwd_rate) {
address gauge_controller_address = gaugeControllers[token_idx];
if (gauge_controller_address != address(0)) {
rwd_rate = (IFraxGaugeController(gauge_controller_address).global_emission_rate() * last_gauge_relative_weights[token_idx]) / 1e18;
}
else {
rwd_rate = rewardRatesManual[token_idx];
}
}
// Amount of reward tokens per LP token / liquidity unit
function rewardsPerToken() public view returns (uint256[] memory newRewardsPerTokenStored) {
if (_total_liquidity_locked == 0 || _total_combined_weight == 0) {
return rewardsPerTokenStored;
}
else {
newRewardsPerTokenStored = new uint256[](rewardTokens.length);
for (uint256 i = 0; i < rewardsPerTokenStored.length; i++){
newRewardsPerTokenStored[i] = rewardsPerTokenStored[i] + (
((lastTimeRewardApplicable() - lastUpdateTime) * rewardRates(i) * 1e18) / _total_combined_weight
);
}
return newRewardsPerTokenStored;
}
}
/// @notice The amount of reward tokens an account has earned / accrued
/// @dev In the edge-case of one of the account's stake expiring since the last claim, this will
/// @param account The account to check
/// @return new_earned Array of reward token amounts earned by the account
function earned(address account) public view returns (uint256[] memory new_earned) {
uint256[] memory reward_arr = rewardsPerToken();
new_earned = new uint256[](rewardTokens.length);
if (_combined_weights[account] > 0){
for (uint256 i = 0; i < rewardTokens.length; i++){
new_earned[i] = ((_combined_weights[account] * (reward_arr[i] - userRewardsPerTokenPaid[account][i])) / 1e18)
+ rewards[account][i];
}
}
}
/// @notice The total reward tokens emitted in the given period
/// @return rewards_per_duration_arr Array of reward token amounts emitted in the current period
function getRewardForDuration() external view returns (uint256[] memory rewards_per_duration_arr) {
rewards_per_duration_arr = new uint256[](rewardRatesManual.length);
for (uint256 i = 0; i < rewardRatesManual.length; i++){
rewards_per_duration_arr[i] = rewardRates(i) * rewardsDuration;
}
}
// ------ LIQUIDITY AND WEIGHTS ------
/// @notice The farm's total locked liquidity / LP tokens
/// @return The total locked liquidity
function totalLiquidityLocked() external view returns (uint256) {
return _total_liquidity_locked;
}
/// @notice A user's locked liquidity / LP tokens
/// @param account The address of the account
/// @return The locked liquidity
function lockedLiquidityOf(address account) external view returns (uint256) {
return _locked_liquidity[account];
}
/// @notice The farm's total combined weight of all users
/// @return The total combined weight
function totalCombinedWeight() external view returns (uint256) {
return _total_combined_weight;
}
/// @notice Total 'balance' used for calculating the percent of the pool the account owns
/// @notice Takes into account the locked stake time multiplier and veFXS multiplier
/// @param account The address of the account
/// @return The combined weight
function combinedWeightOf(address account) external view returns (uint256) {
return _combined_weights[account];
}
/// @notice Calculates the combined weight for an account
/// @notice Must be overriden by the child contract
/// @dev account The address of the account
function calcCurCombinedWeight(address account) public virtual view
returns (
uint256 old_combined_weight,
uint256 new_vefxs_multiplier,
uint256 new_combined_weight
)
{
revert("Need cCCW logic");
}
// ------ LOCK RELATED ------
/// @notice Reads the lock boost multiplier for a given duration
/// @param secs The duration of the lock in seconds
/// @return The multiplier amount
function lockMultiplier(uint256 secs) public view returns (uint256) {
return Math.min(
lock_max_multiplier,
(secs * lock_max_multiplier) / lock_time_for_max_multiplier
) ;
}
// ------ FRAX RELATED ------
/// @notice The amount of FRAX denominated value being boosted that an address has staked
/// @param account The address to check
/// @return The amount of FRAX value boosted
function userStakedFrax(address account) public view returns (uint256) {
return (fraxPerLPStored * _locked_liquidity[account]) / MULTIPLIER_PRECISION;
}
/// @notice The amount of FRAX denominated value being boosted that a proxy address has staked
/// @param proxy_address The address to check
/// @return The amount of FRAX value boosted
function proxyStakedFrax(address proxy_address) public view returns (uint256) {
return (fraxPerLPStored * proxy_lp_balances[proxy_address]) / MULTIPLIER_PRECISION;
}
/// @notice The maximum LP that can get max veFXS boosted for a given address at its current veFXS balance
/// @param account The address to check
/// @return The maximum LP that can get max veFXS boosted for a given address at its current veFXS balance
function maxLPForMaxBoost(address account) external view returns (uint256) {
return (veFXS.balanceOf(account) * MULTIPLIER_PRECISION * MULTIPLIER_PRECISION) / (vefxs_per_frax_for_max_boost * fraxPerLPStored);
}
/// @notice Must be overriden to return the current FRAX per LP token
/// @return The current number of FRAX per LP token
function fraxPerLPToken() public virtual view returns (uint256) {
revert("Need fPLPT logic");
}
// ------ veFXS RELATED ------
/// @notice The minimum veFXS required to get max boost for a given address
/// @param account The address to check
/// @return The minimum veFXS required to get max boost
function minVeFXSForMaxBoost(address account) public view returns (uint256) {
return (userStakedFrax(account) * vefxs_per_frax_for_max_boost) / MULTIPLIER_PRECISION;
}
/// @notice The minimum veFXS required to get max boost for a given proxy
/// @param proxy_address The proxy address
/// @return The minimum veFXS required to get max boost
function minVeFXSForMaxBoostProxy(address proxy_address) public view returns (uint256) {
return (proxyStakedFrax(proxy_address) * vefxs_per_frax_for_max_boost) / MULTIPLIER_PRECISION;
}
/// @notice Looks up a staker's proxy
/// @param addr The address to check
/// @return the_proxy The proxy address, or address(0)
function getProxyFor(address addr) public view returns (address){
if (valid_vefxs_proxies[addr]) {
// If addr itself is a proxy, return that.
// If it farms itself directly, it should use the shared LP tally in proxyStakedFrax
return addr;
}
else {
// Otherwise, return the proxy, or address(0)
return staker_designated_proxies[addr];
}
}
/// @notice The multiplier for a given account, based on veFXS
/// @param account The account to check
/// @return vefxs_multiplier The multiplier boost for the account
function veFXSMultiplier(address account) public view returns (uint256 vefxs_multiplier) {
// Use either the user's or their proxy's veFXS balance
uint256 vefxs_bal_to_use = 0;
address the_proxy = getProxyFor(account);
vefxs_bal_to_use = (the_proxy == address(0)) ? veFXS.balanceOf(account) : veFXS.balanceOf(the_proxy);
// First option based on fraction of total veFXS supply, with an added scale factor
uint256 mult_optn_1 = (vefxs_bal_to_use * vefxs_max_multiplier * vefxs_boost_scale_factor)
/ (veFXS.totalSupply() * MULTIPLIER_PRECISION);
// Second based on old method, where the amount of FRAX staked comes into play
uint256 mult_optn_2;
{
uint256 veFXS_needed_for_max_boost;
// Need to use proxy-wide FRAX balance if applicable, to prevent exploiting
veFXS_needed_for_max_boost = (the_proxy == address(0)) ? minVeFXSForMaxBoost(account) : minVeFXSForMaxBoostProxy(the_proxy);
if (veFXS_needed_for_max_boost > 0){
uint256 user_vefxs_fraction = (vefxs_bal_to_use * MULTIPLIER_PRECISION) / veFXS_needed_for_max_boost;
mult_optn_2 = (user_vefxs_fraction * vefxs_max_multiplier) / MULTIPLIER_PRECISION;
}
else mult_optn_2 = 0; // This will happen with the first stake, when user_staked_frax is 0
}
// Select the higher of the two
vefxs_multiplier = (mult_optn_1 > mult_optn_2 ? mult_optn_1 : mult_optn_2);
// Cap the boost to the vefxs_max_multiplier
if (vefxs_multiplier > vefxs_max_multiplier) vefxs_multiplier = vefxs_max_multiplier;
}
/* =============== MUTATIVE FUNCTIONS =============== */
/// @notice Toggle whether a staker can use the proxy's veFXS balance to boost yields
/// @notice Proxy must call this first, then the staker must call stakerSetVeFXSProxy
function proxyToggleStaker(address staker_address) external {
require(valid_vefxs_proxies[msg.sender], "Invalid proxy");
proxy_allowed_stakers[msg.sender][staker_address] = !proxy_allowed_stakers[msg.sender][staker_address];
// Disable the staker's set proxy if it was the toggler and is currently on
if (staker_designated_proxies[staker_address] == msg.sender){
staker_designated_proxies[staker_address] = address(0);
// Remove the LP as well
proxy_lp_balances[msg.sender] -= _locked_liquidity[staker_address];
}
}
/// @notice After proxy toggles staker to true, staker must call and confirm this
/// @param proxy_address The address of the veFXS proxy
function stakerSetVeFXSProxy(address proxy_address) external {
require(valid_vefxs_proxies[proxy_address], "Invalid proxy");
require(proxy_allowed_stakers[proxy_address][msg.sender], "Proxy has not allowed you yet");
// Corner case sanity check to make sure LP isn't double counted
address old_proxy_addr = staker_designated_proxies[msg.sender];
if (old_proxy_addr != address(0)) {
// Remove the LP count from the old proxy
proxy_lp_balances[old_proxy_addr] -= _locked_liquidity[msg.sender];
}
// Set the new proxy
staker_designated_proxies[msg.sender] = proxy_address;
// Add the the LP as well
proxy_lp_balances[proxy_address] += _locked_liquidity[msg.sender];
}
// ------ STAKING ------
// In children...
// ------ WITHDRAWING ------
// In children...
// ------ REWARDS SYNCING ------
function _updateRewardAndBalance(address account, bool sync_too) internal {
_updateRewardAndBalance(account, sync_too, false);
}
function _updateRewardAndBalance(address account, bool sync_too, bool pre_sync_vemxstored) internal {
// Need to retro-adjust some things if the period hasn't been renewed, then start a new one
if (sync_too){
sync();
}
// Used to make sure the veFXS multiplier is correct if a stake is increased, before calcCurCombinedWeight
if (pre_sync_vemxstored){
_vefxsMultiplierStored[account] = veFXSMultiplier(account);
}
if (account != address(0)) {
// To keep the math correct, the user's combined weight must be recomputed to account for their
// ever-changing veFXS balance.
(
uint256 old_combined_weight,
uint256 new_vefxs_multiplier,
uint256 new_combined_weight
) = calcCurCombinedWeight(account);
// Calculate the earnings first
_syncEarned(account);
// Update the user's stored veFXS multipliers
_vefxsMultiplierStored[account] = new_vefxs_multiplier;
// Update the user's and the global combined weights
if (new_combined_weight >= old_combined_weight) {
uint256 weight_diff = new_combined_weight - old_combined_weight;
_total_combined_weight = _total_combined_weight + weight_diff;
_combined_weights[account] = old_combined_weight + weight_diff;
} else {
uint256 weight_diff = old_combined_weight - new_combined_weight;
_total_combined_weight = _total_combined_weight - weight_diff;
_combined_weights[account] = old_combined_weight - weight_diff;
}
}
}
function _syncEarned(address account) internal {
if (account != address(0)) {
// Calculate the earnings
uint256[] memory earned_arr = earned(account);
// Update the rewards array
for (uint256 i = 0; i < earned_arr.length; i++){
rewards[account][i] = earned_arr[i];
}
// Update the rewards paid array
for (uint256 i = 0; i < earned_arr.length; i++){
userRewardsPerTokenPaid[account][i] = rewardsPerTokenStored[i];
}
}
}
// ------ REWARDS CLAIMING ------
/// @notice A function that can be overridden to add extra logic to the getReward function
/// @param destination_address The address to send the rewards to
function getRewardExtraLogic(address destination_address) public nonReentrant {
require(rewardsCollectionPaused == false, "Rewards collection paused");
return _getRewardExtraLogic(msg.sender, destination_address);
}
function _getRewardExtraLogic(address rewardee, address destination_address) internal virtual {
revert("Need gREL logic");
}
// Two different getReward functions are needed because of delegateCall and msg.sender issues
// For backwards-compatibility
/// @notice Claims rewards to destination address
/// @param destination_address The address to send the rewards to
/// @return rewards_before The rewards available before the claim
function getReward(address destination_address) external nonReentrant returns (uint256[] memory) {
return _getReward(msg.sender, destination_address, true);
}
/// @notice Claims rewards to destination address & wether to do extra logic
/// @param destination_address The address to send the rewards to
/// @param claim_extra_too Whether to do extra logic
/// @return rewards_before The rewards available before the claim
function getReward2(address destination_address, bool claim_extra_too) external nonReentrant returns (uint256[] memory) {
return _getReward(msg.sender, destination_address, claim_extra_too);
}
// No withdrawer == msg.sender check needed since this is only internally callable
function _getReward(address rewardee, address destination_address, bool do_extra_logic) internal updateRewardAndBalanceMdf(rewardee, true) returns (uint256[] memory rewards_before) {
// Update the last reward claim time first, as an extra reentrancy safeguard
lastRewardClaimTime[rewardee] = block.timestamp;
// Make sure rewards collection isn't paused
require(rewardsCollectionPaused == false, "Rewards collection paused");
// Update the rewards array and distribute rewards
rewards_before = new uint256[](rewardTokens.length);
for (uint256 i = 0; i < rewardTokens.length; i++){
rewards_before[i] = rewards[rewardee][i];
rewards[rewardee][i] = 0;
if (rewards_before[i] > 0) {
TransferHelper.safeTransfer(rewardTokens[i], destination_address, rewards_before[i]);
emit RewardPaid(rewardee, rewards_before[i], rewardTokens[i], destination_address);
}
}
// Handle additional reward logic
if (do_extra_logic) {
_getRewardExtraLogic(rewardee, destination_address);
}
}
// ------ FARM SYNCING ------
// If the period expired, renew it
function retroCatchUp() internal {
// Catch up the old rewards first
_updateStoredRewardsAndTime();
// Pull in rewards from the rewards distributor, if applicable
for (uint256 i = 0; i < rewardDistributors.length; i++){
address reward_distributor_address = rewardDistributors[i];
if (reward_distributor_address != address(0)) {
IFraxGaugeFXSRewardsDistributor(reward_distributor_address).distributeReward(address(this));
}
}
// Ensure the provided reward amount is not more than the balance in the contract.
// This keeps the reward rate in the right range, preventing overflows due to
// very high values of rewardRate in the earned and rewardsPerToken functions;
// Reward + leftover must be less than 2^256 / 10^18 to avoid overflow.
uint256 num_periods_elapsed = uint256(block.timestamp - periodFinish) / rewardsDuration; // Floor division to the nearest period
// Make sure there are enough tokens to renew the reward period
for (uint256 i = 0; i < rewardTokens.length; i++){
require((rewardRates(i) * rewardsDuration * (num_periods_elapsed + 1)) <= IERC20(rewardTokens[i]).balanceOf(address(this)), string(abi.encodePacked("Not enough reward tokens available: ", rewardTokens[i])) );
}
// uint256 old_lastUpdateTime = lastUpdateTime;
// uint256 new_lastUpdateTime = block.timestamp;
// lastUpdateTime = periodFinish;
periodFinish = periodFinish + ((num_periods_elapsed + 1) * rewardsDuration);
// // Bunni oLIT rewards
// // ==========================================
// // Pull in rewards and set the reward rate for one week, based off of that
// // If the rewards get messed up for some reason, set this to 0 and it will skip
// // Should only be called once per week max
// if (rewardRatesManual[1] != 0) {
// // oLIT
// // ====================================
// uint256 olit_before = IERC20(rewardTokens[1]).balanceOf(address(this));
// minter.mint(address(stakingToken));
// uint256 olit_after = IERC20(rewardTokens[1]).balanceOf(address(this));
// // Set the new reward rate
// rewardRatesManual[1] = (olit_after - olit_before) / rewardsDuration;
// }
// CONVEX EXTRA REWARDS (OLD METHOD)
// ==========================================
// Pull in rewards and set the reward rate for one week, based off of that
// If the rewards get messed up for some reason, set this to 0 and it will skip
// if (rewardRatesManual[1] != 0 && rewardRatesManual[2] != 0) {
// // CRV & CVX
// // ====================================
// uint256 crv_before = ERC20(rewardTokens[1]).balanceOf(address(this));
// uint256 cvx_before = ERC20(rewardTokens[2]).balanceOf(address(this));
// IConvexBaseRewardPool(0x329cb014b562d5d42927cfF0dEdF4c13ab0442EF).getReward(
// address(this),
// true
// );
// uint256 crv_after = ERC20(rewardTokens[1]).balanceOf(address(this));
// uint256 cvx_after = ERC20(rewardTokens[2]).balanceOf(address(this));
// // Set the new reward rate
// rewardRatesManual[1] = (crv_after - crv_before) / rewardsDuration;
// rewardRatesManual[2] = (cvx_after - cvx_before) / rewardsDuration;
// }
// Make sure everything is caught up again
_updateStoredRewardsAndTime();
}
function _updateStoredRewardsAndTime() internal {
// Get the rewards
uint256[] memory rewards_per_token = rewardsPerToken();
// Update the rewardsPerTokenStored
for (uint256 i = 0; i < rewardsPerTokenStored.length; i++){
rewardsPerTokenStored[i] = rewards_per_token[i];
}
// Update the last stored time
lastUpdateTime = lastTimeRewardApplicable();
}
/// @notice Updates the gauge weights, if applicable
/// @param force_update If true, will update the weights even if the time hasn't elapsed
function sync_gauge_weights(bool force_update) public {
// Loop through the gauge controllers
for (uint256 i = 0; i < gaugeControllers.length; i++){
address gauge_controller_address = gaugeControllers[i];
if (gauge_controller_address != address(0)) {
if (force_update || (block.timestamp > last_gauge_time_totals[i])){
// Update the gauge_relative_weight
last_gauge_relative_weights[i] = IFraxGaugeController(gauge_controller_address).gauge_relative_weight_write(address(this), block.timestamp);
last_gauge_time_totals[i] = IFraxGaugeController(gauge_controller_address).time_total();
}
}
}
}
/// @notice Updates gauge weights, fraxPerLP, pulls in new rewards or updates rewards
function sync() public {
// Sync the gauge weight, if applicable
sync_gauge_weights(false);
// Update the fraxPerLPStored
fraxPerLPStored = fraxPerLPToken();
if (block.timestamp >= periodFinish) {
retroCatchUp();
}
else {
_updateStoredRewardsAndTime();
}
}
/* ========== RESTRICTED FUNCTIONS - Curator callable ========== */
// ------ FARM SYNCING ------
// In children...
// ------ PAUSES ------
/// @notice Owner or governance can pause/unpause staking, withdrawals, rewards collection, and collectRewardsOnWithdrawal
/// @param _stakingPaused Whether staking is paused
/// @param _withdrawalsPaused Whether withdrawals are paused
/// @param _rewardsCollectionPaused Whether rewards collection is paused
/// @param _collectRewardsOnWithdrawalPaused Whether collectRewardsOnWithdrawal is paused
function setPauses(
bool _stakingPaused,
bool _withdrawalsPaused,
bool _rewardsCollectionPaused,
bool _collectRewardsOnWithdrawalPaused
) external onlyByOwnGov {
stakingPaused = _stakingPaused;
withdrawalsPaused = _withdrawalsPaused;
rewardsCollectionPaused = _rewardsCollectionPaused;
collectRewardsOnWithdrawalPaused = _collectRewardsOnWithdrawalPaused;
}
/* ========== RESTRICTED FUNCTIONS - Owner or timelock only ========== */
/// @notice Owner or governance can unlock stakes - irreversible!
function unlockStakes() external onlyByOwnGov {
stakesUnlocked = !stakesUnlocked;
}
/// @notice Owner or governance sets whether an address is a valid veFXS proxy
/// @param _proxy_addr The address to set
function toggleValidVeFXSProxy(address _proxy_addr) external onlyByOwnGov {
valid_vefxs_proxies[_proxy_addr] = !valid_vefxs_proxies[_proxy_addr];
}
/// @notice Allows owner to recover any ERC20 or token manager to recover their reward token.
/// @param tokenAddress The address of the token to recover
/// @param tokenAmount The amount of the token to recover
function recoverERC20(address tokenAddress, uint256 tokenAmount) external onlyTknMgrs(tokenAddress) {
// Check if the desired token is a reward token
bool isRewTkn = isRewardToken[tokenAddress];
// Only the reward managers can take back their reward tokens
// Also, other tokens, like the staking token, airdrops, or accidental deposits, can be withdrawn by the owner
if (
(isRewTkn && rewardManagers[tokenAddress] == msg.sender)
|| (!isRewTkn && (msg.sender == owner))
) {
TransferHelper.safeTransfer(tokenAddress, msg.sender, tokenAmount);
return;
}
// If none of the above conditions are true
else {
revert("No valid tokens to recover");
}
}
/// @notice Sets multiple variables at once
/// @param _misc_vars The variables to set:
/// [0]: uint256 _lock_max_multiplier,
/// [1] uint256 _vefxs_max_multiplier,
/// [2] uint256 _vefxs_per_frax_for_max_boost,
/// [3] uint256 _vefxs_boost_scale_factor,
/// [4] uint256 _lock_time_for_max_multiplier,
/// [5] uint256 _lock_time_min
/// [6] uint256 _max_stake_limit (must be at greater or equal to old value)
function setMiscVariables(
uint256[6] memory _misc_vars
// [0]: uint256 _lock_max_multiplier,
// [1] uint256 _vefxs_max_multiplier,
// [2] uint256 _vefxs_per_frax_for_max_boost,
// [3] uint256 _vefxs_boost_scale_factor,
// [4] uint256 _lock_time_for_max_multiplier,
// [5] uint256 _lock_time_min
) external onlyByOwnGov {
require(_misc_vars[0] >= MULTIPLIER_PRECISION, "Must be >= MUL PREC");
require((_misc_vars[1] >= 0) && (_misc_vars[2] >= 0) && (_misc_vars[3] >= 0), "Must be >= 0");
require((_misc_vars[4] >= 1) && (_misc_vars[5] >= 1), "Must be >= 1");
lock_max_multiplier = _misc_vars[0];
vefxs_max_multiplier = _misc_vars[1];
vefxs_per_frax_for_max_boost = _misc_vars[2];
vefxs_boost_scale_factor = _misc_vars[3];
lock_time_for_max_multiplier = _misc_vars[4];
lock_time_min = _misc_vars[5];
}
// The owner or the reward token managers can set reward rates
/// @notice Allows owner or reward token managers to set the reward rate for a given reward token
/// @param reward_token_address The address of the reward token
/// @param _new_rate The new reward rate (token amount divided by reward period duration)
/// @param _gauge_controller_address The address of the gauge controller for this reward token
/// @param _rewards_distributor_address The address of the rewards distributor for this reward token
function setRewardVars(address reward_token_address, uint256 _new_rate, address _gauge_controller_address, address _rewards_distributor_address) external onlyTknMgrs(reward_token_address) {
rewardRatesManual[rewardTokenAddrToIdx[reward_token_address]] = _new_rate;
gaugeControllers[rewardTokenAddrToIdx[reward_token_address]] = _gauge_controller_address;
rewardDistributors[rewardTokenAddrToIdx[reward_token_address]] = _rewards_distributor_address;
}
// The owner or the reward token managers can change managers
/// @notice Allows owner or reward token managers to change the reward manager for a given reward token
/// @param reward_token_address The address of the reward token
/// @param new_manager_address The new reward manager address
function changeTokenManager(address reward_token_address, address new_manager_address) external onlyTknMgrs(reward_token_address) {
rewardManagers[reward_token_address] = new_manager_address;
}
/* ========== EVENTS ========== */
event RewardPaid(address indexed user, uint256 amount, address token_address, address destination_address);
/* ========== A CHICKEN ========== */
//
// ,~.
// ,-'__ `-,
// {,-' `. } ,')
// ,( a ) `-.__ ,',')~,
// <=.) ( `-.__,==' ' ' '}
// ( ) /)
// `-'\ , )
// | \ `~. /
// \ `._ \ /
// \ `._____,' ,'
// `-. ,'
// `-._ _,-'
// 77jj'
// //_||
// __//--'/`
// ,--'/` '
//
// [hjw] https://textart.io/art/vw6Sa3iwqIRGkZsN1BC2vweF/chicken
}
// File contracts/Staking/FraxUnifiedFarm_ERC20.sol
// ====================================================================
// | ______ _______ |
// | / _____________ __ __ / ____(_____ ____ _____ ________ |
// | / /_ / ___/ __ `| |/_/ / /_ / / __ \/ __ `/ __ \/ ___/ _ \ |
// | / __/ / / / /_/ _> < / __/ / / / / / /_/ / / / / /__/ __/ |
// | /_/ /_/ \__,_/_/|_| /_/ /_/_/ /_/\__,_/_/ /_/\___/\___/ |
// | |
// ====================================================================
// ======================= FraxUnifiedFarm_ERC20 ======================
// ====================================================================
// For ERC20 Tokens
// Uses FraxUnifiedFarmTemplate.sol
// -------------------- VARIES --------------------
// Bunni
// Convex wrappers
// import "../Misc_AMOs/convex/IDepositToken.sol";
// import "../Misc_AMOs/curve/I2poolTokenNoLending.sol";
// Fraxlend
// import '../Fraxlend/IFraxlendPair.sol';
// Fraxswap
// import '../Fraxswap/core/interfaces/IFraxswapPair.sol';
// G-UNI
// import "../Misc_AMOs/gelato/IGUniPool.sol";
// mStable
// import '../Misc_AMOs/mstable/IFeederPool.sol';
// StakeDAO sdETH-FraxPut
// import '../Misc_AMOs/stakedao/IOpynPerpVault.sol';
// StakeDAO Vault
// import '../Misc_AMOs/stakedao/IStakeDaoVault.sol';
// Uniswap V2
// import '../Uniswap/Interfaces/IUniswapV2Pair.sol';
// Vesper
// import '../Misc_AMOs/vesper/IVPool.sol';
// ------------------------------------------------
contract FraxUnifiedFarm_ERC20 is FraxUnifiedFarmTemplate {
/* ========== STATE VARIABLES ========== */
// -------------------- COMMON --------------------
bool internal frax_is_token0;
// -------------------- VARIES --------------------
// Convex crvUSD/FRAX
// IConvexStakingWrapperFrax public stakingToken;
// I2poolTokenNoLending public curveToken;
// ICurvefrxETHETHPool public curvePool;
// Convex stkcvxFPIFRAX, stkcvxFRAXBP, etc
IConvexStakingWrapperFrax public stakingToken;
I2poolToken public curveToken;
// I2pool public curvePool;
ICurvefrxETHETHPool public curvePool;
// Fraxswap
// IFraxswapPair public stakingToken;
// Fraxlend
// IFraxlendPair public stakingToken;
// G-UNI
// IGUniPool public stakingToken;
// mStable
// IFeederPool public stakingToken;
// sdETH-FraxPut Vault
// IOpynPerpVault public stakingToken;
// StakeDAO Vault
// IStakeDaoVault public stakingToken;
// Uniswap V2
// IUniswapV2Pair public stakingToken;
// Vesper
// IVPool public stakingToken;
// ------------------------------------------------
// Stake tracking
mapping(address => LockedStake[]) public lockedStakes;
/* ========== STRUCTS ========== */
// Struct for the stake
struct LockedStake {
bytes32 kek_id;
uint256 start_timestamp;
uint256 liquidity;
uint256 ending_timestamp;
uint256 lock_multiplier; // 6 decimals of precision. 1x = 1000000
}
/* ========== CONSTRUCTOR ========== */
constructor (
address _owner,
address[] memory _rewardTokens,
address[] memory _rewardManagers,
uint256[] memory _rewardRatesManual,
address[] memory _gaugeControllers,
address[] memory _rewardDistributors,
address _stakingToken
)
FraxUnifiedFarmTemplate(_owner, _rewardTokens, _rewardManagers, _rewardRatesManual, _gaugeControllers, _rewardDistributors)
{
// -------------------- VARIES (USE CHILD FOR LOGIC) --------------------
// Bunni
// USE CHILD
// Convex stkcvxFPIFRAX, stkcvxFRAXBP, etc
// USE CHILD
// Fraxlend
// USE CHILD
// Fraxswap
// USE CHILD
// G-UNI
// stakingToken = IGUniPool(_stakingToken);
// address token0 = address(stakingToken.token0());
// frax_is_token0 = (token0 == frax_address);
// mStable
// stakingToken = IFeederPool(_stakingToken);
// StakeDAO sdETH-FraxPut Vault
// stakingToken = IOpynPerpVault(_stakingToken);
// StakeDAO Vault
// stakingToken = IStakeDaoVault(_stakingToken);
// Uniswap V2
// stakingToken = IUniswapV2Pair(_stakingToken);
// address token0 = stakingToken.token0();
// if (token0 == frax_address) frax_is_token0 = true;
// else frax_is_token0 = false;
// Vesper
// stakingToken = IVPool(_stakingToken);
}
/* ============= VIEWS ============= */
// ------ FRAX RELATED ------
function fraxPerLPToken() public virtual view override returns (uint256) {
// Get the amount of FRAX 'inside' of the lp tokens
uint256 frax_per_lp_token;
// Bunni
// ============================================
// USE CHILD
// Convex stkcvxFPIFRAX and stkcvxFRAXBP only
// ============================================
// USE CHILD
// Convex Stable/FRAXBP
// ============================================
// USE CHILD
// Convex Volatile/FRAXBP
// ============================================
// USE CHILD
// Fraxlend
// ============================================
// USE CHILD
// Fraxswap
// ============================================
// USE CHILD
// G-UNI
// ============================================
// {
// (uint256 reserve0, uint256 reserve1) = stakingToken.getUnderlyingBalances();
// uint256 total_frax_reserves = frax_is_token0 ? reserve0 : reserve1;
// frax_per_lp_token = (total_frax_reserves * 1e18) / stakingToken.totalSupply();
// }
// mStable
// ============================================
// {
// uint256 total_frax_reserves;
// (, IFeederPool.BassetData memory vaultData) = (stakingToken.getBasset(frax_address));
// total_frax_reserves = uint256(vaultData.vaultBalance);
// frax_per_lp_token = (total_frax_reserves * 1e18) / stakingToken.totalSupply();
// }
// StakeDAO sdETH-FraxPut Vault
// ============================================
// {
// uint256 frax3crv_held = stakingToken.totalUnderlyingControlled();
// // Optimistically assume 50/50 FRAX/3CRV ratio in the metapool to save gas
// frax_per_lp_token = ((frax3crv_held * 1e18) / stakingToken.totalSupply()) / 2;
// }
// StakeDAO Vault
// ============================================
// {
// uint256 frax3crv_held = stakingToken.balance();
// // Optimistically assume 50/50 FRAX/3CRV ratio in the metapool to save gas
// frax_per_lp_token = ((frax3crv_held * 1e18) / stakingToken.totalSupply()) / 2;
// }
// Uniswap V2
// ============================================
// {
// uint256 total_frax_reserves;
// (uint256 reserve0, uint256 reserve1, ) = (stakingToken.getReserves());
// if (frax_is_token0) total_frax_reserves = reserve0;
// else total_frax_reserves = reserve1;
// frax_per_lp_token = (total_frax_reserves * 1e18) / stakingToken.totalSupply();
// }
// Vesper
// ============================================
// frax_per_lp_token = stakingToken.pricePerShare();
return frax_per_lp_token;
}
// ------ LIQUIDITY AND WEIGHTS ------
function calcCurrLockMultiplier(address account, uint256 stake_idx) public view returns (uint256 midpoint_lock_multiplier) {
// Get the stake
LockedStake memory thisStake = lockedStakes[account][stake_idx];
// Handles corner case where user never claims for a new stake
// Don't want the multiplier going above the max
uint256 accrue_start_time;
if (lastRewardClaimTime[account] < thisStake.start_timestamp) {
accrue_start_time = thisStake.start_timestamp;
}
else {
accrue_start_time = lastRewardClaimTime[account];
}
// If the lock is expired
if (thisStake.ending_timestamp <= block.timestamp) {
// If the lock expired in the time since the last claim, the weight needs to be proportionately averaged this time
if (lastRewardClaimTime[account] < thisStake.ending_timestamp){
uint256 time_before_expiry = thisStake.ending_timestamp - accrue_start_time;
uint256 time_after_expiry = block.timestamp - thisStake.ending_timestamp;
// Average the pre-expiry lock multiplier
uint256 pre_expiry_avg_multiplier = lockMultiplier(time_before_expiry / 2);
// Get the weighted-average lock_multiplier
// uint256 numerator = (pre_expiry_avg_multiplier * time_before_expiry) + (MULTIPLIER_PRECISION * time_after_expiry);
uint256 numerator = (pre_expiry_avg_multiplier * time_before_expiry) + (0 * time_after_expiry);
midpoint_lock_multiplier = numerator / (time_before_expiry + time_after_expiry);
}
else {
// Otherwise, it needs to just be 1x
// midpoint_lock_multiplier = MULTIPLIER_PRECISION;
// Otherwise, it needs to just be 0x
midpoint_lock_multiplier = 0;
}
}
// If the lock is not expired
else {
// Decay the lock multiplier based on the time left
uint256 avg_time_left;
{
uint256 time_left_p1 = thisStake.ending_timestamp - accrue_start_time;
uint256 time_left_p2 = thisStake.ending_timestamp - block.timestamp;
avg_time_left = (time_left_p1 + time_left_p2) / 2;
}
midpoint_lock_multiplier = lockMultiplier(avg_time_left);
}
// Sanity check: make sure it never goes above the initial multiplier
if (midpoint_lock_multiplier > thisStake.lock_multiplier) midpoint_lock_multiplier = thisStake.lock_multiplier;
}
// Calculate the combined weight for an account
function calcCurCombinedWeight(address account) public override view
returns (
uint256 old_combined_weight,
uint256 new_vefxs_multiplier,
uint256 new_combined_weight
)
{
// Get the old combined weight
old_combined_weight = _combined_weights[account];
// Get the veFXS multipliers
// For the calculations, use the midpoint (analogous to midpoint Riemann sum)
new_vefxs_multiplier = veFXSMultiplier(account);
uint256 midpoint_vefxs_multiplier;
if (
(_locked_liquidity[account] == 0 && _combined_weights[account] == 0) ||
(new_vefxs_multiplier >= _vefxsMultiplierStored[account])
) {
// This is only called for the first stake to make sure the veFXS multiplier is not cut in half
// Also used if the user increased or maintained their position
midpoint_vefxs_multiplier = new_vefxs_multiplier;
}
else {
// Handles natural decay with a non-increased veFXS position
midpoint_vefxs_multiplier = (new_vefxs_multiplier + _vefxsMultiplierStored[account]) / 2;
}
// Loop through the locked stakes, first by getting the liquidity * lock_multiplier portion
new_combined_weight = 0;
for (uint256 i = 0; i < lockedStakes[account].length; i++) {
LockedStake memory thisStake = lockedStakes[account][i];
// Calculate the midpoint lock multiplier
uint256 midpoint_lock_multiplier = calcCurrLockMultiplier(account, i);
// Calculate the combined boost
uint256 liquidity = thisStake.liquidity;
uint256 combined_boosted_amount = liquidity + ((liquidity * (midpoint_lock_multiplier + midpoint_vefxs_multiplier)) / MULTIPLIER_PRECISION);
new_combined_weight += combined_boosted_amount;
}
}
// ------ LOCK RELATED ------
// All the locked stakes for a given account
function lockedStakesOf(address account) external view returns (LockedStake[] memory) {
return lockedStakes[account];
}
// Returns the length of the locked stakes for a given account
function lockedStakesOfLength(address account) external view returns (uint256) {
return lockedStakes[account].length;
}
// // All the locked stakes for a given account [old-school method]
// function lockedStakesOfMultiArr(address account) external view returns (
// bytes32[] memory kek_ids,
// uint256[] memory start_timestamps,
// uint256[] memory liquidities,
// uint256[] memory ending_timestamps,
// uint256[] memory lock_multipliers
// ) {
// for (uint256 i = 0; i < lockedStakes[account].length; i++){
// LockedStake memory thisStake = lockedStakes[account][i];
// kek_ids[i] = thisStake.kek_id;
// start_timestamps[i] = thisStake.start_timestamp;
// liquidities[i] = thisStake.liquidity;
// ending_timestamps[i] = thisStake.ending_timestamp;
// lock_multipliers[i] = thisStake.lock_multiplier;
// }
// }
/* =============== MUTATIVE FUNCTIONS =============== */
// ------ STAKING ------
function _updateLiqAmts(address staker_address, uint256 amt, bool is_add) internal {
// Get the proxy address
address the_proxy = getProxyFor(staker_address);
if (is_add) {
// Update total liquidities
_total_liquidity_locked += amt;
_locked_liquidity[staker_address] += amt;
// Update the proxy
if (the_proxy != address(0)) proxy_lp_balances[the_proxy] += amt;
}
else {
// Update total liquidities
_total_liquidity_locked -= amt;
_locked_liquidity[staker_address] -= amt;
// Update the proxy
if (the_proxy != address(0)) proxy_lp_balances[the_proxy] -= amt;
}
// Need to call to update the combined weights
_updateRewardAndBalance(staker_address, false, true);
}
function _getStake(address staker_address, bytes32 kek_id) internal view returns (LockedStake memory locked_stake, uint256 arr_idx) {
for (uint256 i = 0; i < lockedStakes[staker_address].length; i++){
if (kek_id == lockedStakes[staker_address][i].kek_id){
locked_stake = lockedStakes[staker_address][i];
arr_idx = i;
break;
}
}
require(locked_stake.kek_id == kek_id, "Stake not found");
}
// Add additional LPs to an existing locked stake
function lockAdditional(bytes32 kek_id, uint256 addl_liq) nonReentrant updateRewardAndBalanceMdf(msg.sender, true) public {
// Get the stake and its index
(LockedStake memory thisStake, uint256 theArrayIndex) = _getStake(msg.sender, kek_id);
// Calculate the new amount
uint256 new_amt = thisStake.liquidity + addl_liq;
// Checks
require(addl_liq >= 0, "Must be positive");
// Pull the tokens from the sender
TransferHelper.safeTransferFrom(address(stakingToken), msg.sender, address(this), addl_liq);
// Update the stake
lockedStakes[msg.sender][theArrayIndex] = LockedStake(
kek_id,
thisStake.start_timestamp,
new_amt,
thisStake.ending_timestamp,
thisStake.lock_multiplier
);
// Update liquidities
_updateLiqAmts(msg.sender, addl_liq, true);
emit LockedAdditional(msg.sender, kek_id, addl_liq);
}
// Extends the lock of an existing stake
function lockLonger(bytes32 kek_id, uint256 new_ending_ts) nonReentrant updateRewardAndBalanceMdf(msg.sender, true) public {
// Get the stake and its index
(LockedStake memory thisStake, uint256 theArrayIndex) = _getStake(msg.sender, kek_id);
// Check
require(new_ending_ts > block.timestamp, "Must be in the future");
// Calculate some times
uint256 time_left = (thisStake.ending_timestamp > block.timestamp) ? thisStake.ending_timestamp - block.timestamp : 0;
uint256 new_secs = new_ending_ts - block.timestamp;
// Checks
// require(time_left > 0, "Already expired");
require(new_secs > time_left, "Cannot shorten lock time");
require(new_secs >= lock_time_min, "Minimum stake time not met");
require(new_secs <= lock_time_for_max_multiplier, "Trying to lock for too long");
// Update the stake
lockedStakes[msg.sender][theArrayIndex] = LockedStake(
kek_id,
block.timestamp,
thisStake.liquidity,
new_ending_ts,
lockMultiplier(new_secs)
);
// Need to call to update the combined weights
_updateRewardAndBalance(msg.sender, false, true);
emit LockedLonger(msg.sender, kek_id, new_secs, block.timestamp, new_ending_ts);
}
// Two different stake functions are needed because of delegateCall and msg.sender issues (important for proxies)
function stakeLocked(uint256 liquidity, uint256 secs) nonReentrant external returns (bytes32) {
return _stakeLocked(msg.sender, msg.sender, liquidity, secs, block.timestamp);
}
// If this were not internal, and source_address had an infinite approve, this could be exploitable
// (pull funds from source_address and stake for an arbitrary staker_address)
function _stakeLocked(
address staker_address,
address source_address,
uint256 liquidity,
uint256 secs,
uint256 start_timestamp
) internal updateRewardAndBalanceMdf(staker_address, true) returns (bytes32) {
require(stakingPaused == false, "Staking paused");
require(secs >= lock_time_min, "Minimum stake time not met");
require(secs <= lock_time_for_max_multiplier,"Trying to lock for too long");
// Pull in the required token(s)
// Varies per farm
TransferHelper.safeTransferFrom(address(stakingToken), source_address, address(this), liquidity);
// Get the lock multiplier and kek_id
uint256 lock_multiplier = lockMultiplier(secs);
bytes32 kek_id = keccak256(abi.encodePacked(staker_address, start_timestamp, liquidity, _locked_liquidity[staker_address]));
// Create the locked stake
lockedStakes[staker_address].push(LockedStake(
kek_id,
start_timestamp,
liquidity,
start_timestamp + secs,
lock_multiplier
));
// Update liquidities
_updateLiqAmts(staker_address, liquidity, true);
emit StakeLocked(staker_address, liquidity, secs, kek_id, source_address);
return kek_id;
}
// ------ WITHDRAWING ------
// Two different withdrawLocked functions are needed because of delegateCall and msg.sender issues (important for proxies)
function withdrawLocked(bytes32 kek_id, address destination_address, bool claim_rewards) nonReentrant external returns (uint256) {
require(withdrawalsPaused == false, "Withdrawals paused");
return _withdrawLocked(msg.sender, destination_address, kek_id, claim_rewards);
}
// No withdrawer == msg.sender check needed since this is only internally callable and the checks are done in the wrapper
function _withdrawLocked(
address staker_address,
address destination_address,
bytes32 kek_id,
bool claim_rewards
) internal returns (uint256) {
// Collect rewards first and then update the balances
// collectRewardsOnWithdrawalPaused to be used in an emergency situation if reward is overemitted or not available
// and the user can forfeit rewards to get their principal back. User can also specify it in withdrawLocked
if (claim_rewards || !collectRewardsOnWithdrawalPaused) _getReward(staker_address, destination_address, true);
else {
// Sync the rewards at least
_updateRewardAndBalance(staker_address, true, false);
}
// Get the stake and its index
(LockedStake memory thisStake, uint256 theArrayIndex) = _getStake(staker_address, kek_id);
require(block.timestamp >= thisStake.ending_timestamp || stakesUnlocked == true, "Stake is still locked!");
uint256 liquidity = thisStake.liquidity;
if (liquidity > 0) {
// Give the tokens to the destination_address
// Should throw if insufficient balance
TransferHelper.safeTransfer(address(stakingToken), destination_address, liquidity);
// Remove the stake from the array
delete lockedStakes[staker_address][theArrayIndex];
// Update liquidities
_updateLiqAmts(staker_address, liquidity, false);
emit WithdrawLocked(staker_address, liquidity, kek_id, destination_address);
}
return liquidity;
}
function _getRewardExtraLogic(address rewardee, address destination_address) internal override {
// Do nothing
}
/* ========== RESTRICTED FUNCTIONS - Owner or timelock only ========== */
// Inherited...
/* ========== EVENTS ========== */
event LockedAdditional(address indexed user, bytes32 kek_id, uint256 amount);
event LockedLonger(address indexed user, bytes32 kek_id, uint256 new_secs, uint256 new_start_ts, uint256 new_end_ts);
event StakeLocked(address indexed user, uint256 amount, uint256 secs, bytes32 kek_id, address source_address);
event WithdrawLocked(address indexed user, uint256 liquidity, bytes32 kek_id, address destination_address);
}
// File contracts/Misc_AMOs/convex/IDepositToken.sol
interface IDepositToken {
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
function burn(address _from, uint256 _amount) external;
function decimals() external view returns (uint8);
function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool);
function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
function mint(address _to, uint256 _amount) external;
function name() external view returns (string memory);
function operator() external view returns (address);
function symbol() external view returns (string memory);
function totalSupply() external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}
// File contracts/Oracle/AggregatorV3Interface.sol
interface AggregatorV3Interface {
function decimals() external view returns (uint8);
function description() external view returns (string memory);
function version() external view returns (uint256);
// getRoundData and latestRoundData should both raise "No data present"
// if they do not have data to report, instead of returning unset values
// which could be misinterpreted as actual reported values.
function getRoundData(uint80 _roundId)
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
function latestRoundData()
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
}
// File contracts/Staking/Variants/FraxUnifiedFarm_ERC20_Convex_frxETH.sol
contract FraxUnifiedFarm_ERC20_Convex_frxETH is FraxUnifiedFarm_ERC20 {
AggregatorV3Interface internal priceFeedETHUSD = AggregatorV3Interface(0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419);
constructor (
address _owner,
address[] memory _rewardTokens,
address[] memory _rewardManagers,
uint256[] memory _rewardRates,
address[] memory _gaugeControllers,
address[] memory _rewardDistributors,
address _stakingToken
)
FraxUnifiedFarm_ERC20(_owner , _rewardTokens, _rewardManagers, _rewardRates, _gaugeControllers, _rewardDistributors, _stakingToken)
{
// COMMENTED OUT SO COMPILER DOESNT COMPLAIN. UNCOMMENT WHEN DEPLOYING
// Convex frxETH/XYZ
stakingToken = IConvexStakingWrapperFrax(_stakingToken);
curveToken = I2poolToken(stakingToken.curveToken());
curvePool = ICurvefrxETHETHPool(curveToken.minter());
}
function getLatestETHPriceE8() public view returns (int) {
// Returns in E8
(uint80 roundID, int price, , uint256 updatedAt, uint80 answeredInRound) = priceFeedETHUSD.latestRoundData();
require(price >= 0 && updatedAt!= 0 && answeredInRound >= roundID, "Invalid chainlink price");
return price;
}
function setETHUSDOracle(address _eth_usd_oracle_address) public onlyByOwnGov {
require(_eth_usd_oracle_address != address(0), "Zero address detected");
priceFeedETHUSD = AggregatorV3Interface(_eth_usd_oracle_address);
}
function fraxPerLPToken() public view override returns (uint256) {
// COMMENTED OUT SO COMPILER DOESNT COMPLAIN. UNCOMMENT WHEN DEPLOYING
// Get the amount of FRAX 'inside' of the lp tokens
uint256 frax_per_lp_token;
// Convex frxETH/XYZ
// ============================================
{
// Assume frxETH = ETH for pricing purposes
// Get the USD value of the frxETH per LP token
uint256 frxETH_in_pool = IERC20(0x5E8422345238F34275888049021821E8E08CAa1f).balanceOf(address(curvePool));
uint256 frxETH_usd_val_per_lp_e8 = (frxETH_in_pool * uint256(getLatestETHPriceE8())) / curveToken.totalSupply();
frax_per_lp_token = frxETH_usd_val_per_lp_e8 * (1e10); // We use USD as "Frax" here
}
return frax_per_lp_token;
}
}Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address[]","name":"_rewardTokens","type":"address[]"},{"internalType":"address[]","name":"_rewardManagers","type":"address[]"},{"internalType":"uint256[]","name":"_rewardRates","type":"uint256[]"},{"internalType":"address[]","name":"_gaugeControllers","type":"address[]"},{"internalType":"address[]","name":"_rewardDistributors","type":"address[]"},{"internalType":"address","name":"_stakingToken","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"bytes32","name":"kek_id","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"LockedAdditional","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"bytes32","name":"kek_id","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"new_secs","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"new_start_ts","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"new_end_ts","type":"uint256"}],"name":"LockedLonger","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"oldOwner","type":"address"},{"indexed":false,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnerChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnerNominated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"address","name":"token_address","type":"address"},{"indexed":false,"internalType":"address","name":"destination_address","type":"address"}],"name":"RewardPaid","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"secs","type":"uint256"},{"indexed":false,"internalType":"bytes32","name":"kek_id","type":"bytes32"},{"indexed":false,"internalType":"address","name":"source_address","type":"address"}],"name":"StakeLocked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"liquidity","type":"uint256"},{"indexed":false,"internalType":"bytes32","name":"kek_id","type":"bytes32"},{"indexed":false,"internalType":"address","name":"destination_address","type":"address"}],"name":"WithdrawLocked","type":"event"},{"inputs":[],"name":"acceptOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"calcCurCombinedWeight","outputs":[{"internalType":"uint256","name":"old_combined_weight","type":"uint256"},{"internalType":"uint256","name":"new_vefxs_multiplier","type":"uint256"},{"internalType":"uint256","name":"new_combined_weight","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"stake_idx","type":"uint256"}],"name":"calcCurrLockMultiplier","outputs":[{"internalType":"uint256","name":"midpoint_lock_multiplier","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"reward_token_address","type":"address"},{"internalType":"address","name":"new_manager_address","type":"address"}],"name":"changeTokenManager","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"combinedWeightOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"curvePool","outputs":[{"internalType":"contract ICurvefrxETHETHPool","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"curveToken","outputs":[{"internalType":"contract I2poolToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"earned","outputs":[{"internalType":"uint256[]","name":"new_earned","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"fraxPerLPStored","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"fraxPerLPToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getAllRewardTokens","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getLatestETHPriceE8","outputs":[{"internalType":"int256","name":"","type":"int256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"getProxyFor","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"destination_address","type":"address"}],"name":"getReward","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"destination_address","type":"address"},{"internalType":"bool","name":"claim_extra_too","type":"bool"}],"name":"getReward2","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"destination_address","type":"address"}],"name":"getRewardExtraLogic","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getRewardForDuration","outputs":[{"internalType":"uint256[]","name":"rewards_per_duration_arr","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"caller_addr","type":"address"},{"internalType":"address","name":"reward_token_addr","type":"address"}],"name":"isTokenManagerFor","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"lastRewardClaimTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastUpdateTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"kek_id","type":"bytes32"},{"internalType":"uint256","name":"addl_liq","type":"uint256"}],"name":"lockAdditional","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"kek_id","type":"bytes32"},{"internalType":"uint256","name":"new_ending_ts","type":"uint256"}],"name":"lockLonger","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"secs","type":"uint256"}],"name":"lockMultiplier","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lock_max_multiplier","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lock_time_for_max_multiplier","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lock_time_min","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"lockedLiquidityOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"lockedStakes","outputs":[{"internalType":"bytes32","name":"kek_id","type":"bytes32"},{"internalType":"uint256","name":"start_timestamp","type":"uint256"},{"internalType":"uint256","name":"liquidity","type":"uint256"},{"internalType":"uint256","name":"ending_timestamp","type":"uint256"},{"internalType":"uint256","name":"lock_multiplier","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"lockedStakesOf","outputs":[{"components":[{"internalType":"bytes32","name":"kek_id","type":"bytes32"},{"internalType":"uint256","name":"start_timestamp","type":"uint256"},{"internalType":"uint256","name":"liquidity","type":"uint256"},{"internalType":"uint256","name":"ending_timestamp","type":"uint256"},{"internalType":"uint256","name":"lock_multiplier","type":"uint256"}],"internalType":"struct FraxUnifiedFarm_ERC20.LockedStake[]","name":"","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"lockedStakesOfLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"maxLPForMaxBoost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"minVeFXSForMaxBoost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"proxy_address","type":"address"}],"name":"minVeFXSForMaxBoostProxy","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"nominateNewOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"nominatedOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"periodFinish","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"proxy_address","type":"address"}],"name":"proxyStakedFrax","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"staker_address","type":"address"}],"name":"proxyToggleStaker","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"proxy_lp_balances","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"tokenAddress","type":"address"},{"internalType":"uint256","name":"tokenAmount","type":"uint256"}],"name":"recoverERC20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"rewardManagers","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"token_idx","type":"uint256"}],"name":"rewardRates","outputs":[{"internalType":"uint256","name":"rwd_rate","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"rewardTokenAddrToIdx","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardsDuration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardsPerToken","outputs":[{"internalType":"uint256[]","name":"newRewardsPerTokenStored","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_eth_usd_oracle_address","type":"address"}],"name":"setETHUSDOracle","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[6]","name":"_misc_vars","type":"uint256[6]"}],"name":"setMiscVariables","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_stakingPaused","type":"bool"},{"internalType":"bool","name":"_withdrawalsPaused","type":"bool"},{"internalType":"bool","name":"_rewardsCollectionPaused","type":"bool"},{"internalType":"bool","name":"_collectRewardsOnWithdrawalPaused","type":"bool"}],"name":"setPauses","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"reward_token_address","type":"address"},{"internalType":"uint256","name":"_new_rate","type":"uint256"},{"internalType":"address","name":"_gauge_controller_address","type":"address"},{"internalType":"address","name":"_rewards_distributor_address","type":"address"}],"name":"setRewardVars","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"liquidity","type":"uint256"},{"internalType":"uint256","name":"secs","type":"uint256"}],"name":"stakeLocked","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"proxy_address","type":"address"}],"name":"stakerSetVeFXSProxy","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"staker_designated_proxies","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stakesUnlocked","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stakingToken","outputs":[{"internalType":"contract IConvexStakingWrapperFrax","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"sync","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"force_update","type":"bool"}],"name":"sync_gauge_weights","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_proxy_addr","type":"address"}],"name":"toggleValidVeFXSProxy","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"totalCombinedWeight","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalLiquidityLocked","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"unlockStakes","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"userStakedFrax","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"veFXSMultiplier","outputs":[{"internalType":"uint256","name":"vefxs_multiplier","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"vefxs_boost_scale_factor","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"vefxs_max_multiplier","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"vefxs_per_frax_for_max_boost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"kek_id","type":"bytes32"},{"internalType":"address","name":"destination_address","type":"address"},{"internalType":"bool","name":"claim_rewards","type":"bool"}],"name":"withdrawLocked","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"}]Deployed Bytecode
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
Deployed Bytecode Sourcemap
130036:2430:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;77456:529;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;125121:294;;;;;;:::i;:::-;;:::i;:::-;;;1700:25:1;;;1688:2;1673:18;125121:294:0;1554:177:1;80354:222:0;;;;;;:::i;:::-;;:::i;75458:109::-;;;:::i;:::-;;;;;;;:::i;61411:141::-;;;;;;:::i;:::-;;:::i;:::-;;123205:190;;;;;;:::i;:::-;;:::i;78164:339::-;;;:::i;117887:133::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;81186:179::-;;;;;;:::i;:::-;;:::i;107331:36::-;;;;;;;;;;;;4262:42:1;4250:55;;;4232:74;;4220:2;4205:18;107331:36:0;4058:254:1;74870:459:0;;;;;;:::i;:::-;;:::i;:::-;;;4747:14:1;;4740:22;4722:41;;4710:2;4695:18;74870:459:0;4582:187:1;71715:60:0;;;;;;:::i;:::-;;;;;;;;;;;;;;;;83713:1752;;;;;;:::i;:::-;;:::i;99145:439::-;;;;;;:::i;:::-;;:::i;79565:127::-;;;;;;:::i;:::-;79658:26;;79631:7;79658:26;;;:17;:26;;;;;;;79565:127;70551:48;;70593:6;70551:48;;90200:238;;;;;;:::i;:::-;;:::i;70140:49::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;107262:29;;;;;;;;;82348:181;;;;;;:::i;:::-;;:::i;61179:29::-;;;;;;;;;131602:861;;;:::i;79173:111::-;79254:22;;79173:111;;70461:55;;;;;;:::i;:::-;;;;;;;;;;;;;;70943:54;;;;;;:::i;:::-;;;;;;;;;;;;;;69370:37;;;;;;76463:681;;;:::i;107210:45::-;;;;;;;;;;;;131349:245;;;;;;:::i;:::-;;:::i;113078:2692::-;;;;;;:::i;:::-;;:::i;91386:206::-;;;;;;:::i;:::-;;:::i;107961:53::-;;;;;;:::i;:::-;;:::i;:::-;;;;7011:25:1;;;7067:2;7052:18;;7045:34;;;;7095:18;;;7088:34;;;;7153:2;7138:18;;7131:34;7196:3;7181:19;;7174:35;6998:3;6983:19;107961:53:0;6752:463:1;61560:271:0;;;:::i;71510:52::-;;;;;;:::i;:::-;;;;;;;;;;;;;;82725:199;;;;;;:::i;:::-;;:::i;100380:818::-;;;;;;:::i;:::-;;:::i;115831:1961::-;;;;;;:::i;:::-;;:::i;:::-;;;;7422:25:1;;;7478:2;7463:18;;7456:34;;;;7506:18;;;7499:34;7410:2;7395:18;115831:1961:0;7220:319:1;61152:20:0;;;;;;;;;99984:161;;;;;;:::i;:::-;;:::i;71837:26::-;;;;;;;;;81642:224;;;;;;:::i;:::-;;:::i;69464:55::-;;;;;;120646:1006;;;;;;:::i;:::-;;:::i;69215:62::-;;;;;;130994:347;;;:::i;90924:172::-;;;;;;:::i;:::-;;:::i;83077:444::-;;;;;;:::i;:::-;;:::i;69061:29::-;;;;;;118096:133;;;;;;:::i;:::-;118193:21;;118166:7;118193:21;;;:12;:21;;;;;:28;;118096:133;69141:50;;;;;;68734:30;;;;;;121706:1364;;;;;;:::i;:::-;;:::i;80811:166::-;;;;;;:::i;:::-;;:::i;103173:483::-;;;;;;:::i;:::-;;:::i;86485:800::-;;;;;;:::i;:::-;;:::i;78931:128::-;;;;;;:::i;:::-;79025:26;;78998:7;79025:26;;;:17;:26;;;;;;;78931:128;103976:207;;;;;;:::i;:::-;;:::i;78666:113::-;78748:23;;78666:113;;99748:97;;;:::i;85719:610::-;;;;;;:::i;:::-;;:::i;68954:27::-;;;;;;69602:51;;;;;;69678:59;;;;;;75941:452;;;;;;:::i;:::-;;:::i;97320:761::-;;;;;;:::i;:::-;;:::i;101661:958::-;;;;;;:::i;:::-;;:::i;98180:363::-;;;:::i;77456:529::-;77510:27;77550;77580:17;:15;:17::i;:::-;77635:12;:19;77550:47;;-1:-1:-1;77621:34:0;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;77621:34:0;-1:-1:-1;77672:26:0;;;77701:1;77672:26;;;:17;:26;;;;;;77608:47;;-1:-1:-1;77672:30:0;77668:310;;77723:9;77718:249;77742:12;:19;77738:23;;77718:249;;;77932:16;;;;;;;:7;:16;;;;;;;;:19;;;;;;;;;77851:32;;;:23;:32;;;;;:35;;;;;;;;;77835:13;;77891:4;;77851:35;77835:10;;77949:1;;77835:13;;;;;;:::i;:::-;;;;;;;:51;;;;:::i;:::-;77805:26;;;;;;;:17;:26;;;;;;:82;;;;:::i;:::-;77804:91;;;;:::i;:::-;77803:148;;;;:::i;:::-;77787:10;77798:1;77787:13;;;;;;;;:::i;:::-;;;;;;;;;;:164;77763:3;;;;:::i;:::-;;;;77718:249;;;;77668:310;77539:446;77456:529;;;:::o;125121:294::-;125241:7;65326:1;65932:7;;:19;65924:63;;;;;;;11235:2:1;65924:63:0;;;11217:21:1;11274:2;11254:18;;;11247:30;11313:33;11293:18;;;11286:61;11364:18;;65924:63:0;;;;;;;;;65326:1;66065:18;;125269:17:::1;::::0;::::1;::::0;::::1;;;:26;125261:57;;;::::0;::::1;::::0;;11595:2:1;125261:57:0::1;::::0;::::1;11577:21:1::0;11634:2;11614:18;;;11607:30;11673:20;11653:18;;;11646:48;11711:18;;125261:57:0::1;11393:342:1::0;125261:57:0::1;125336:71;125352:10;125364:19;125385:6;125393:13;125336:15;:71::i;:::-;65282:1:::0;66244:7;:22;125329:78;125121:294;-1:-1:-1;;;;125121:294:0:o;80354:222::-;80463:19;;80528:28;;80413:7;;80440:127;;80498:26;80463:19;80498:4;:26;:::i;:::-;80497:59;;;;:::i;:::-;80440:8;:127::i;:::-;80433:134;80354:222;-1:-1:-1;;80354:222:0:o;75458:109::-;75511:16;75547:12;75540:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;75458:109;:::o;61411:141::-;61891:5;;;;61877:10;:19;61869:79;;;;;;;11942:2:1;61869:79:0;;;11924:21:1;11981:2;11961:18;;;11954:30;12020:34;12000:18;;;11993:62;12091:17;12071:18;;;12064:45;12126:19;;61869:79:0;11740:411:1;61869:79:0;61483:14:::1;:23:::0;;;::::1;;::::0;::::1;::::0;;::::1;::::0;;;61522:22:::1;::::0;4232:74:1;;;61522:22:0::1;::::0;4220:2:1;4205:18;61522:22:0::1;;;;;;;61411:141:::0;:::o;123205:190::-;123290:7;65326:1;65932:7;;:19;65924:63;;;;;;;11235:2:1;65924:63:0;;;11217:21:1;11274:2;11254:18;;;11247:30;11313:33;11293:18;;;11286:61;11364:18;;65924:63:0;11033:355:1;65924:63:0;65326:1;66065:18;;123317:70:::1;123330:10;::::0;123354:9;123365:4;123371:15:::1;123317:12;:70::i;:::-;65282:1:::0;66244:7;:22;123310:77;123205:190;-1:-1:-1;;;123205:190:0:o;78164:339::-;78314:17;:24;78219:41;;78300:39;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;78300:39:0;;78273:66;;78357:9;78352:144;78376:17;:24;78372:28;;78352:144;;;70593:6;78452:14;78464:1;78452:11;:14::i;:::-;:32;;;;:::i;:::-;78422:24;78447:1;78422:27;;;;;;;;:::i;:::-;;;;;;;;;;:62;78402:3;;;;:::i;:::-;;;;78352:144;;;;78164:339;:::o;117887:133::-;117991:21;;;;;;;:12;:21;;;;;;;;117984:28;;;;;;;;;;;;;;;;;117951:20;;117984:28;;117991:21;;117984:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;117887:133;;;:::o;81186:179::-;81301:32;;;81255:7;81301:32;;;:17;:32;;;;;;81283:15;;68862:4;;81283:50;;;:::i;:::-;81282:75;;;;:::i;74870:459::-;74987:32;;;74966:4;74987:32;;;:13;:32;;;;;;;;74982:297;;-1:-1:-1;75028:5:0;75021:12;;74982:297;75053:25;;;;;:60;;-1:-1:-1;75082:31:0;;;;75053:60;75049:230;;;-1:-1:-1;75122:5:0;75115:12;;75049:230;75162:5;;;;;;75147:20;;;;75143:136;;-1:-1:-1;75176:4:0;75169:11;;75143:136;75218:48;:33;;;;;;;:14;:33;;;;;;:48;;;:33;;:48;75214:65;;-1:-1:-1;75275:4:0;75268:11;;75214:65;-1:-1:-1;75315:5:0;74870:459;;;;:::o;83713:1752::-;83776:24;;;83937:20;83949:7;83937:11;:20::i;:::-;83917:40;-1:-1:-1;83988:23:0;;;;83987:81;;84042:26;;;;;4262:42:1;4250:55;;84042:26:0;;;4232:74:1;68469:42:0;;84042:15;;4205:18:1;;84042:26:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;83987:81;;;84015:24;;;;;4262:42:1;4250:55;;84015:24:0;;;4232:74:1;68469:42:0;;84015:15;;4205:18:1;;84015:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;83968:100;;84174:19;68862:4;68469:42;84298:17;;;:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:42;;;;:::i;:::-;84239:24;;84216:20;;84197:39;;:16;:39;:::i;:::-;:66;;;;:::i;:::-;84196:145;;;;:::i;:::-;84174:167;-1:-1:-1;84450:19:0;;84665:23;;;;84664:94;;84723:35;84748:9;84723:24;:35::i;:::-;84664:94;;;84692:28;84712:7;84692:19;:28::i;:::-;84635:123;-1:-1:-1;84779:30:0;;84775:323;;84830:27;84904:26;84861:39;68862:4;84861:16;:39;:::i;:::-;84860:70;;;;:::i;:::-;84830:100;;68862:4;85004:20;;84982:19;:42;;;;:::i;:::-;84981:67;;;;:::i;:::-;84967:81;;84810:254;84775:323;;;85097:1;85083:15;;84775:323;84480:699;85266:11;85252;:25;:53;;85294:11;85252:53;;;85280:11;85252:53;85232:74;;85396:20;;85377:16;:39;85373:84;;;85437:20;;85418:39;;85373:84;83802:1663;;;;83713:1752;;;:::o;99145:439::-;72359:5;;;;72345:10;:19;;:79;;-1:-1:-1;72382:42:0;72368:10;:56;72345:79;72337:113;;;;;;;12547:2:1;72337:113:0;;;12529:21:1;12586:2;12566:18;;;12559:30;12625:23;12605:18;;;12598:51;12666:18;;72337:113:0;12345:345:1;72337:113:0;99357:13:::1;:30:::0;;99398:38;;99357:30;;::::1;;::::0;;;::::1;99398:38:::0;;;;;;99357:30:::1;99398:38:::0;::::1;;::::0;;;::::1;::::0;;;::::1;99508:68:::0;;99447:50;;::::1;;::::0;;;::::1;99508:68:::0;;;;;::::1;;::::0;;;::::1;;::::0;;99145:439::o;90200:238::-;65326:1;65932:7;;:19;65924:63;;;;;;;11235:2:1;65924:63:0;;;11217:21:1;11274:2;11254:18;;;11247:30;11313:33;11293:18;;;11286:61;11364:18;;65924:63:0;11033:355:1;65924:63:0;65326:1;66065:18;;90297:23:::1;::::0;;;::::1;;;:32;90289:70;;;::::0;::::1;::::0;;12897:2:1;90289:70:0::1;::::0;::::1;12879:21:1::0;12936:2;12916:18;;;12909:30;12975:27;12955:18;;;12948:55;13020:18;;90289:70:0::1;12695:349:1::0;90289:70:0::1;-1:-1:-1::0;65282:1:0;66244:7;:22;90200:238::o;82348:181::-;82415:7;68862:4;82469:28;;82443:23;82458:7;82443:14;:23::i;:::-;:54;;;;:::i;131602:861::-;132173:9;;;132104:80;;;;;:60;132173:9;;;132104:80;;;4232:74:1;131658:7:0;;;;;;132111:42;;132104:60;;4205:18:1;132104:80:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;132079:105;;132199:32;132286:10;;;;;;;;;;;:22;;;:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;132260:21;:19;:21::i;:::-;132235:47;;:14;:47;:::i;:::-;132234:76;;;;:::i;:::-;132199:111;-1:-1:-1;132345:33:0;132199:111;132373:4;132345:33;:::i;:::-;132325:53;131602:861;-1:-1:-1;;;;131602:861:0:o;76463:681::-;76511:41;76569:23;;76596:1;76569:28;:59;;;-1:-1:-1;76601:22:0;;:27;76569:59;76565:572;;;76652:21;76645:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;76463:681;:::o;76565:572::-;76756:12;:19;76742:34;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;76742:34:0;;76715:61;;76796:9;76791:289;76815:21;:28;76811:32;;76791:289;;;77023:22;;76998:14;77010:1;76998:11;:14::i;:::-;76980;;76951:26;:24;:26::i;:::-;:43;;;;:::i;:::-;76950:62;;;;:::i;:::-;:69;;77015:4;76950:69;:::i;:::-;76949:96;;;;:::i;:::-;76899:21;76921:1;76899:24;;;;;;;;:::i;:::-;;;;;;;;;:165;;;;:::i;:::-;76869:24;76894:1;76869:27;;;;;;;;:::i;:::-;;;;;;;;;;:195;76845:3;;;;:::i;:::-;;;;76791:289;;131349:245;72359:5;;;;72345:10;:19;;:79;;-1:-1:-1;72382:42:0;72368:10;:56;72345:79;72337:113;;;;;;;12547:2:1;72337:113:0;;;12529:21:1;12586:2;12566:18;;;12559:30;12625:23;12605:18;;;12598:51;12666:18;;72337:113:0;12345:345:1;72337:113:0;131446:37:::1;::::0;::::1;131438:71;;;::::0;::::1;::::0;;13251:2:1;131438:71:0::1;::::0;::::1;13233:21:1::0;13290:2;13270:18;;;13263:30;13329:23;13309:18;;;13302:51;13370:18;;131438:71:0::1;13049:345:1::0;131438:71:0::1;131522:15;:64:::0;;;::::1;;::::0;;;::::1;::::0;;;::::1;::::0;;131349:245::o;113078:2692::-;113269:21;;;113167:32;113269:21;;;:12;:21;;;;;:32;;113167;;113269:21;113291:9;;113269:32;;;;;;:::i;:::-;;;;;;;;;113238:63;;;;;;;;113269:32;;;;;;;113238:63;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;113484:28;;;;;:19;:28;;;;;;113238:63;;-1:-1:-1;;113480:224:0;;;-1:-1:-1;113577:25:0;;;;113480:224;;;-1:-1:-1;113664:28:0;;;;;;;:19;:28;;;;;;113480:224;113793:15;113763:9;:26;;;:45;113759:1802;;113988:26;;;;113957:28;;;;;;;:19;:28;;;;;;:57;113953:1087;;;114034:26;114092:17;114063:9;:26;;;:46;;;;:::i;:::-;114034:75;;114128:25;114174:9;:26;;;114156:15;:44;;;;:::i;:::-;114128:72;-1:-1:-1;114280:33:0;114316:38;114331:22;114352:1;114331:18;:22;:::i;114316:38::-;114280:74;-1:-1:-1;114571:17:0;114643:21;114647:17;114571;114643:21;:::i;:::-;114592:46;114620:18;114592:25;:46;:::i;:::-;114591:74;;;;:::i;:::-;114571:94;-1:-1:-1;114724:38:0;114745:17;114724:18;:38;:::i;:::-;114711:52;;:9;:52;:::i;:::-;114684:79;;114015:764;;;;113759:1802;;113953:1087;115023:1;114996:28;;113759:1802;;;115185:21;115240:20;115292:17;115263:9;:26;;;:46;;;;:::i;:::-;115240:69;;115328:20;115380:15;115351:9;:26;;;:44;;;;:::i;:::-;115328:67;-1:-1:-1;115462:1:0;115431:27;115328:67;115431:12;:27;:::i;:::-;115430:33;;;;:::i;:::-;115414:49;;115221:258;;115520:29;115535:13;115520:14;:29::i;:::-;115493:56;;115105:456;113759:1802;115683:9;:25;;;115656:24;:52;115652:110;;;115737:9;:25;;;115710:52;;115652:110;113201:2569;;113078:2692;;;;:::o;91386:206::-;91488:16;65326:1;65932:7;;:19;65924:63;;;;;;;11235:2:1;65924:63:0;;;11217:21:1;11274:2;11254:18;;;11247:30;11313:33;11293:18;;;11286:61;11364:18;;65924:63:0;11033:355:1;65924:63:0;65326:1;66065:18;;91524:60:::1;91535:10;91547:19:::0;91568:15;91524:10:::1;:60::i;107961:53::-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;107961:53:0;;-1:-1:-1;107961:53:0;;;:::o;61560:271::-;61629:14;;;;61615:10;:28;61607:94;;;;;;;13601:2:1;61607:94:0;;;13583:21:1;13640:2;13620:18;;;13613:30;13679:34;13659:18;;;13652:62;13750:23;13730:18;;;13723:51;13791:19;;61607:94:0;13399:417:1;61607:94:0;61730:5;;;61737:14;61717:35;;;61730:5;;;;14056:34:1;;61737:14:0;;;;14121:2:1;14106:18;;14099:43;61717:35:0;;13968:18:1;61717:35:0;;;;;;;61771:14;;;;61763:22;;;;;;61771:14;;;61763:22;;;;61796:27;;;61560:271::o;82725:199::-;82803:7;68862:4;82864:28;;82831:30;82847:13;82831:15;:30::i;100380:818::-;72562:5;;100466:12;;72562:5;;72548:10;:19;;:74;;;72571:51;72589:10;72601:20;72571:17;:51::i;:::-;72540:107;;;;;;;14355:2:1;72540:107:0;;;14337:21:1;14394:2;14374:18;;;14367:30;14433:22;14413:18;;;14406:50;14473:18;;72540:107:0;14153:344:1;72540:107:0;100564:27:::1;::::0;::::1;100548:13;100564:27:::0;;;:13:::1;:27;::::0;;;;;::::1;;::::0;100818:54;::::1;;;-1:-1:-1::0;100830:42:0::1;:28:::0;;::::1;;::::0;;;:14:::1;:28;::::0;;;;;::::1;100862:10;100830:42;100818:54;100817:113;;;;100896:8;100895:9;:34;;;;-1:-1:-1::0;100923:5:0::1;::::0;::::1;;100909:10;:19;100895:34;100795:396;;;100961:66;100989:12;101003:10;101015:11;100961:27;:66::i;:::-;101042:7;100380:818:::0;;;:::o;100795:396::-:1;101143:36;::::0;::::1;::::0;;14704:2:1;101143:36:0::1;::::0;::::1;14686:21:1::0;14743:2;14723:18;;;14716:30;14782:28;14762:18;;;14755:56;14828:18;;101143:36:0::1;14502:350:1::0;72658:1:0::1;100380:818:::0;;;:::o;115831:1961::-;116134:26;;;115932:27;116134:26;;;:17;:26;;;;;;;115932:27;116321:24;116152:7;116321:15;:24::i;:::-;116421:26;;;116358:33;116421:26;;;:17;:26;;;;;;116298:47;;-1:-1:-1;116358:33:0;116421:31;:66;;;;-1:-1:-1;116456:26:0;;;;;;;:17;:26;;;;;;:31;116421:66;116420:143;;;-1:-1:-1;116531:31:0;;;;;;;:22;:31;;;;;;116507:55;;;116420:143;116402:638;;;-1:-1:-1;116804:20:0;116402:638;;;116992:31;;;;;;;:22;:31;;;;;;117027:1;;116969:54;;:20;:54;:::i;:::-;116968:60;;;;:::i;:::-;116940:88;;116402:638;117175:1;117153:23;;117192:9;117187:598;117211:21;;;;;;;:12;:21;;;;;:28;117207:32;;117187:598;;;117292:21;;;117261:28;117292:21;;;:12;:21;;;;;:24;;117314:1;;117292:24;;;;;;:::i;:::-;;;;;;;;;;;117261:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;117388:32;117423:34;117446:7;117455:1;117423:22;:34::i;:::-;117539:19;;;;117388:69;;-1:-1:-1;117519:17:0;68862:4;117634:52;117661:25;117388:69;117634:52;:::i;:::-;117621:66;;:9;:66;:::i;:::-;117620:91;;;;:::i;:::-;117607:105;;:9;:105;:::i;:::-;117573:139;-1:-1:-1;117727:46:0;117573:139;117727:46;;:::i;:::-;;;117246:539;;;;117241:3;;;;;:::i;:::-;;;;117187:598;;;;116061:1731;115831:1961;;;;;:::o;99984:161::-;72359:5;;;;72345:10;:19;;:79;;-1:-1:-1;72382:42:0;72368:10;:56;72345:79;72337:113;;;;;;;12547:2:1;72337:113:0;;;12529:21:1;12586:2;12566:18;;;12559:30;12625:23;12605:18;;;12598:51;12666:18;;72337:113:0;12345:345:1;72337:113:0;100105:32:::1;;;::::0;;;:19:::1;:32;::::0;;;;;;100069:68;;::::1;100105:32;::::0;;::::1;100104:33;100069:68;::::0;;99984:161::o;81642:224::-;81708:7;81842:15;;81811:28;;:46;;;;:::i;:::-;81736:24;;;;;4262:42:1;4250:55;;81736:24:0;;;4232:74:1;68862:4:0;;;;68469:42;;81736:15;;4205:18:1;;81736:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:47;;;;:::i;120646:1006::-;65326:1;65932:7;;:19;65924:63;;;;;;;11235:2:1;65924:63:0;;;11217:21:1;11274:2;11254:18;;;11247:30;11313:33;11293:18;;;11286:61;11364:18;;65924:63:0;11033:355:1;65924:63:0;65326:1;66065:18;;120743:10:::1;120755:4;72753:49;120743:10:::0;120755:4;72796:5:::1;72753:23;:49::i;:::-;120820:28:::2;120850:21:::0;120875:29:::2;120885:10;120897:6;120875:9;:29::i;:::-;120819:85;;;;120954:15;120994:8;120972:9;:19;;;:30;;;;:::i;:::-;120954:48:::0;-1:-1:-1;121173:12:0::2;::::0;121133:91:::2;::::0;121173:12;;::::2;;;121188:10;121208:4;121215:8:::0;121133:31:::2;:91::i;:::-;121308:186;::::0;;::::2;::::0;::::2;::::0;;;;;::::2;121355:25:::0;;::::2;::::0;121308:186;;::::2;::::0;;;;;;;;121417:26;;::::2;::::0;121308:186;;;;;121458:25;;::::2;::::0;121308:186;;;;121279:10:::2;-1:-1:-1::0;121266:24:0;;;:12:::2;:24:::0;;;;;;;:39;;121291:13;;121266:39;::::2;;;;;:::i;:::-;;;;;;;;;;;:228;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;121538:42;121553:10;121565:8;121575:4;121538:14;:42::i;:::-;121598:46;::::0;;15376:25:1;;;15432:2;15417:18;;15410:34;;;121615:10:0::2;::::0;121598:46:::2;::::0;15349:18:1;121598:46:0::2;;;;;;;-1:-1:-1::0;;65282:1:0;66244:7;:22;-1:-1:-1;;;;;120646:1006:0:o;130994:347::-;131046:3;131089:14;131105:9;131118:17;131137:22;131163:15;;;;;;;;;;;:31;;;:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;131088:108;;;;;;;;;131224:1;131215:5;:10;;:27;;;;-1:-1:-1;131229:13:0;;;131215:27;:57;;;;;131265:7;131246:26;;:15;:26;;;;131215:57;131207:93;;;;;;;16319:2:1;131207:93:0;;;16301:21:1;16358:2;16338:18;;;16331:30;16397:25;16377:18;;;16370:53;16440:18;;131207:93:0;16117:347:1;131207:93:0;-1:-1:-1;131328:5:0;;130994:347;-1:-1:-1;;;130994:347:0:o;90924:172::-;91003:16;65326:1;65932:7;;:19;65924:63;;;;;;;11235:2:1;65924:63:0;;;11217:21:1;11274:2;11254:18;;;11247:30;11313:33;11293:18;;;11286:61;11364:18;;65924:63:0;11033:355:1;65924:63:0;65326:1;66065:18;;91039:49:::1;91050:10;91062:19:::0;91083:4:::1;91039:10;:49::i;:::-;65282:1:::0;66244:7;:22;91032:56;90924:172;-1:-1:-1;;90924:172:0:o;83077:444::-;83156:25;;;83133:7;83156:25;;;:19;:25;;;;;;;;83152:362;;;-1:-1:-1;83359:4:0;83077:444::o;83152:362::-;-1:-1:-1;83471:31:0;;;;;;;;:25;:31;;;;;;;;83077:444::o;83152:362::-;83077:444;;;:::o;121706:1364::-;65326:1;65932:7;;:19;65924:63;;;;;;;11235:2:1;65924:63:0;;;11217:21:1;11274:2;11254:18;;;11247:30;11313:33;11293:18;;;11286:61;11364:18;;65924:63:0;11033:355:1;65924:63:0;65326:1;66065:18;;121804:10:::1;121816:4;72753:49;121804:10:::0;121816:4;72796:5:::1;72753:23;:49::i;:::-;121881:28:::2;121911:21:::0;121936:29:::2;121946:10;121958:6;121936:9;:29::i;:::-;121880:85;;;;122020:15;122004:13;:31;121996:65;;;::::0;::::2;::::0;;16671:2:1;121996:65:0::2;::::0;::::2;16653:21:1::0;16710:2;16690:18;;;16683:30;16749:23;16729:18;;;16722:51;16790:18;;121996:65:0::2;16469:345:1::0;121996:65:0::2;122107:17;122157:15;122128:9;:26;;;:44;122127:97;;122223:1;122127:97;;;122205:15;122176:9;:26;;;:44;;;;:::i;:::-;122107:117:::0;-1:-1:-1;122235:16:0::2;122254:31;122270:15;122254:13:::0;:31:::2;:::i;:::-;122235:50;;122391:9;122380:8;:20;122372:57;;;::::0;::::2;::::0;;17021:2:1;122372:57:0::2;::::0;::::2;17003:21:1::0;17060:2;17040:18;;;17033:30;17099:26;17079:18;;;17072:54;17143:18;;122372:57:0::2;16819:348:1::0;122372:57:0::2;122460:13;;122448:8;:25;;122440:64;;;::::0;::::2;::::0;;17374:2:1;122440:64:0::2;::::0;::::2;17356:21:1::0;17413:2;17393:18;;;17386:30;17452:28;17432:18;;;17425:56;17498:18;;122440:64:0::2;17172:350:1::0;122440:64:0::2;122535:28;;122523:8;:40;;122515:80;;;::::0;::::2;::::0;;17729:2:1;122515:80:0::2;::::0;::::2;17711:21:1::0;17768:2;17748:18;;;17741:30;17807:29;17787:18;;;17780:57;17854:18;;122515:80:0::2;17527:351:1::0;122515:80:0::2;122679:174;;;;;;;;122705:6;122679:174;;;;122726:15;122679:174;;;;122756:9;:19;;;122679:174;;;;122790:13;122679:174;;;;122818:24;122833:8;122818:14;:24::i;:::-;122679:174:::0;;122650:10:::2;122637:24;::::0;;;:12:::2;:24;::::0;;;;:39;;122662:13;;122637:39;::::2;;;;;:::i;:::-;;;;;;;;;;;:216;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;122922:48;122946:10;122958:5;122965:4;122922:23;:48::i;:::-;122988:74;::::0;;18114:25:1;;;18170:2;18155:18;;18148:34;;;123031:15:0::2;18198:18:1::0;;;18191:34;18256:2;18241:18;;18234:34;;;122988:74:0;;123001:10:::2;::::0;122988:74:::2;::::0;;;;;18101:3:1;122988:74:0;;::::2;-1:-1:-1::0;;65282:1:0;66244:7;:22;-1:-1:-1;;;;;;121706:1364:0:o;80811:166::-;80919:26;;;80873:7;80919:26;;;:17;:26;;;;;;80901:15;;68862:4;;80901:44;;;:::i;103173:483::-;72562:5;;103339:20;;72562:5;;72548:10;:19;;:74;;;72571:51;72589:10;72601:20;72571:17;:51::i;:::-;72540:107;;;;;;;14355:2:1;72540:107:0;;;14337:21:1;14394:2;14374:18;;;14367:30;14433:22;14413:18;;;14406:50;14473:18;;72540:107:0;14153:344:1;72540:107:0;103390:42:::1;::::0;::::1;;::::0;;;:20:::1;:42;::::0;;;;;103372:17:::1;:61:::0;;103436:9;;103390:42;103372:61;::::1;;;;;:::i;:::-;;;;;;;;:73;;;;103519:25;103456:16;103473:20;:42;103494:20;103473:42;;;;;;;;;;;;;;;;103456:60;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;;;;::::1;:88:::0;;;::::1;;::::0;;::::1;;::::0;;103574:42;;::::1;::::0;;:20:::1;:42:::0;;;;;;;103555:18:::1;:62:::0;;103620:28;;103574:42;103555:62;::::1;;;;;:::i;:::-;;;;;;;;;:93;;;;;;;;;;;;;;;;;;103173:483:::0;;;;;:::o;86485:800::-;86565:34;;;;;;;:19;:34;;;;;;;;86557:60;;;;;;;18481:2:1;86557:60:0;;;18463:21:1;18520:2;18500:18;;;18493:30;18559:15;18539:18;;;18532:43;18592:18;;86557:60:0;18279:337:1;86557:60:0;86636:36;;;;;;;:21;:36;;;;;;;;86673:10;86636:48;;;;;;;;;;86628:90;;;;;;;18823:2:1;86628:90:0;;;18805:21:1;18862:2;18842:18;;;18835:30;18901:31;18881:18;;;18874:59;18950:18;;86628:90:0;18621:353:1;86628:90:0;86864:10;86813:22;86838:37;;;:25;:37;;;;;;;;86890:28;;86886:182;;87045:10;87027:29;;;;:17;:29;;;;;;;;;;86990:33;;;;;;;;;:66;;87027:29;;86990:33;;:66;;87027:29;;86990:66;:::i;:::-;;;;-1:-1:-1;;86886:182:0;87136:10;87110:37;;;;:25;:37;;;;;;;;:53;;;;:37;:53;;;;;;;;87248:17;:29;;;;;;87212:32;;;;;;;;:65;;87248:29;;87212:32;;:65;;87248:29;;87212:65;:::i;:::-;;;;-1:-1:-1;;;;86485:800:0:o;103976:207::-;72562:5;;104084:20;;72562:5;;72548:10;:19;;:74;;;72571:51;72589:10;72601:20;72571:17;:51::i;:::-;72540:107;;;;;;;14355:2:1;72540:107:0;;;14337:21:1;14394:2;14374:18;;;14367:30;14433:22;14413:18;;;14406:50;14473:18;;72540:107:0;14153:344:1;72540:107:0;-1:-1:-1;104117:36:0::1;::::0;;::::1;;::::0;;;:14:::1;:36;::::0;;;;:58;;;::::1;::::0;;;::::1;;::::0;;103976:207::o;99748:97::-;72359:5;;;;72345:10;:19;;:79;;-1:-1:-1;72382:42:0;72368:10;:56;72345:79;72337:113;;;;;;;12547:2:1;72337:113:0;;;12529:21:1;12586:2;12566:18;;;12559:30;12625:23;12605:18;;;12598:51;12666:18;;72337:113:0;12345:345:1;72337:113:0;99823:14:::1;::::0;;99805:32;;::::1;99823:14;::::0;;::::1;99822:15;99805:32;::::0;;99748:97::o;85719:610::-;85818:10;85798:31;;;;:19;:31;;;;;;;;85790:57;;;;;;;18481:2:1;85790:57:0;;;18463:21:1;18520:2;18500:18;;;18493:30;18559:15;18539:18;;;18532:43;18592:18;;85790:57:0;18279:337:1;85790:57:0;85933:10;85911:33;;;;:21;:33;;;;;;;;;:49;;;;;;;;;;;;;;;;85910:50;85858:102;;;;;;;86063:25;:41;;;;;;;;:55;86059:263;;86134:41;;;86186:1;86134:41;;;:25;:41;;;;;;;;:54;;;;;;86277:17;:33;;;;;;86262:10;86244:29;;;;;;;:66;;86277:33;;86244:29;;:66;;86277:33;;86244:66;:::i;:::-;;;;-1:-1:-1;;86059:263:0;85719:610;:::o;75941:452::-;76002:16;76031:32;76066:16;76083:9;76066:27;;;;;;;;:::i;:::-;;;;;;;;;;;;;;-1:-1:-1;76108:38:0;;76104:282;;76289:4;76247:27;76275:9;76247:38;;;;;;;;:::i;:::-;;;;;;;;;76196:24;76175:67;;;:69;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:110;;;;:::i;:::-;76174:119;;;;:::i;:::-;76163:130;;76104:282;;;76346:17;76364:9;76346:28;;;;;;;;:::i;:::-;;;;;;;;;76335:39;;76020:373;75941:452;;;:::o;97320:761::-;97437:9;97432:642;97456:16;:23;97452:27;;97432:642;;;97501:32;97536:16;97553:1;97536:19;;;;;;;;:::i;:::-;;;;;;;;;;;;;;-1:-1:-1;97574:38:0;;97570:493;;97637:12;:61;;;;97672:22;97695:1;97672:25;;;;;;;;:::i;:::-;;;;;;;;;97654:15;:43;97637:61;97633:415;;;97812:106;;;;;97895:4;97812:106;;;19153:74:1;97902:15:0;19243:18:1;;;19236:34;97812:74:0;;;;;;19126:18:1;;97812:106:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;97779:27;97807:1;97779:30;;;;;;;;:::i;:::-;;;;;;;;:139;;;;97990:24;97969:57;;;:59;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;97941:22;97964:1;97941:25;;;;;;;;:::i;:::-;;;;;;;;;;:87;97633:415;-1:-1:-1;97481:3:0;;;;:::i;:::-;;;;97432:642;;;;97320:761;:::o;101661:958::-;72359:5;;;;72345:10;:19;;:79;;-1:-1:-1;72382:42:0;72368:10;:56;72345:79;72337:113;;;;;;;12547:2:1;72337:113:0;;;12529:21:1;12586:2;12566:18;;;12559:30;12625:23;12605:18;;;12598:51;12666:18;;72337:113:0;12345:345:1;72337:113:0;102070:13;;68862:4:::1;-1:-1:-1::0;102070:37:0::1;102062:69;;;::::0;::::1;::::0;;19483:2:1;102062:69:0::1;::::0;::::1;19465:21:1::0;19522:2;19502:18;;;19495:30;19561:21;19541:18;;;19534:49;19600:18;;102062:69:0::1;19281:343:1::0;102062:69:0::1;102255:13:::0;;::::1;::::0;102272:1:::1;-1:-1:-1::0;102255:18:0;::::1;::::0;102254:44:::1;;-1:-1:-1::0;102279:13:0;;::::1;::::0;102296:1:::1;-1:-1:-1::0;102279:18:0::1;102254:44;102246:69;;;::::0;::::1;::::0;;20172:2:1;102246:69:0::1;::::0;::::1;20154:21:1::0;20211:2;20191:18;;;20184:30;20250:14;20230:18;;;20223:42;20282:18;;102246:69:0::1;19970:336:1::0;102246:69:0::1;102350:13:::0;;102328:19:::1;:35:::0;102350:13:::1;102397::::0;::::1;::::0;102374:20:::1;:36:::0;102452:13;;::::1;::::0;102421:28:::1;:44:::0;102503:13;;::::1;::::0;102476:24:::1;:40:::0;102558:13;;::::1;::::0;102527:28:::1;:44:::0;102598:13;::::1;::::0;102582::::1;:29:::0;101661:958::o;98180:363::-;98263:25;98282:5;98263:18;:25::i;:::-;98358:16;:14;:16::i;:::-;98340:15;:34;98410:12;;98391:15;:31;98387:149;;98439:14;:12;:14::i;:::-;98180:363::o;98387:149::-;98495:29;:27;:29::i;125550:1651::-;125725:7;126053:13;:50;;;-1:-1:-1;126071:32:0;;;;;;;126070:33;126053:50;126049:246;;;126105:53;126116:14;126132:19;126153:4;126105:10;:53::i;:::-;;126049:246;;;126231:52;126255:14;126271:4;126277:5;126231:23;:52::i;:::-;126348:28;126378:21;126403:33;126413:14;126429:6;126403:9;:33::i;:::-;126347:89;;;;126474:9;:26;;;126455:15;:45;;:71;;;-1:-1:-1;126504:14:0;;;;:22;;:14;:22;126455:71;126447:106;;;;;;;20513:2:1;126447:106:0;;;20495:21:1;20552:2;20532:18;;;20525:30;20591:24;20571:18;;;20564:52;20633:18;;126447:106:0;20311:346:1;126447:106:0;126584:19;;;;126620:13;;126616:549;;126800:12;;126764:82;;126800:12;;;;;126815:19;126836:9;126764:27;:82::i;:::-;126918:28;;;;;;;:12;:28;;;;;:43;;126947:13;;126918:43;;;;;;:::i;:::-;;;;;;;;;;;;;126911:50;;;;;;;;;;;;;;;;;;;;;;;;;;127013:48;;127028:14;;127044:9;;127013:14;:48::i;:::-;127083:70;;;20864:25:1;;;20920:2;20905:18;;20898:34;;;127083:70:0;20968:55:1;;;20948:18;;;20941:83;127083:70:0;;;;;;;;;;;20852:2:1;127083:70:0;;;126616:549;127184:9;125550:1651;-1:-1:-1;;;;;;;125550:1651:0:o;59049:106::-;59107:7;59138:1;59134;:5;:13;;59146:1;59134:13;;;59142:1;59134:13;59127:20;59049:106;-1:-1:-1;;;59049:106:0:o;123591:1358::-;123837:7;123806:14;123822:4;72753:49;72777:7;72786:8;72796:5;72753:23;:49::i;:::-;123865:13:::1;::::0;;;::::1;;;:22;123857:49;;;::::0;::::1;::::0;;21237:2:1;123857:49:0::1;::::0;::::1;21219:21:1::0;21276:2;21256:18;;;21249:30;21315:16;21295:18;;;21288:44;21349:18;;123857:49:0::1;21035:338:1::0;123857:49:0::1;123933:13;;123925:4;:21;;123917:60;;;::::0;::::1;::::0;;17374:2:1;123917:60:0::1;::::0;::::1;17356:21:1::0;17413:2;17393:18;;;17386:30;17452:28;17432:18;;;17425:56;17498:18;;123917:60:0::1;17172:350:1::0;123917:60:0::1;124004:28;;123996:4;:36;;123988:75;;;::::0;::::1;::::0;;17729:2:1;123988:75:0::1;::::0;::::1;17711:21:1::0;17768:2;17748:18;;;17741:30;17807:29;17787:18;;;17780:57;17854:18;;123988:75:0::1;17527:351:1::0;123988:75:0::1;124186:12;::::0;124146:96:::1;::::0;124186:12;;::::1;;;124201:14:::0;124225:4:::1;124232:9:::0;124146:31:::1;:96::i;:::-;124302:23;124328:20;124343:4;124328:14;:20::i;:::-;124447:33;::::0;::::1;124359:14;124447:33:::0;;;:17:::1;:33;::::0;;;;;;;;124386:95;;21624:66:1;21611:2;21607:15;;;21603:88;124386:95:0;;::::1;21591:101:1::0;;;;21708:12;;;21701:28;;;21745:12;;;21738:28;;;21782:12;;;21775:28;124302:46:0;;-1:-1:-1;124359:14:0;21819:13:1;;124386:95:0::1;::::0;;;;;::::1;::::0;;;;;;124376:106;;124386:95:::1;124376:106:::0;;::::1;::::0;124539:28:::1;::::0;::::1;;::::0;;;:12:::1;:28:::0;;;;;124573:164:::1;::::0;::::1;::::0;;;;;;;::::1;::::0;;;;;;;;;124376:106;;-1:-1:-1;124539:28:0;124573:164;;;124674:22:::1;124692:4:::0;124620:15;124674:22:::1;:::i;:::-;124573:164:::0;;::::1;::::0;;::::1;::::0;;;124539:199;;::::1;::::0;;::::1;::::0;;-1:-1:-1;124539:199:0;;;;;;;;;::::1;::::0;;::::1;;::::0;;;;;::::1;::::0;;;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;::::1;::::0;;::::1;::::0;::::1;::::0;;::::1;::::0;124782:47:::1;::::0;124797:14;;124813:9;;124782:14:::1;:47::i;:::-;124847:68;::::0;;22074:25:1;;;22130:2;22115:18;;22108:34;;;22158:18;;;22151:34;;;124847:68:0::1;22221:55:1::0;;;22216:2;22201:18;;22194:83;124847:68:0;::::1;::::0;::::1;::::0;22061:3:1;22046:19;124847:68:0::1;;;;;;;124935:6:::0;123591:1358;-1:-1:-1;;;;;;;;;123591:1358:0:o;75619:133::-;75678:7;75705:39;75714:15;75731:12;;75705:8;:39::i;:::-;75698:46;;75619:133;:::o;91688:1194::-;91836:31;91811:8;91821:4;72753:49;72777:7;72786:8;72796:5;72753:23;:49::i;:::-;91966:29:::1;::::0;::::1;;::::0;;;:19:::1;:29;::::0;;;;91998:15:::1;91966:47:::0;;92096:23:::1;::::0;;;::::1;;;:32;92088:70;;;::::0;::::1;::::0;;12897:2:1;92088:70:0::1;::::0;::::1;12879:21:1::0;12936:2;12916:18;;;12909:30;12975:27;12955:18;;;12948:55;13020:18;;92088:70:0::1;12695:349:1::0;92088:70:0::1;92270:12;:19:::0;92256:34:::1;::::0;::::1;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;-1:-1:-1;92256:34:0::1;;92239:51;;92308:9;92303:419;92327:12;:19:::0;92323:23;::::1;92303:419;;;92388:17;::::0;::::1;;::::0;;;:7:::1;:17;::::0;;;;;;;:20;;;;;;;;;92368:17;;:14;;92406:1;;92368:17;::::1;;;;;:::i;:::-;;::::0;;::::1;::::0;;;;;;:40;;;;92423:17:::1;::::0;::::1;92446:1;92423:17:::0;;;:7:::1;:17:::0;;;;;;:20;;;;;;;;;:24;;;92466:17;;:14;;92441:1;;92466:17;::::1;;;;;:::i;:::-;;;;;;;:21;92462:249;;;92508:84;92536:12;92549:1;92536:15;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;92553:19;92574:14;92589:1;92574:17;;;;;;;;:::i;:::-;;;;;;;92508:27;:84::i;:::-;92629:8;92618:77;;;92639:14;92654:1;92639:17;;;;;;;;:::i;:::-;;;;;;;92658:12;92671:1;92658:15;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;;::::1;::::0;92618:77:::1;::::0;;22490:25:1;;;92658:15:0::1;::::0;;::::1;22592:18:1::0;;;22585:43;;;;22664:15;;22644:18;;;22637:43;22478:2;22463:18;92618:77:0::1;;;;;;;92462:249;92348:3:::0;::::1;::::0;::::1;:::i;:::-;;;;92303:419;;;;91688:1194:::0;;;;;;;:::o;62643:361::-;62838:45;;;62827:10;19171:55:1;;;62838:45:0;;;19153:74:1;19243:18;;;;19236:34;;;62838:45:0;;;;;;;;;;19126:18:1;;;;62838:45:0;;;;;;;;;;;;;62827:57;;-1:-1:-1;;;;62827:10:0;;;;:57;;62838:45;62827:57;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62791:93;;;;62903:7;:57;;;;-1:-1:-1;62915:11:0;;:16;;:44;;;62946:4;62935:24;;;;;;;;;;;;:::i;:::-;62895:101;;;;;;;23690:2:1;62895:101:0;;;23672:21:1;23729:2;23709:18;;;23702:30;23768:33;23748:18;;;23741:61;23819:18;;62895:101:0;23488:355:1;62895:101:0;62713:291;;62643:361;;;:::o;87601:1788::-;87817:8;87813:46;;;87841:6;:4;:6::i;:::-;87991:19;87987:109;;;88060:24;88076:7;88060:15;:24::i;:::-;88026:31;;;;;;;:22;:31;;;;;:58;87987:109;88120:21;;;;88116:1266;;88334:27;88380:28;88427:27;88472:30;88494:7;88472:21;:30::i;:::-;88312:190;;;;;;88564:20;88576:7;88564:11;:20::i;:::-;88660:31;;;;;;;:22;:31;;;;;:54;;;88801:42;;;88797:572;;88864:19;88886:41;88908:19;88886;:41;:::i;:::-;88864:63;;88996:11;88971:22;;:36;;;;:::i;:::-;88946:22;:61;89055:33;89077:11;89055:19;:33;:::i;:::-;89026:26;;;;;;;:17;:26;;;;;:62;-1:-1:-1;88797:572:0;;;89129:19;89151:41;89173:19;89151;:41;:::i;:::-;89129:63;;89261:11;89236:22;;:36;;;;:::i;:::-;89211:22;:61;89320:33;89342:11;89320:19;:33;:::i;:::-;89291:26;;;;;;;:17;:26;;;;;:62;-1:-1:-1;88797:572:0;88143:1239;;;87601:1788;;;:::o;120075:508::-;120157:31;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;120157:31:0;120190:15;;120218:280;120242:28;;;;;;;:12;:28;;;;;:35;120238:39;;120218:280;;;120313:28;;;;;;;:12;:28;;;;;:31;;120342:1;;120313:31;;;;;;:::i;:::-;;;;;;;;;;;:38;;;120303:6;:48;120299:188;;120386:28;;;;;;;:12;:28;;;;;:31;;120415:1;;120386:31;;;;;;:::i;:::-;;;;;;;;;;;120371:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;120446:1;120436:11;;120466:5;;120299:188;120279:3;;;;:::i;:::-;;;;120218:280;;;-1:-1:-1;120516:19:0;;:29;;120508:57;;;;;;;24050:2:1;120508:57:0;;;24032:21:1;24089:2;24069:18;;;24062:30;24128:17;24108:18;;;24101:45;24163:18;;120508:57:0;23848:339:1;120508:57:0;120075:508;;;;;:::o;63012:402::-;63237:51;;;63226:10;24473:15:1;;;63237:51:0;;;24455:34:1;24525:15;;;24505:18;;;24498:43;24557:18;;;;24550:34;;;63237:51:0;;;;;;;;;;24367:18:1;;;;63237:51:0;;;;;;;;;;;;;63226:63;;-1:-1:-1;;;;63226:10:0;;;;:63;;63237:51;63226:63;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63190:99;;;;63308:7;:57;;;;-1:-1:-1;63320:11:0;;:16;;:44;;;63351:4;63340:24;;;;;;;;;;;;:::i;:::-;63300:106;;;;;;;24797:2:1;63300:106:0;;;24779:21:1;24836:2;24816:18;;;24809:30;24875:34;24855:18;;;24848:62;24946:6;24926:18;;;24919:34;24970:19;;63300:106:0;24595:400:1;119190:877:0;119318:17;119338:27;119350:14;119338:11;:27::i;:::-;119318:47;;119382:6;119378:561;;;119473:3;119446:23;;:30;;;;;;;:::i;:::-;;;;-1:-1:-1;;119491:33:0;;;;;;;:17;:33;;;;;:40;;119528:3;;119491:33;:40;;119528:3;;119491:40;:::i;:::-;;;;-1:-1:-1;;119585:23:0;;;;119581:64;;119610:28;;;;;;;:17;:28;;;;;:35;;119642:3;;119610:28;:35;;119642:3;;119610:35;:::i;:::-;;;;-1:-1:-1;;119581:64:0;119378:561;;;119755:3;119728:23;;:30;;;;;;;:::i;:::-;;;;-1:-1:-1;;119773:33:0;;;;;;;:17;:33;;;;;:40;;119810:3;;119773:33;:40;;119810:3;;119773:40;:::i;:::-;;;;-1:-1:-1;;119867:23:0;;;;119863:64;;119892:28;;;;;;;:17;:28;;;;;:35;;119924:3;;119892:28;:35;;119924:3;;119892:35;:::i;:::-;;;;-1:-1:-1;;119863:64:0;120007:52;120031:14;120047:5;120054:4;120007:23;:52::i;92969:3748::-;93056:29;:27;:29::i;:::-;93175:9;93170:327;93194:18;:25;93190:29;;93170:327;;;93241:34;93278:18;93297:1;93278:21;;;;;;;;:::i;:::-;;;;;;;;;;;;;;-1:-1:-1;93318:40:0;;93314:172;;93379:91;;;;;93464:4;93379:91;;;4232:74:1;93379:76:0;;;;;;4205:18:1;;93379:91:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;93314:172;-1:-1:-1;93221:3:0;;;;:::i;:::-;;;;93170:327;;;;93857:27;70593:6;93913:12;;93895:15;:30;;;;:::i;:::-;93887:57;;;;:::i;:::-;93857:87;;94083:9;94078:284;94102:12;:19;94098:23;;94078:284;;;94224:12;94237:1;94224:15;;;;;;;;:::i;:::-;;;;;;;;;;;94217:48;;;;;94259:4;94217:48;;;4232:74:1;94224:15:0;;;;;94217:33;;4205:18:1;;94217:48:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;94188:23;:19;94210:1;94188:23;:::i;:::-;70593:6;94152:14;94164:1;94152:11;:14::i;:::-;:32;;;;:::i;:::-;:60;;;;:::i;:::-;94151:114;;94331:12;94344:1;94331:15;;;;;;;;:::i;:::-;;;;;;;;;;;;94274:73;;;25492:34:1;94274:73:0;;;25480:47:1;;;;25557:6;25543:12;;;25536:28;25602:2;25598:15;;;25580:12;;;25573:110;25699:12;;94274:73:0;;;;;;;;;;;;94143:207;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;94123:3:0;;;;:::i;:::-;;;;94078:284;;;-1:-1:-1;70593:6:0;94574:23;:19;94596:1;94574:23;:::i;:::-;94573:43;;;;:::i;:::-;94557:12;;:60;;;;:::i;:::-;94542:12;:75;96680:29;96725:435;96812:34;96849:17;:15;:17::i;:::-;96812:54;;96929:9;96924:133;96948:21;:28;96944:32;;96924:133;;;97025:17;97043:1;97025:20;;;;;;;;:::i;:::-;;;;;;;96998:21;97020:1;96998:24;;;;;;;;:::i;:::-;;;;;;;;;;:47;96978:3;;;;:::i;:::-;;;;96924:133;;;;97126:26;:24;:26::i;:::-;97109:14;:43;-1:-1:-1;96725:435:0:o;89397:585::-;89459:21;;;;89455:520;;89536:27;89566:15;89573:7;89566:6;:15::i;:::-;89536:45;;89644:9;89639:118;89663:10;:17;89659:1;:21;89639:118;;;89728:10;89739:1;89728:13;;;;;;;;:::i;:::-;;;;;;;;;;;;89706:16;;;;;;;:7;:16;;;;;;:19;;;;;;;;;;:35;89723:1;89682:3;89723:1;89682:3;:::i;:::-;;;;89639:118;;;;89824:9;89819:145;89843:10;:17;89839:1;:21;89819:145;;;89924:21;89946:1;89924:24;;;;;;;;:::i;:::-;;;;;;;;;;;;;89886:32;;;;;:23;:32;;;;;;:35;;;;;;;;:62;89919:1;89862:3;89919:1;89862:3;:::i;:::-;;;;89819:145;;14:196:1;82:20;;142:42;131:54;;121:65;;111:93;;200:1;197;190:12;215:186;274:6;327:2;315:9;306:7;302:23;298:32;295:52;;;343:1;340;333:12;295:52;366:29;385:9;366:29;:::i;406:632::-;577:2;629:21;;;699:13;;602:18;;;721:22;;;548:4;;577:2;800:15;;;;774:2;759:18;;;548:4;843:169;857:6;854:1;851:13;843:169;;;918:13;;906:26;;987:15;;;;952:12;;;;879:1;872:9;843:169;;;-1:-1:-1;1029:3:1;;406:632;-1:-1:-1;;;;;;406:632:1:o;1043:118::-;1129:5;1122:13;1115:21;1108:5;1105:32;1095:60;;1151:1;1148;1141:12;1166:383;1240:6;1248;1256;1309:2;1297:9;1288:7;1284:23;1280:32;1277:52;;;1325:1;1322;1315:12;1277:52;1361:9;1348:23;1338:33;;1390:38;1424:2;1413:9;1409:18;1390:38;:::i;:::-;1380:48;;1478:2;1467:9;1463:18;1450:32;1491:28;1513:5;1491:28;:::i;:::-;1538:5;1528:15;;;1166:383;;;;;:::o;1736:180::-;1795:6;1848:2;1836:9;1827:7;1823:23;1819:32;1816:52;;;1864:1;1861;1854:12;1816:52;-1:-1:-1;1887:23:1;;1736:180;-1:-1:-1;1736:180:1:o;1921:681::-;2092:2;2144:21;;;2214:13;;2117:18;;;2236:22;;;2063:4;;2092:2;2315:15;;;;2289:2;2274:18;;;2063:4;2358:218;2372:6;2369:1;2366:13;2358:218;;;2437:13;;2452:42;2433:62;2421:75;;2551:15;;;;2516:12;;;;2394:1;2387:9;2358:218;;2607:248;2675:6;2683;2736:2;2724:9;2715:7;2711:23;2707:32;2704:52;;;2752:1;2749;2742:12;2704:52;-1:-1:-1;;2775:23:1;;;2845:2;2830:18;;;2817:32;;-1:-1:-1;2607:248:1:o;3042:1011::-;3271:2;3323:21;;;3393:13;;3296:18;;;3415:22;;;3242:4;;3271:2;3456;;3474:18;;;;3515:15;;;3242:4;3558:469;3572:6;3569:1;3566:13;3558:469;;;3631:13;;3669:9;;3657:22;;3719:11;;;3713:18;3699:12;;;3692:40;3772:11;;;3766:18;3752:12;;;3745:40;3808:4;3852:11;;;3846:18;3832:12;;;3825:40;3888:4;3932:11;;;3926:18;3912:12;;;3905:40;3974:4;3965:14;;;;4002:15;;;;3594:1;3587:9;3558:469;;;-1:-1:-1;4044:3:1;;3042:1011;-1:-1:-1;;;;;;;3042:1011:1:o;4317:260::-;4385:6;4393;4446:2;4434:9;4425:7;4421:23;4417:32;4414:52;;;4462:1;4459;4452:12;4414:52;4485:29;4504:9;4485:29;:::i;:::-;4475:39;;4533:38;4567:2;4556:9;4552:18;4533:38;:::i;:::-;4523:48;;4317:260;;;;;:::o;5005:647::-;5079:6;5087;5095;5103;5156:3;5144:9;5135:7;5131:23;5127:33;5124:53;;;5173:1;5170;5163:12;5124:53;5212:9;5199:23;5231:28;5253:5;5231:28;:::i;:::-;5278:5;-1:-1:-1;5335:2:1;5320:18;;5307:32;5348:30;5307:32;5348:30;:::i;:::-;5397:7;-1:-1:-1;5456:2:1;5441:18;;5428:32;5469:30;5428:32;5469:30;:::i;:::-;5518:7;-1:-1:-1;5577:2:1;5562:18;;5549:32;5590:30;5549:32;5590:30;:::i;:::-;5005:647;;;;-1:-1:-1;5005:647:1;;-1:-1:-1;;5005:647:1:o;6173:254::-;6241:6;6249;6302:2;6290:9;6281:7;6277:23;6273:32;6270:52;;;6318:1;6315;6308:12;6270:52;6341:29;6360:9;6341:29;:::i;:::-;6331:39;6417:2;6402:18;;;;6389:32;;-1:-1:-1;;;6173:254:1:o;6432:315::-;6497:6;6505;6558:2;6546:9;6537:7;6533:23;6529:32;6526:52;;;6574:1;6571;6564:12;6526:52;6597:29;6616:9;6597:29;:::i;:::-;6587:39;;6676:2;6665:9;6661:18;6648:32;6689:28;6711:5;6689:28;:::i;:::-;6736:5;6726:15;;;6432:315;;;;;:::o;7977:403::-;8063:6;8071;8079;8087;8140:3;8128:9;8119:7;8115:23;8111:33;8108:53;;;8157:1;8154;8147:12;8108:53;8180:29;8199:9;8180:29;:::i;:::-;8170:39;;8256:2;8245:9;8241:18;8228:32;8218:42;;8279:38;8313:2;8302:9;8298:18;8279:38;:::i;:::-;8269:48;;8336:38;8370:2;8359:9;8355:18;8336:38;:::i;:::-;8326:48;;7977:403;;;;;;;:::o;8385:241::-;8441:6;8494:2;8482:9;8473:7;8469:23;8465:32;8462:52;;;8510:1;8507;8500:12;8462:52;8549:9;8536:23;8568:28;8590:5;8568:28;:::i;8631:184::-;8683:77;8680:1;8673:88;8780:4;8777:1;8770:15;8804:4;8801:1;8794:15;8820:915;8902:6;8955:3;8943:9;8934:7;8930:23;8926:33;8923:53;;;8972:1;8969;8962:12;8923:53;9021:7;9014:4;9003:9;8999:20;8995:34;8985:62;;9043:1;9040;9033:12;8985:62;9076:2;9070:9;9118:3;9110:6;9106:16;9188:6;9176:10;9173:22;9152:18;9140:10;9137:34;9134:62;9131:242;;;9229:77;9226:1;9219:88;9330:4;9327:1;9320:15;9358:4;9355:1;9348:15;9131:242;9389:2;9382:22;9424:6;9468:3;9453:19;;9484;;;9481:39;;;9516:1;9513;9506:12;9481:39;9540:9;9558:146;9574:6;9569:3;9566:15;9558:146;;;9642:17;;9630:30;;9689:4;9680:14;;;;9591;9558:146;;;-1:-1:-1;9723:6:1;;8820:915;-1:-1:-1;;;;;8820:915:1:o;9740:184::-;9792:77;9789:1;9782:88;9889:4;9886:1;9879:15;9913:4;9910:1;9903:15;9929:184;9981:77;9978:1;9971:88;10078:4;10075:1;10068:15;10102:4;10099:1;10092:15;10118:128;10185:9;;;10206:11;;;10203:37;;;10220:18;;:::i;10251:168::-;10324:9;;;10355;;10372:15;;;10366:22;;10352:37;10342:71;;10393:18;;:::i;10424:274::-;10464:1;10490;10480:189;;10525:77;10522:1;10515:88;10626:4;10623:1;10616:15;10654:4;10651:1;10644:15;10480:189;-1:-1:-1;10683:9:1;;10424:274::o;10703:125::-;10768:9;;;10789:10;;;10786:36;;;10802:18;;:::i;10833:195::-;10872:3;10903:66;10896:5;10893:77;10890:103;;10973:18;;:::i;:::-;-1:-1:-1;11020:1:1;11009:13;;10833:195::o;12156:184::-;12226:6;12279:2;12267:9;12258:7;12254:23;12250:32;12247:52;;;12295:1;12292;12285:12;12247:52;-1:-1:-1;12318:16:1;;12156:184;-1:-1:-1;12156:184:1:o;15455:179::-;15533:13;;15586:22;15575:34;;15565:45;;15555:73;;15624:1;15621;15614:12;15639:473;15742:6;15750;15758;15766;15774;15827:3;15815:9;15806:7;15802:23;15798:33;15795:53;;;15844:1;15841;15834:12;15795:53;15867:39;15896:9;15867:39;:::i;:::-;15857:49;;15946:2;15935:9;15931:18;15925:25;15915:35;;15990:2;15979:9;15975:18;15969:25;15959:35;;16034:2;16023:9;16019:18;16013:25;16003:35;;16057:49;16101:3;16090:9;16086:19;16057:49;:::i;:::-;16047:59;;15639:473;;;;;;;;:::o;22691:250::-;22776:1;22786:113;22800:6;22797:1;22794:13;22786:113;;;22876:11;;;22870:18;22857:11;;;22850:39;22822:2;22815:10;22786:113;;;-1:-1:-1;;22933:1:1;22915:16;;22908:27;22691:250::o;22946:287::-;23075:3;23113:6;23107:13;23129:66;23188:6;23183:3;23176:4;23168:6;23164:17;23129:66;:::i;:::-;23211:16;;;;;22946:287;-1:-1:-1;;22946:287:1:o;23238:245::-;23305:6;23358:2;23346:9;23337:7;23333:23;23329:32;23326:52;;;23374:1;23371;23364:12;23326:52;23406:9;23400:16;23425:28;23447:5;23425:28;:::i;25000:245::-;25079:6;25087;25140:2;25128:9;25119:7;25115:23;25111:32;25108:52;;;25156:1;25153;25146:12;25108:52;-1:-1:-1;;25179:16:1;;25235:2;25220:18;;;25214:25;25179:16;;25214:25;;-1:-1:-1;25000:245:1:o;25722:455::-;25871:2;25860:9;25853:21;25834:4;25903:6;25897:13;25946:6;25941:2;25930:9;25926:18;25919:34;25962:79;26034:6;26029:2;26018:9;26014:18;26009:2;26001:6;25997:15;25962:79;:::i;:::-;26093:2;26081:15;26098:66;26077:88;26062:104;;;;26168:2;26058:113;;25722:455;-1:-1:-1;;25722:455:1:o
Swarm Source
ipfs://6c1175923d19d82379e75426b015a77db693f76234fbdbae7c2c9f34a5499c6a
Loading...
Loading
Loading...
Loading
Loading...
Loading
[ Download: CSV Export ]
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.