Contract 0x86d36e2c6c3d7eb7a740cf136d37a9a0edb4fa8d 2
Contract Overview
My Name Tag:
Not Available
[ Download CSV Export ]
Latest 25 internal transaction
[ Download CSV Export ]
This contract may be a proxy contract. Click on More Options and select Is this a proxy? to confirm and enable the "Read as Proxy" & "Write as Proxy" tabs.
Contract Name:
StrategyBalancerBalWethLp
Compiler Version
v0.6.12+commit.27d51765
Contract Source Code (Solidity)
/** *Submitted for verification at Arbiscan.io on 2022-01-08 */ // Sources flattened with hardhat v2.6.8 https://hardhat.org // File src/lib/safe-math.sol // SPDX-License-Identifier: MIT pragma solidity ^0.6.0; /** * @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. */ 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. */ function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { 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. */ function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } // File src/lib/context.sol pragma solidity ^0.6.0; /* * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with 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 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 src/lib/erc20.sol // File: contracts/GSN/Context.sol pragma solidity ^0.6.0; // File: contracts/token/ERC20/IERC20.sol /** * @dev Interface of the ERC20 standard as defined in the EIP. */ 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/utils/Address.sol /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success, ) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain`call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return _functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); return _functionCallWithValue(target, data, value, errorMessage); } function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) { require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: weiValue }(data); if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } // File: contracts/token/ERC20/ERC20.sol /** * @dev Implementation of the {IERC20} interface. * * This implementation is agnostic to the way tokens are created. This means * that a supply mechanism has to be added in a derived contract using {_mint}. * For a generic mechanism see {ERC20PresetMinterPauser}. * * TIP: For a detailed writeup see our guide * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How * to implement supply mechanisms]. * * We have followed general OpenZeppelin guidelines: functions revert instead * of returning `false` on failure. This behavior is nonetheless conventional * and does not conflict with the expectations of ERC20 applications. * * Additionally, an {Approval} event is emitted on calls to {transferFrom}. * This allows applications to reconstruct the allowance for all accounts just * by listening to said events. Other implementations of the EIP may not emit * these events, as it isn't required by the specification. * * Finally, the non-standard {decreaseAllowance} and {increaseAllowance} * functions have been added to mitigate the well-known issues around setting * allowances. See {IERC20-approve}. */ contract ERC20 is Context, IERC20 { using SafeMath for uint256; using Address for address; mapping (address => uint256) private _balances; mapping (address => mapping (address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; uint8 private _decimals; /** * @dev Sets the values for {name} and {symbol}, initializes {decimals} with * a default value of 18. * * To select a different value for {decimals}, use {_setupDecimals}. * * All three of these values are immutable: they can only be set once during * construction. */ constructor (string memory name, string memory symbol) public { _name = name; _symbol = symbol; _decimals = 18; } /** * @dev Returns the name of the token. */ function name() public view returns (string memory) { return _name; } /** * @dev Returns the symbol of the token, usually a shorter version of the * name. */ function symbol() public view returns (string memory) { return _symbol; } /** * @dev Returns the number of decimals used to get its user representation. * For example, if `decimals` equals `2`, a balance of `505` tokens should * be displayed to a user as `5,05` (`505 / 10 ** 2`). * * Tokens usually opt for a value of 18, imitating the relationship between * Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is * called. * * NOTE: This information is only used for _display_ purposes: it in * no way affects any of the arithmetic of the contract, including * {IERC20-balanceOf} and {IERC20-transfer}. */ function decimals() public view returns (uint8) { return _decimals; } /** * @dev See {IERC20-totalSupply}. */ function totalSupply() public view override returns (uint256) { return _totalSupply; } /** * @dev See {IERC20-balanceOf}. */ function balanceOf(address account) public view override returns (uint256) { return _balances[account]; } /** * @dev See {IERC20-transfer}. * * Requirements: * * - `recipient` cannot be the zero address. * - the caller must have a balance of at least `amount`. */ function transfer(address recipient, uint256 amount) public virtual override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } /** * @dev See {IERC20-allowance}. */ function allowance(address owner, address spender) public view virtual override returns (uint256) { return _allowances[owner][spender]; } /** * @dev See {IERC20-approve}. * * Requirements: * * - `spender` cannot be the zero address. */ function approve(address spender, uint256 amount) public virtual override returns (bool) { _approve(_msgSender(), spender, amount); return true; } /** * @dev See {IERC20-transferFrom}. * * Emits an {Approval} event indicating the updated allowance. This is not * required by the EIP. See the note at the beginning of {ERC20}; * * Requirements: * - `sender` and `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. * - the caller must have allowance for ``sender``'s tokens of at least * `amount`. */ function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } /** * @dev Atomically increases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. */ function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } /** * @dev Atomically decreases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. * - `spender` must have allowance for the caller of at least * `subtractedValue`. */ function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } /** * @dev Moves tokens `amount` from `sender` to `recipient`. * * This is internal function is equivalent to {transfer}, and can be used to * e.g. implement automatic token fees, slashing mechanisms, etc. * * Emits a {Transfer} event. * * Requirements: * * - `sender` cannot be the zero address. * - `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. */ function _transfer(address sender, address recipient, uint256 amount) internal virtual { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _beforeTokenTransfer(sender, recipient, amount); _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance"); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, amount); } /** @dev Creates `amount` tokens and assigns them to `account`, increasing * the total supply. * * Emits a {Transfer} event with `from` set to the zero address. * * Requirements * * - `to` cannot be the zero address. */ function _mint(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: mint to the zero address"); _beforeTokenTransfer(address(0), account, amount); _totalSupply = _totalSupply.add(amount); _balances[account] = _balances[account].add(amount); emit Transfer(address(0), account, amount); } /** * @dev Destroys `amount` tokens from `account`, reducing the * total supply. * * Emits a {Transfer} event with `to` set to the zero address. * * Requirements * * - `account` cannot be the zero address. * - `account` must have at least `amount` tokens. */ function _burn(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: burn from the zero address"); _beforeTokenTransfer(account, address(0), amount); _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance"); _totalSupply = _totalSupply.sub(amount); emit Transfer(account, address(0), amount); } /** * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens. * * This internal function is equivalent to `approve`, and can be used to * e.g. set automatic allowances for certain subsystems, etc. * * Emits an {Approval} event. * * Requirements: * * - `owner` cannot be the zero address. * - `spender` cannot be the zero address. */ function _approve(address owner, address spender, uint256 amount) internal virtual { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } /** * @dev Sets {decimals} to a value other than the default one of 18. * * WARNING: This function should only be called from the constructor. Most * applications that interact with token contracts will not expect * {decimals} to ever change, and may work incorrectly if it does. */ function _setupDecimals(uint8 decimals_) internal { _decimals = decimals_; } /** * @dev Hook that is called before any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * will be to transferred to `to`. * - when `from` is zero, `amount` tokens will be minted for `to`. * - when `to` is zero, `amount` of ``from``'s tokens will be burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { } } /** * @title SafeERC20 * @dev Wrappers around ERC20 operations that throw on failure (when the token * contract returns false). Tokens that return no value (and instead revert or * throw on failure) are also supported, non-reverting calls are assumed to be * successful. * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract, * which allows you to call the safe operations as `token.safeTransfer(...)`, etc. */ library SafeERC20 { using SafeMath for uint256; using Address for address; function safeTransfer(IERC20 token, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } /** * @dev Deprecated. This function has issues similar to the ones found in * {IERC20-approve}, and its usage is discouraged. * * Whenever possible, use {safeIncreaseAllowance} and * {safeDecreaseAllowance} instead. */ function safeApprove(IERC20 token, address spender, uint256 value) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' // solhint-disable-next-line max-line-length require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance" ); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).add(value); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero"); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } /** * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement * on the return value: the return value is optional (but if data is returned, it must not be false). * @param token The token targeted by the call. * @param data The call data (encoded using abi.encode or one of its variants). */ function _callOptionalReturn(IERC20 token, bytes memory data) private { // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional // solhint-disable-next-line max-line-length require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } } // File src/interfaces/jar.sol pragma solidity ^0.6.2; interface IJar is IERC20 { function token() external view returns (address); function reward() external view returns (address); function claimInsurance() external; // NOTE: Only yDelegatedVault implements this function getRatio() external view returns (uint256); function depositAll() external; function balance() external view returns (uint256); function deposit(uint256) external; function withdrawAll() external; function withdraw(uint256) external; function earn() external; function decimals() external view returns (uint8); } // File src/interfaces/staking-rewards.sol pragma solidity ^0.6.2; interface IStakingRewards { function balanceOf(address account) external view returns (uint256); function earned(address account) external view returns (uint256); function exit() external; function getReward() external; function getRewardForDuration() external view returns (uint256); function lastTimeRewardApplicable() external view returns (uint256); function lastUpdateTime() external view returns (uint256); function notifyRewardAmount(uint256 reward) external; function periodFinish() external view returns (uint256); function rewardPerToken() external view returns (uint256); function rewardPerTokenStored() external view returns (uint256); function rewardRate() external view returns (uint256); function rewards(address) external view returns (uint256); function rewardsDistribution() external view returns (address); function rewardsDuration() external view returns (uint256); function rewardsToken() external view returns (address); function stake(uint256 amount) external; function deposit(uint256 amount) external; function stakeWithPermit( uint256 amount, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) external; function stakingToken() external view returns (address); function totalSupply() external view returns (uint256); function userRewardPerTokenPaid(address) external view returns (uint256); function withdraw(uint256 amount) external; } interface IStakingRewardsFactory { function deploy(address stakingToken, uint256 rewardAmount) external; function isOwner() external view returns (bool); function notifyRewardAmount(address stakingToken) external; function notifyRewardAmounts() external; function owner() external view returns (address); function renounceOwnership() external; function rewardsToken() external view returns (address); function stakingRewardsGenesis() external view returns (uint256); function stakingRewardsInfoByStakingToken(address) external view returns (address stakingRewards, uint256 rewardAmount); function stakingTokens(uint256) external view returns (address); function transferOwnership(address newOwner) external; } // File src/interfaces/masterchef.sol pragma solidity ^0.6.7; interface IMasterchef { function BONUS_MULTIPLIER() external view returns (uint256); function add( uint256 _allocPoint, address _lpToken, bool _withUpdate ) external; function bonusEndBlock() external view returns (uint256); function deposit(uint256 _pid, uint256 _amount) external; function dev(address _devaddr) external; function devFundDivRate() external view returns (uint256); function devaddr() external view returns (address); function emergencyWithdraw(uint256 _pid) external; function getMultiplier(uint256 _from, uint256 _to) external view returns (uint256); function massUpdatePools() external; function owner() external view returns (address); function pendingPickle(uint256 _pid, address _user) external view returns (uint256); function pendingReward(uint256 _pid, address _user) external view returns (uint256); function pending(uint256 _pid, address _user) external view returns (uint256); function pickle() external view returns (address); function picklePerBlock() external view returns (uint256); function poolInfo(uint256) external view returns ( address lpToken, uint256 allocPoint, uint256 lastRewardBlock, uint256 accPicklePerShare ); function poolLength() external view returns (uint256); function renounceOwnership() external; function set( uint256 _pid, uint256 _allocPoint, bool _withUpdate ) external; function setBonusEndBlock(uint256 _bonusEndBlock) external; function setDevFundDivRate(uint256 _devFundDivRate) external; function setPicklePerBlock(uint256 _picklePerBlock) external; function startBlock() external view returns (uint256); function totalAllocPoint() external view returns (uint256); function transferOwnership(address newOwner) external; function updatePool(uint256 _pid) external; function userInfo(uint256, address) external view returns (uint256 amount, uint256 rewardDebt); function withdraw(uint256 _pid, uint256 _amount) external; } // File src/interfaces/uniswapv2.sol pragma solidity ^0.6.2; interface UniswapRouterV2 { function swapExactTokensForTokens( uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline ) external returns (uint256[] memory amounts); function addLiquidity( address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline ) external returns ( uint256 amountA, uint256 amountB, uint256 liquidity ); function addLiquidityETH( address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline ) external payable returns ( uint256 amountToken, uint256 amountETH, uint256 liquidity ); function removeLiquidity( address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline ) external returns (uint256 amountA, uint256 amountB); function getAmountsOut(uint256 amountIn, address[] calldata path) external view returns (uint256[] memory amounts); function getAmountsIn(uint256 amountOut, address[] calldata path) external view returns (uint256[] memory amounts); function swapETHForExactTokens( uint256 amountOut, address[] calldata path, address to, uint256 deadline ) external payable returns (uint256[] memory amounts); function swapExactETHForTokens( uint256 amountOutMin, address[] calldata path, address to, uint256 deadline ) external payable returns (uint256[] memory amounts); } interface IUniswapV2Pair { event Approval( address indexed owner, address indexed spender, uint256 value ); event Transfer(address indexed from, address indexed to, uint256 value); function name() external pure returns (string memory); function symbol() external pure returns (string memory); function decimals() external pure returns (uint8); function totalSupply() external view returns (uint256); function balanceOf(address owner) external view returns (uint256); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 value) external returns (bool); function transfer(address to, uint256 value) external returns (bool); function transferFrom( address from, address to, uint256 value ) external returns (bool); function DOMAIN_SEPARATOR() external view returns (bytes32); function PERMIT_TYPEHASH() external pure returns (bytes32); function nonces(address owner) external view returns (uint256); function permit( address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) external; event Mint(address indexed sender, uint256 amount0, uint256 amount1); event Burn( address indexed sender, uint256 amount0, uint256 amount1, address indexed to ); event Swap( address indexed sender, uint256 amount0In, uint256 amount1In, uint256 amount0Out, uint256 amount1Out, address indexed to ); event Sync(uint112 reserve0, uint112 reserve1); function MINIMUM_LIQUIDITY() external pure returns (uint256); function factory() external view returns (address); function token0() external view returns (address); function token1() external view returns (address); function getReserves() external view returns ( uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast ); function price0CumulativeLast() external view returns (uint256); function price1CumulativeLast() external view returns (uint256); function kLast() external view returns (uint256); function mint(address to) external returns (uint256 liquidity); function burn(address to) external returns (uint256 amount0, uint256 amount1); function swap( uint256 amount0Out, uint256 amount1Out, address to, bytes calldata data ) external; function skim(address to) external; function sync() external; } interface IUniswapV2Factory { event PairCreated( address indexed token0, address indexed token1, address pair, uint256 ); function getPair(address tokenA, address tokenB) external view returns (address pair); function allPairs(uint256) external view returns (address pair); function allPairsLength() external view returns (uint256); function feeTo() external view returns (address); function feeToSetter() external view returns (address); function createPair(address tokenA, address tokenB) external returns (address pair); } // File src/interfaces/controller.sol pragma solidity ^0.6.0; interface IController { function jars(address) external view returns (address); function rewards() external view returns (address); function devfund() external view returns (address); function treasury() external view returns (address); function balanceOf(address) external view returns (uint256); function withdraw(address, uint256) external; function withdrawReward(address, uint256) external; function earn(address, uint256) external; function strategies(address) external view returns (address); } // File src/strategies/arbitrum/strategy-base.sol pragma solidity ^0.6.7; // Strategy Contract Basics abstract contract StrategyBase { using SafeERC20 for IERC20; using Address for address; using SafeMath for uint256; // Perfomance fees - start with 20% uint256 public performanceTreasuryFee = 0; uint256 public constant performanceTreasuryMax = 10000; uint256 public performanceDevFee = 0; uint256 public constant performanceDevMax = 10000; // Withdrawal fee 0% // - 0% to treasury // - 0% to dev fund uint256 public withdrawalTreasuryFee = 0; uint256 public constant withdrawalTreasuryMax = 100000; uint256 public withdrawalDevFundFee = 0; uint256 public constant withdrawalDevFundMax = 100000; // Tokens address public want; address public constant weth = 0x82aF49447D8a07e3bd95BD0d56f35241523fBab1; // User accounts address public governance; address public controller; address public strategist; address public timelock; // Dex address public sushiRouter = 0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506; mapping(address => bool) public harvesters; constructor( address _want, address _governance, address _strategist, address _controller, address _timelock ) public { require(_want != address(0)); require(_governance != address(0)); require(_strategist != address(0)); require(_controller != address(0)); require(_timelock != address(0)); want = _want; governance = _governance; strategist = _strategist; controller = _controller; timelock = _timelock; } // **** Modifiers **** // modifier onlyBenevolent { require( harvesters[msg.sender] || msg.sender == governance || msg.sender == strategist ); _; } // **** Views **** // function balanceOfWant() public view returns (uint256) { return IERC20(want).balanceOf(address(this)); } function balanceOfPool() public virtual view returns (uint256); function balanceOf() public view returns (uint256) { return balanceOfWant().add(balanceOfPool()); } function getName() external virtual pure returns (string memory); // **** Setters **** // function whitelistHarvesters(address[] calldata _harvesters) external { require(msg.sender == governance || msg.sender == strategist || harvesters[msg.sender], "not authorized"); for (uint i = 0; i < _harvesters.length; i ++) { harvesters[_harvesters[i]] = true; } } function revokeHarvesters(address[] calldata _harvesters) external { require(msg.sender == governance || msg.sender == strategist, "not authorized"); for (uint i = 0; i < _harvesters.length; i ++) { harvesters[_harvesters[i]] = false; } } function setWithdrawalDevFundFee(uint256 _withdrawalDevFundFee) external { require(msg.sender == timelock, "!timelock"); withdrawalDevFundFee = _withdrawalDevFundFee; } function setWithdrawalTreasuryFee(uint256 _withdrawalTreasuryFee) external { require(msg.sender == timelock, "!timelock"); withdrawalTreasuryFee = _withdrawalTreasuryFee; } function setPerformanceDevFee(uint256 _performanceDevFee) external { require(msg.sender == timelock, "!timelock"); performanceDevFee = _performanceDevFee; } function setPerformanceTreasuryFee(uint256 _performanceTreasuryFee) external { require(msg.sender == timelock, "!timelock"); performanceTreasuryFee = _performanceTreasuryFee; } function setStrategist(address _strategist) external { require(msg.sender == governance, "!governance"); strategist = _strategist; } function setGovernance(address _governance) external { require(msg.sender == governance, "!governance"); governance = _governance; } function setTimelock(address _timelock) external { require(msg.sender == timelock, "!timelock"); timelock = _timelock; } function setController(address _controller) external { require(msg.sender == timelock, "!timelock"); controller = _controller; } // **** State mutations **** // function deposit() public virtual; // Controller only function for creating additional rewards from dust function withdraw(IERC20 _asset) external returns (uint256 balance) { require(msg.sender == controller, "!controller"); require(want != address(_asset), "want"); balance = _asset.balanceOf(address(this)); _asset.safeTransfer(controller, balance); } // Withdraw partial funds, normally used with a jar withdrawal function withdraw(uint256 _amount) external { require(msg.sender == controller, "!controller"); uint256 _balance = IERC20(want).balanceOf(address(this)); if (_balance < _amount) { _amount = _withdrawSome(_amount.sub(_balance)); _amount = _amount.add(_balance); } uint256 _feeDev = _amount.mul(withdrawalDevFundFee).div( withdrawalDevFundMax ); IERC20(want).safeTransfer(IController(controller).devfund(), _feeDev); uint256 _feeTreasury = _amount.mul(withdrawalTreasuryFee).div( withdrawalTreasuryMax ); IERC20(want).safeTransfer( IController(controller).treasury(), _feeTreasury ); address _jar = IController(controller).jars(address(want)); require(_jar != address(0), "!jar"); // additional protection so we don't burn the funds IERC20(want).safeTransfer(_jar, _amount.sub(_feeDev).sub(_feeTreasury)); } // Withdraw funds, used to swap between strategies function withdrawForSwap(uint256 _amount) external returns (uint256 balance) { require(msg.sender == controller, "!controller"); _withdrawSome(_amount); balance = IERC20(want).balanceOf(address(this)); address _jar = IController(controller).jars(address(want)); require(_jar != address(0), "!jar"); IERC20(want).safeTransfer(_jar, balance); } // Withdraw all funds, normally used when migrating strategies function withdrawAll() external returns (uint256 balance) { require(msg.sender == controller, "!controller"); _withdrawAll(); balance = IERC20(want).balanceOf(address(this)); address _jar = IController(controller).jars(address(want)); require(_jar != address(0), "!jar"); // additional protection so we don't burn the funds IERC20(want).safeTransfer(_jar, balance); } function _withdrawAll() internal { _withdrawSome(balanceOfPool()); } function _withdrawSome(uint256 _amount) internal virtual returns (uint256); function harvest() public virtual; // **** Emergency functions **** function execute(address _target, bytes memory _data) public payable returns (bytes memory response) { require(msg.sender == timelock, "!timelock"); require(_target != address(0), "!target"); // call contract in current context assembly { let succeeded := delegatecall( sub(gas(), 5000), _target, add(_data, 0x20), mload(_data), 0, 0 ) let size := returndatasize() response := mload(0x40) mstore( 0x40, add(response, and(add(add(size, 0x20), 0x1f), not(0x1f))) ) mstore(response, size) returndatacopy(add(response, 0x20), 0, size) switch iszero(succeeded) case 1 { // throw if delegatecall failed revert(add(response, 0x20), size) } } } // **** Internal functions **** function _swapSushiswap( address _from, address _to, uint256 _amount ) internal { require(_to != address(0)); address[] memory path; if (_from == weth || _to == weth) { path = new address[](2); path[0] = _from; path[1] = _to; } else { path = new address[](3); path[0] = _from; path[1] = weth; path[2] = _to; } IERC20(_from).safeApprove(sushiRouter, 0); IERC20(_from).safeApprove(sushiRouter, _amount); UniswapRouterV2(sushiRouter).swapExactTokensForTokens( _amount, 0, path, address(this), now.add(60) ); } function _swapSushiswapWithPath( address[] memory path, uint256 _amount ) internal { require(path[1] != address(0)); IERC20(path[0]).safeApprove(sushiRouter, 0); IERC20(path[0]).safeApprove(sushiRouter, _amount); UniswapRouterV2(sushiRouter).swapExactTokensForTokens( _amount, 0, path, address(this), now.add(60) ); } function _distributePerformanceFeesAndDeposit() internal { uint256 _want = IERC20(want).balanceOf(address(this)); if (_want > 0) { // Treasury fees IERC20(want).safeTransfer( IController(controller).treasury(), _want.mul(performanceTreasuryFee).div(performanceTreasuryMax) ); // Performance fee IERC20(want).safeTransfer( IController(controller).devfund(), _want.mul(performanceDevFee).div(performanceDevMax) ); deposit(); } } function _distributePerformanceFeesBasedAmountAndDeposit(uint256 _amount) internal { uint256 _want = IERC20(want).balanceOf(address(this)); if (_amount > _want) { _amount = _want; } if (_amount > 0) { // Treasury fees IERC20(want).safeTransfer( IController(controller).treasury(), _amount.mul(performanceTreasuryFee).div(performanceTreasuryMax) ); // Performance fee IERC20(want).safeTransfer( IController(controller).devfund(), _amount.mul(performanceDevFee).div(performanceDevMax) ); deposit(); } } } // File src/lib/balancer-vault.sol pragma solidity 0.6.12; pragma experimental ABIEncoderV2; interface IMerkleRedeem { function claimWeek( address liquidityProvider, uint256 week, uint256 claimedBalance, bytes32[] calldata merkleProof ) external; } interface IAsset {} interface IBVault { // Internal Balance // // Users can deposit tokens into the Vault, where they are allocated to their Internal Balance, and later // transferred or withdrawn. It can also be used as a source of tokens when joining Pools, as a destination // when exiting them, and as either when performing swaps. This usage of Internal Balance results in greatly reduced // gas costs when compared to relying on plain ERC20 transfers, leading to large savings for frequent users. // // Internal Balance management features batching, which means a single contract call can be used to perform multiple // operations of different kinds, with different senders and recipients, at once. /** * @dev Returns `user`'s Internal Balance for a set of tokens. */ function getInternalBalance(address user, IERC20[] calldata tokens) external view returns (uint256[] memory); /** * @dev Performs a set of user balance operations, which involve Internal Balance (deposit, withdraw or transfer) * and plain ERC20 transfers using the Vault's allowance. This last feature is particularly useful for relayers, as * it lets integrators reuse a user's Vault allowance. * * For each operation, if the caller is not `sender`, it must be an authorized relayer for them. */ function manageUserBalance(UserBalanceOp[] calldata ops) external payable; /** * @dev Data for `manageUserBalance` operations, which include the possibility for ETH to be sent and received without manual WETH wrapping or unwrapping. */ struct UserBalanceOp { UserBalanceOpKind kind; IAsset asset; uint256 amount; address sender; address payable recipient; } // There are four possible operations in `manageUserBalance`: // // - DEPOSIT_INTERNAL // Increases the Internal Balance of the `recipient` account by transferring tokens from the corresponding // `sender`. The sender must have allowed the Vault to use their tokens via `IERC20.approve()`. // // ETH can be used by passing the ETH sentinel value as the asset and forwarding ETH in the call: it will be wrapped // and deposited as WETH. Any ETH amount remaining will be sent back to the caller (not the sender, which is // relevant for relayers). // // Emits an `InternalBalanceChanged` event. // // // - WITHDRAW_INTERNAL // Decreases the Internal Balance of the `sender` account by transferring tokens to the `recipient`. // // ETH can be used by passing the ETH sentinel value as the asset. This will deduct WETH instead, unwrap it and send // it to the recipient as ETH. // // Emits an `InternalBalanceChanged` event. // // // - TRANSFER_INTERNAL // Transfers tokens from the Internal Balance of the `sender` account to the Internal Balance of `recipient`. // // Reverts if the ETH sentinel value is passed. // // Emits an `InternalBalanceChanged` event. // // // - TRANSFER_EXTERNAL // Transfers tokens from `sender` to `recipient`, using the Vault's ERC20 allowance. This is typically used by // relayers, as it lets them reuse a user's Vault allowance. // // Reverts if the ETH sentinel value is passed. // // Emits an `ExternalBalanceTransfer` event. enum UserBalanceOpKind { DEPOSIT_INTERNAL, WITHDRAW_INTERNAL, TRANSFER_INTERNAL, TRANSFER_EXTERNAL } /** * @dev Emitted when a user's Internal Balance changes, either from calls to `manageUserBalance`, or through * interacting with Pools using Internal Balance. * * Because Internal Balance works exclusively with ERC20 tokens, ETH deposits and withdrawals will use the WETH * address. */ event InternalBalanceChanged( address indexed user, IERC20 indexed token, int256 delta ); /** * @dev Emitted when a user's Vault ERC20 allowance is used by the Vault to transfer tokens to an external account. */ event ExternalBalanceTransfer( IERC20 indexed token, address indexed sender, address recipient, uint256 amount ); // Pools // // There are three specialization settings for Pools, which allow for cheaper swaps at the cost of reduced // functionality: // // - General: no specialization, suited for all Pools. IGeneralPool is used for swap request callbacks, passing the // balance of all tokens in the Pool. These Pools have the largest swap costs (because of the extra storage reads), // which increase with the number of registered tokens. // // - Minimal Swap Info: IMinimalSwapInfoPool is used instead of IGeneralPool, which saves gas by only passing the // balance of the two tokens involved in the swap. This is suitable for some pricing algorithms, like the weighted // constant product one popularized by Balancer V1. Swap costs are smaller compared to general Pools, and are // independent of the number of registered tokens. // // - Two Token: only allows two tokens to be registered. This achieves the lowest possible swap gas cost. Like // minimal swap info Pools, these are called via IMinimalSwapInfoPool. enum PoolSpecialization { GENERAL, MINIMAL_SWAP_INFO, TWO_TOKEN } /** * @dev Registers the caller account as a Pool with a given specialization setting. Returns the Pool's ID, which * is used in all Pool-related functions. Pools cannot be deregistered, nor can the Pool's specialization be * changed. * * The caller is expected to be a smart contract that implements either `IGeneralPool` or `IMinimalSwapInfoPool`, * depending on the chosen specialization setting. This contract is known as the Pool's contract. * * Note that the same contract may register itself as multiple Pools with unique Pool IDs, or in other words, * multiple Pools may share the same contract. * * Emits a `PoolRegistered` event. */ function registerPool(PoolSpecialization specialization) external returns (bytes32); /** * @dev Emitted when a Pool is registered by calling `registerPool`. */ event PoolRegistered( bytes32 indexed poolId, address indexed poolAddress, PoolSpecialization specialization ); /** * @dev Returns a Pool's contract address and specialization setting. */ function getPool(bytes32 poolId) external view returns (address, PoolSpecialization); /** * @dev Registers `tokens` for the `poolId` Pool. Must be called by the Pool's contract. * * Pools can only interact with tokens they have registered. Users join a Pool by transferring registered tokens, * exit by receiving registered tokens, and can only swap registered tokens. * * Each token can only be registered once. For Pools with the Two Token specialization, `tokens` must have a length * of two, that is, both tokens must be registered in the same `registerTokens` call, and they must be sorted in * ascending order. * * The `tokens` and `assetManagers` arrays must have the same length, and each entry in these indicates the Asset * Manager for the corresponding token. Asset Managers can manage a Pool's tokens via `managePoolBalance`, * depositing and withdrawing them directly, and can even set their balance to arbitrary amounts. They are therefore * expected to be highly secured smart contracts with sound design principles, and the decision to register an * Asset Manager should not be made lightly. * * Pools can choose not to assign an Asset Manager to a given token by passing in the zero address. Once an Asset * Manager is set, it cannot be changed except by deregistering the associated token and registering again with a * different Asset Manager. * * Emits a `TokensRegistered` event. */ function registerTokens( bytes32 poolId, IERC20[] calldata tokens, address[] calldata assetManagers ) external; /** * @dev Emitted when a Pool registers tokens by calling `registerTokens`. */ event TokensRegistered( bytes32 indexed poolId, IERC20[] tokens, address[] assetManagers ); /** * @dev Deregisters `tokens` for the `poolId` Pool. Must be called by the Pool's contract. * * Only registered tokens (via `registerTokens`) can be deregistered. Additionally, they must have zero total * balance. For Pools with the Two Token specialization, `tokens` must have a length of two, that is, both tokens * must be deregistered in the same `deregisterTokens` call. * * A deregistered token can be re-registered later on, possibly with a different Asset Manager. * * Emits a `TokensDeregistered` event. */ function deregisterTokens(bytes32 poolId, IERC20[] calldata tokens) external; /** * @dev Emitted when a Pool deregisters tokens by calling `deregisterTokens`. */ event TokensDeregistered(bytes32 indexed poolId, IERC20[] tokens); /** * @dev Returns detailed information for a Pool's registered token. * * `cash` is the number of tokens the Vault currently holds for the Pool. `managed` is the number of tokens * withdrawn and held outside the Vault by the Pool's token Asset Manager. The Pool's total balance for `token` * equals the sum of `cash` and `managed`. * * Internally, `cash` and `managed` are stored using 112 bits. No action can ever cause a Pool's token `cash`, * `managed` or `total` balance to be greater than 2^112 - 1. * * `lastChangeBlock` is the number of the block in which `token`'s total balance was last modified (via either a * join, exit, swap, or Asset Manager update). This value is useful to avoid so-called 'sandwich attacks', for * example when developing price oracles. A change of zero (e.g. caused by a swap with amount zero) is considered a * change for this purpose, and will update `lastChangeBlock`. * * `assetManager` is the Pool's token Asset Manager. */ function getPoolTokenInfo(bytes32 poolId, IERC20 token) external view returns ( uint256 cash, uint256 managed, uint256 lastChangeBlock, address assetManager ); /** * @dev Returns a Pool's registered tokens, the total balance for each, and the latest block when *any* of * the tokens' `balances` changed. * * The order of the `tokens` array is the same order that will be used in `joinPool`, `exitPool`, as well as in all * Pool hooks (where applicable). Calls to `registerTokens` and `deregisterTokens` may change this order. * * If a Pool only registers tokens once, and these are sorted in ascending order, they will be stored in the same * order as passed to `registerTokens`. * * Total balances include both tokens held by the Vault and those withdrawn by the Pool's Asset Managers. These are * the amounts used by joins, exits and swaps. For a detailed breakdown of token balances, use `getPoolTokenInfo` * instead. */ function getPoolTokens(bytes32 poolId) external view returns ( IERC20[] memory tokens, uint256[] memory balances, uint256 lastChangeBlock ); /** * @dev Called by users to join a Pool, which transfers tokens from `sender` into the Pool's balance. This will * trigger custom Pool behavior, which will typically grant something in return to `recipient` - often tokenized * Pool shares. * * If the caller is not `sender`, it must be an authorized relayer for them. * * The `assets` and `maxAmountsIn` arrays must have the same length, and each entry indicates the maximum amount * to send for each asset. The amounts to send are decided by the Pool and not the Vault: it just enforces * these maximums. * * If joining a Pool that holds WETH, it is possible to send ETH directly: the Vault will do the wrapping. To enable * this mechanism, the IAsset sentinel value (the zero address) must be passed in the `assets` array instead of the * WETH address. Note that it is not possible to combine ETH and WETH in the same join. Any excess ETH will be sent * back to the caller (not the sender, which is important for relayers). * * `assets` must have the same length and order as the array returned by `getPoolTokens`. This prevents issues when * interacting with Pools that register and deregister tokens frequently. If sending ETH however, the array must be * sorted *before* replacing the WETH address with the ETH sentinel value (the zero address), which means the final * `assets` array might not be sorted. Pools with no registered tokens cannot be joined. * * If `fromInternalBalance` is true, the caller's Internal Balance will be preferred: ERC20 transfers will only * be made for the difference between the requested amount and Internal Balance (if any). Note that ETH cannot be * withdrawn from Internal Balance: attempting to do so will trigger a revert. * * This causes the Vault to call the `IBasePool.onJoinPool` hook on the Pool's contract, where Pools implement * their own custom logic. This typically requires additional information from the user (such as the expected number * of Pool shares). This can be encoded in the `userData` argument, which is ignored by the Vault and passed * directly to the Pool's contract, as is `recipient`. * * Emits a `PoolBalanceChanged` event. */ function joinPool( bytes32 poolId, address sender, address recipient, JoinPoolRequest calldata request ) external payable; enum JoinKind { INIT, EXACT_TOKENS_IN_FOR_BPT_OUT, TOKEN_IN_FOR_EXACT_BPT_OUT } enum ExitKind { EXACT_BPT_IN_FOR_ONE_TOKEN_OUT, EXACT_BPT_IN_FOR_TOKENS_OUT, BPT_IN_FOR_EXACT_TOKENS_OUT } struct JoinPoolRequest { IAsset[] assets; uint256[] maxAmountsIn; bytes userData; bool fromInternalBalance; } /** * @dev Called by users to exit a Pool, which transfers tokens from the Pool's balance to `recipient`. This will * trigger custom Pool behavior, which will typically ask for something in return from `sender` - often tokenized * Pool shares. The amount of tokens that can be withdrawn is limited by the Pool's `cash` balance (see * `getPoolTokenInfo`). * * If the caller is not `sender`, it must be an authorized relayer for them. * * The `tokens` and `minAmountsOut` arrays must have the same length, and each entry in these indicates the minimum * token amount to receive for each token contract. The amounts to send are decided by the Pool and not the Vault: * it just enforces these minimums. * * If exiting a Pool that holds WETH, it is possible to receive ETH directly: the Vault will do the unwrapping. To * enable this mechanism, the IAsset sentinel value (the zero address) must be passed in the `assets` array instead * of the WETH address. Note that it is not possible to combine ETH and WETH in the same exit. * * `assets` must have the same length and order as the array returned by `getPoolTokens`. This prevents issues when * interacting with Pools that register and deregister tokens frequently. If receiving ETH however, the array must * be sorted *before* replacing the WETH address with the ETH sentinel value (the zero address), which means the * final `assets` array might not be sorted. Pools with no registered tokens cannot be exited. * * If `toInternalBalance` is true, the tokens will be deposited to `recipient`'s Internal Balance. Otherwise, * an ERC20 transfer will be performed. Note that ETH cannot be deposited to Internal Balance: attempting to * do so will trigger a revert. * * `minAmountsOut` is the minimum amount of tokens the user expects to get out of the Pool, for each token in the * `tokens` array. This array must match the Pool's registered tokens. * * This causes the Vault to call the `IBasePool.onExitPool` hook on the Pool's contract, where Pools implement * their own custom logic. This typically requires additional information from the user (such as the expected number * of Pool shares to return). This can be encoded in the `userData` argument, which is ignored by the Vault and * passed directly to the Pool's contract. * * Emits a `PoolBalanceChanged` event. */ function exitPool( bytes32 poolId, address sender, address payable recipient, ExitPoolRequest calldata request ) external; struct ExitPoolRequest { IAsset[] assets; uint256[] minAmountsOut; bytes userData; bool toInternalBalance; } /** * @dev Emitted when a user joins or exits a Pool by calling `joinPool` or `exitPool`, respectively. */ event PoolBalanceChanged( bytes32 indexed poolId, address indexed liquidityProvider, IERC20[] tokens, int256[] deltas, uint256[] protocolFeeAmounts ); enum PoolBalanceChangeKind { JOIN, EXIT } // Swaps // // Users can swap tokens with Pools by calling the `swap` and `batchSwap` functions. To do this, // they need not trust Pool contracts in any way: all security checks are made by the Vault. They must however be // aware of the Pools' pricing algorithms in order to estimate the prices Pools will quote. // // The `swap` function executes a single swap, while `batchSwap` can perform multiple swaps in sequence. // In each individual swap, tokens of one kind are sent from the sender to the Pool (this is the 'token in'), // and tokens of another kind are sent from the Pool to the recipient in exchange (this is the 'token out'). // More complex swaps, such as one token in to multiple tokens out can be achieved by batching together // individual swaps. // // There are two swap kinds: // - 'given in' swaps, where the amount of tokens in (sent to the Pool) is known, and the Pool determines (via the // `onSwap` hook) the amount of tokens out (to send to the recipient). // - 'given out' swaps, where the amount of tokens out (received from the Pool) is known, and the Pool determines // (via the `onSwap` hook) the amount of tokens in (to receive from the sender). // // Additionally, it is possible to chain swaps using a placeholder input amount, which the Vault replaces with // the calculated output of the previous swap. If the previous swap was 'given in', this will be the calculated // tokenOut amount. If the previous swap was 'given out', it will use the calculated tokenIn amount. These extended // swaps are known as 'multihop' swaps, since they 'hop' through a number of intermediate tokens before arriving at // the final intended token. // // In all cases, tokens are only transferred in and out of the Vault (or withdrawn from and deposited into Internal // Balance) after all individual swaps have been completed, and the net token balance change computed. This makes // certain swap patterns, such as multihops, or swaps that interact with the same token pair in multiple Pools, cost // much less gas than they would otherwise. // // It also means that under certain conditions it is possible to perform arbitrage by swapping with multiple // Pools in a way that results in net token movement out of the Vault (profit), with no tokens being sent in (only // updating the Pool's internal accounting). // // To protect users from front-running or the market changing rapidly, they supply a list of 'limits' for each token // involved in the swap, where either the maximum number of tokens to send (by passing a positive value) or the // minimum amount of tokens to receive (by passing a negative value) is specified. // // Additionally, a 'deadline' timestamp can also be provided, forcing the swap to fail if it occurs after // this point in time (e.g. if the transaction failed to be included in a block promptly). // // If interacting with Pools that hold WETH, it is possible to both send and receive ETH directly: the Vault will do // the wrapping and unwrapping. To enable this mechanism, the IAsset sentinel value (the zero address) must be // passed in the `assets` array instead of the WETH address. Note that it is possible to combine ETH and WETH in the // same swap. Any excess ETH will be sent back to the caller (not the sender, which is relevant for relayers). // // Finally, Internal Balance can be used when either sending or receiving tokens. enum SwapKind { GIVEN_IN, GIVEN_OUT } /** * @dev Performs a swap with a single Pool. * * If the swap is 'given in' (the number of tokens to send to the Pool is known), it returns the amount of tokens * taken from the Pool, which must be greater than or equal to `limit`. * * If the swap is 'given out' (the number of tokens to take from the Pool is known), it returns the amount of tokens * sent to the Pool, which must be less than or equal to `limit`. * * Internal Balance usage and the recipient are determined by the `funds` struct. * * Emits a `Swap` event. */ function swap( SingleSwap calldata singleSwap, FundManagement calldata funds, uint256 limit, uint256 deadline ) external payable returns (uint256); /** * @dev Data for a single swap executed by `swap`. `amount` is either `amountIn` or `amountOut` depending on * the `kind` value. * * `assetIn` and `assetOut` are either token addresses, or the IAsset sentinel value for ETH (the zero address). * Note that Pools never interact with ETH directly: it will be wrapped to or unwrapped from WETH by the Vault. * * The `userData` field is ignored by the Vault, but forwarded to the Pool in the `onSwap` hook, and may be * used to extend swap behavior. */ struct SingleSwap { bytes32 poolId; SwapKind kind; IAsset assetIn; IAsset assetOut; uint256 amount; bytes userData; } /** * @dev Performs a series of swaps with one or multiple Pools. In each individual swap, the caller determines either * the amount of tokens sent to or received from the Pool, depending on the `kind` value. * * Returns an array with the net Vault asset balance deltas. Positive amounts represent tokens (or ETH) sent to the * Vault, and negative amounts represent tokens (or ETH) sent by the Vault. Each delta corresponds to the asset at * the same index in the `assets` array. * * Swaps are executed sequentially, in the order specified by the `swaps` array. Each array element describes a * Pool, the token to be sent to this Pool, the token to receive from it, and an amount that is either `amountIn` or * `amountOut` depending on the swap kind. * * Multihop swaps can be executed by passing an `amount` value of zero for a swap. This will cause the amount in/out * of the previous swap to be used as the amount in for the current one. In a 'given in' swap, 'tokenIn' must equal * the previous swap's `tokenOut`. For a 'given out' swap, `tokenOut` must equal the previous swap's `tokenIn`. * * The `assets` array contains the addresses of all assets involved in the swaps. These are either token addresses, * or the IAsset sentinel value for ETH (the zero address). Each entry in the `swaps` array specifies tokens in and * out by referencing an index in `assets`. Note that Pools never interact with ETH directly: it will be wrapped to * or unwrapped from WETH by the Vault. * * Internal Balance usage, sender, and recipient are determined by the `funds` struct. The `limits` array specifies * the minimum or maximum amount of each token the vault is allowed to transfer. * * `batchSwap` can be used to make a single swap, like `swap` does, but doing so requires more gas than the * equivalent `swap` call. * * Emits `Swap` events. */ function batchSwap( SwapKind kind, BatchSwapStep[] calldata swaps, IAsset[] calldata assets, FundManagement calldata funds, int256[] calldata limits, uint256 deadline ) external payable returns (int256[] memory); /** * @dev Data for each individual swap executed by `batchSwap`. The asset in and out fields are indexes into the * `assets` array passed to that function, and ETH assets are converted to WETH. * * If `amount` is zero, the multihop mechanism is used to determine the actual amount based on the amount in/out * from the previous swap, depending on the swap kind. * * The `userData` field is ignored by the Vault, but forwarded to the Pool in the `onSwap` hook, and may be * used to extend swap behavior. */ struct BatchSwapStep { bytes32 poolId; uint256 assetInIndex; uint256 assetOutIndex; uint256 amount; bytes userData; } /** * @dev Emitted for each individual swap performed by `swap` or `batchSwap`. */ event Swap( bytes32 indexed poolId, IERC20 indexed tokenIn, IERC20 indexed tokenOut, uint256 amountIn, uint256 amountOut ); /** * @dev All tokens in a swap are either sent from the `sender` account to the Vault, or from the Vault to the * `recipient` account. * * If the caller is not `sender`, it must be an authorized relayer for them. * * If `fromInternalBalance` is true, the `sender`'s Internal Balance will be preferred, performing an ERC20 * transfer for the difference between the requested amount and the User's Internal Balance (if any). The `sender` * must have allowed the Vault to use their tokens via `IERC20.approve()`. This matches the behavior of * `joinPool`. * * If `toInternalBalance` is true, tokens will be deposited to `recipient`'s internal balance instead of * transferred. This matches the behavior of `exitPool`. * * Note that ETH cannot be deposited to or withdrawn from Internal Balance: attempting to do so will trigger a * revert. */ struct FundManagement { address sender; bool fromInternalBalance; address payable recipient; bool toInternalBalance; } /** * @dev Simulates a call to `batchSwap`, returning an array of Vault asset deltas. Calls to `swap` cannot be * simulated directly, but an equivalent `batchSwap` call can and will yield the exact same result. * * Each element in the array corresponds to the asset at the same index, and indicates the number of tokens (or ETH) * the Vault would take from the sender (if positive) or send to the recipient (if negative). The arguments it * receives are the same that an equivalent `batchSwap` call would receive. * * Unlike `batchSwap`, this function performs no checks on the sender or recipient field in the `funds` struct. * This makes it suitable to be called by off-chain applications via eth_call without needing to hold tokens, * approve them for the Vault, or even know a user's address. * * Note that this function is not 'view' (due to implementation details): the client code must explicitly execute * eth_call instead of eth_sendTransaction. */ function queryBatchSwap( SwapKind kind, BatchSwapStep[] calldata swaps, IAsset[] calldata assets, FundManagement calldata funds ) external returns (int256[] memory assetDeltas); } // File src/strategies/arbitrum/balancer/strategy-balancer-bal-weth.sol pragma solidity ^0.6.7; contract StrategyBalancerBalWethLp is StrategyBase { // Token addresses address public vault = 0xBA12222222228d8Ba445958a75a0704d566BF2C8; bytes32 public poolId = 0xcc65a812ce382ab909a11e434dbf75b34f1cc59d000200000000000000000001; address public bal = 0x040d1EdC9569d4Bab2D15287Dc5A4F10F56a56B8; address public token0 = bal; address public token1 = weth; // pool deposit fee uint256 public depositFee = 0; address _lp = 0xcC65A812ce382aB909a11E434dbf75B34f1cc59D; address balDistributor = 0x6bd0B17713aaa29A2d7c9A39dDc120114f9fD809; constructor( address _governance, address _strategist, address _controller, address _timelock ) public StrategyBase(_lp, _governance, _strategist, _controller, _timelock) {} function getName() external pure override returns (string memory) { return "StrategyBalancerBalWethLp"; } function balanceOfPool() public view override returns (uint256) { return 0; } function getHarvestable() external view virtual returns (uint256) { return IERC20(bal).balanceOf(address(this)); } // **** Setters **** function deposit() public override {} function _withdrawSome(uint256 _amount) internal override returns (uint256) { return _amount; } // **** State Mutations **** function claimBal( uint256 _week, uint256 _claim, bytes32[] memory merkleProof ) public { IMerkleRedeem(balDistributor).claimWeek( address(this), _week, _claim, merkleProof ); } function setDistributor(address _distributor) external { require(msg.sender == governance, "not authorized"); balDistributor = _distributor; } function harvest() public override onlyBenevolent { uint256 _balBalance = IERC20(bal).balanceOf(address(this)); if (_balBalance == 0) { return; } // allow Balancer to sell our reward IERC20(bal).safeApprove(vault, 0); IERC20(bal).safeApprove(vault, _balBalance); IAsset[] memory assets = new IAsset[](2); assets[0] = IAsset(token0); assets[1] = IAsset(token1); IBVault.JoinKind joinKind = IBVault .JoinKind .EXACT_TOKENS_IN_FOR_BPT_OUT; uint256[] memory amountsIn = new uint256[](2); amountsIn[0] = _balBalance; amountsIn[1] = 0; uint256 minAmountOut = 1; bytes memory userData = abi.encode(joinKind, amountsIn, minAmountOut); IBVault.JoinPoolRequest memory request = IBVault.JoinPoolRequest({ assets: assets, maxAmountsIn: amountsIn, userData: userData, fromInternalBalance: false }); uint256 _before = IERC20(want).balanceOf(address(this)); IBVault(vault).joinPool(poolId, address(this), address(this), request); uint256 _after = IERC20(want).balanceOf(address(this)); uint256 _amount = _after.sub(_before); _distributePerformanceFeesBasedAmountAndDeposit(_amount); } }
[{"inputs":[{"internalType":"address","name":"_governance","type":"address"},{"internalType":"address","name":"_strategist","type":"address"},{"internalType":"address","name":"_controller","type":"address"},{"internalType":"address","name":"_timelock","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"bal","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"balanceOfPool","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"balanceOfWant","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_week","type":"uint256"},{"internalType":"uint256","name":"_claim","type":"uint256"},{"internalType":"bytes32[]","name":"merkleProof","type":"bytes32[]"}],"name":"claimBal","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"controller","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"depositFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_target","type":"address"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"execute","outputs":[{"internalType":"bytes","name":"response","type":"bytes"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"getHarvestable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getName","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"governance","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"harvest","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"harvesters","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"performanceDevFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"performanceDevMax","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"performanceTreasuryFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"performanceTreasuryMax","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolId","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"_harvesters","type":"address[]"}],"name":"revokeHarvesters","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_controller","type":"address"}],"name":"setController","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_distributor","type":"address"}],"name":"setDistributor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_governance","type":"address"}],"name":"setGovernance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_performanceDevFee","type":"uint256"}],"name":"setPerformanceDevFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_performanceTreasuryFee","type":"uint256"}],"name":"setPerformanceTreasuryFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_strategist","type":"address"}],"name":"setStrategist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_timelock","type":"address"}],"name":"setTimelock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_withdrawalDevFundFee","type":"uint256"}],"name":"setWithdrawalDevFundFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_withdrawalTreasuryFee","type":"uint256"}],"name":"setWithdrawalTreasuryFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"strategist","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"sushiRouter","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"timelock","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token0","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token1","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"vault","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"want","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"weth","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"_harvesters","type":"address[]"}],"name":"whitelistHarvesters","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"_asset","type":"address"}],"name":"withdraw","outputs":[{"internalType":"uint256","name":"balance","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawAll","outputs":[{"internalType":"uint256","name":"balance","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdrawForSwap","outputs":[{"internalType":"uint256","name":"balance","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawalDevFundFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdrawalDevFundMax","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdrawalTreasuryFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdrawalTreasuryMax","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
000000000000000000000000acfe4511ce883c14c4ea40563f176c3c09b4c47c000000000000000000000000acfe4511ce883c14c4ea40563f176c3c09b4c47c00000000000000000000000055d5bcef2bfd4921b8790525ff87919c2e26bd03000000000000000000000000acfe4511ce883c14c4ea40563f176c3c09b4c47c
-----Decoded View---------------
Arg [0] : _governance (address): 0xaCfE4511CE883C14c4eA40563F176C3C09b4c47C
Arg [1] : _strategist (address): 0xaCfE4511CE883C14c4eA40563F176C3C09b4c47C
Arg [2] : _controller (address): 0x55D5BCEf2BFD4921B8790525FF87919c2E26bD03
Arg [3] : _timelock (address): 0xaCfE4511CE883C14c4eA40563F176C3C09b4c47C
-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 000000000000000000000000acfe4511ce883c14c4ea40563f176c3c09b4c47c
Arg [1] : 000000000000000000000000acfe4511ce883c14c4ea40563f176c3c09b4c47c
Arg [2] : 00000000000000000000000055d5bcef2bfd4921b8790525ff87919c2e26bd03
Arg [3] : 000000000000000000000000acfe4511ce883c14c4ea40563f176c3c09b4c47c
Deployed ByteCode Sourcemap
82350:3311:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;83426:128;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;82682:27;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;44203:340::-;;;;;;;;;;-1:-1:-1;44203:340:0;;;;;:::i;:::-;;:::i;:::-;;83327:91;;;;;;;;;;;;;:::i;83200:119::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;49106:1053::-;;;;;;:::i;:::-;;:::i;42547:19::-;;;;;;;;;;;;;:::i;42741:25::-;;;;;;;;;;;;;:::i;83820:284::-;;;;;;;;;;-1:-1:-1;83820:284:0;;;;;:::i;:::-;;:::i;45447:213::-;;;;;;;;;;-1:-1:-1;45447:213:0;;;;;:::i;:::-;;:::i;42074:54::-;;;;;;;;;;;;;:::i;46823:1022::-;;;;;;;;;;-1:-1:-1;46823:1022:0;;;;;:::i;:::-;;:::i;82612:63::-;;;;;;;;;;;;;:::i;82504:99::-;;;;;;;;;;;;;:::i;42573:73::-;;;;;;;;;;;;;:::i;84285:1373::-;;;;;;;;;;;;;:::i;42470:53::-;;;;;;;;;;;;;:::i;46458:289::-;;;;;;;;;;-1:-1:-1;46458:289:0;;;;;:::i;:::-;;:::i;42424:39::-;;;;;;;;;;;;;:::i;42026:41::-;;;;;;;;;;;;;:::i;42677:25::-;;;;;;;;;;;;;:::i;82778:29::-;;;;;;;;;;;;;:::i;42818:71::-;;;;;;;;;;;;;:::i;43978:113::-;;;;;;;;;;;;;:::i;84112:165::-;;;;;;;;;;-1:-1:-1;84112:165:0;;;;;:::i;:::-;;:::i;45057:195::-;;;;;;;;;;-1:-1:-1;45057:195:0;;;;;:::i;:::-;;:::i;48413:430::-;;;;;;;;;;;;;:::i;42898:42::-;;;;;;;;;;-1:-1:-1;42898:42:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;42137:36::-;;;;;;;;;;;;;:::i;42314:40::-;;;;;;;;;;;;;:::i;46145:151::-;;;;;;;;;;-1:-1:-1;46145:151:0;;;;;:::i;:::-;;:::i;45831:155::-;;;;;;;;;;-1:-1:-1;45831:155:0;;;;;:::i;:::-;;:::i;44858:191::-;;;;;;;;;;-1:-1:-1;44858:191:0;;;;;:::i;:::-;;:::i;44551:299::-;;;;;;;;;;-1:-1:-1;44551:299:0;;;;;:::i;:::-;;:::i;45994:143::-;;;;;;;;;;-1:-1:-1;45994:143:0;;;;;:::i;:::-;;:::i;43781:118::-;;;;;;;;;;;;;:::i;47909:428::-;;;;;;;;;;-1:-1:-1;47909:428:0;;;;;:::i;:::-;;:::i;45260:179::-;;;;;;;;;;-1:-1:-1;45260:179:0;;;;;:::i;:::-;;:::i;45668:155::-;;;;;;;;;;-1:-1:-1;45668:155:0;;;;;:::i;:::-;;:::i;83590:37::-;;;;;;;;;;;;;:::i;82716:28::-;;;;;;;;;;;;;:::i;42773:23::-;;;;;;;;;;;;;:::i;42709:25::-;;;;;;;;;;;;;:::i;82432:65::-;;;;;;;;;;;;;:::i;83426:128::-;83517:3;;83510:36;;-1:-1:-1;;;83510:36:0;;83483:7;;-1:-1:-1;;;;;83517:3:0;;83510:21;;:36;;83540:4;;83510:36;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;83503:43;;83426:128;:::o;82682:27::-;;;-1:-1:-1;;;;;82682:27:0;;:::o;44203:340::-;44306:10;;-1:-1:-1;;;;;44306:10:0;44292;:24;;:66;;-1:-1:-1;44348:10:0;;-1:-1:-1;;;;;44348:10:0;44334;:24;44292:66;:92;;;-1:-1:-1;44373:10:0;44362:22;;;;:10;:22;;;;;;;;44292:92;44284:119;;;;-1:-1:-1;;;44284:119:0;;;;;;;:::i;:::-;;;;;;;;;44434:6;44429:107;44446:22;;;44429:107;;;44520:4;44491:10;:26;44502:11;;44514:1;44502:14;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;44491:26:0;;;;;;;;;;;;-1:-1:-1;44491:26:0;:33;;-1:-1:-1;;44491:33:0;;;;;;;;;;-1:-1:-1;44470:4:0;44429:107;;;;44203:340;;:::o;83327:91::-;83382:7;83327:91;:::o;83200:119::-;83277:34;;;;;;;;;;;;;;;;;83200:119;:::o;49106:1053::-;49272:8;;49211:21;;-1:-1:-1;;;;;49272:8:0;49258:10;:22;49250:44;;;;-1:-1:-1;;;49250:44:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;49313:21:0;;49305:41;;;;-1:-1:-1;;;49305:41:0;;;;;;;:::i;:::-;49623:1;49603;49578:5;49572:12;49548:4;49541:5;49537:16;49511:7;49487:4;49480:5;49476:16;49445:194;49665:16;49715:4;49709:11;49697:23;;49832:4;49828:9;49821:4;49814;49808;49804:15;49800:26;49796:42;49786:8;49782:57;49759:4;49734:120;49885:4;49875:8;49868:22;49943:4;49940:1;49933:4;49923:8;49919:19;49904:44;49978:9;49971:17;50011:1;50006:135;;;;49964:177;;50006:135;50117:4;50110;50100:8;50096:19;50089:33;49964:177;;;;49413:739;;;;:::o;42547:19::-;;;-1:-1:-1;;;;;42547:19:0;;:::o;42741:25::-;;;-1:-1:-1;;;;;42741:25:0;;:::o;83820:284::-;83965:14;;83951:145;;-1:-1:-1;;;83951:145:0;;-1:-1:-1;;;;;83965:14:0;;;;83951:39;;:145;;84013:4;;84033:5;;84053:6;;84074:11;;83951:145;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;83820:284;;;:::o;45447:213::-;45571:8;;-1:-1:-1;;;;;45571:8:0;45557:10;:22;45549:44;;;;-1:-1:-1;;;45549:44:0;;;;;;;:::i;:::-;45604:22;:48;45447:213::o;42074:54::-;42123:5;42074:54;:::o;46823:1022::-;46900:10;;-1:-1:-1;;;;;46900:10:0;46886;:24;46878:48;;;;-1:-1:-1;;;46878:48:0;;;;;;;:::i;:::-;46963:4;;;46956:37;;-1:-1:-1;;;46956:37:0;;46937:16;;-1:-1:-1;;;;;46963:4:0;;;;46956:22;;:37;;46987:4;;46956:37;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;46937:56;;47019:7;47008:8;:18;47004:143;;;47053:36;47067:21;:7;47079:8;47067:11;:21::i;:::-;47053:13;:36::i;:::-;47043:46;-1:-1:-1;47114:21:0;47043:46;47126:8;47114:11;:21::i;:::-;47104:31;;47004:143;47159:15;47177:83;42517:6;47177:33;47189:20;;47177:7;:11;;:33;;;;:::i;:::-;:37;;:83::i;:::-;47159:101;;47271:69;47309:10;;;;;;;;;-1:-1:-1;;;;;47309:10:0;-1:-1:-1;;;;;47297:31:0;;:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;47278:4;;-1:-1:-1;;;;;47278:4:0;;47332:7;47271:25;:69::i;:::-;47353:20;47376:85;42409:6;47376:34;47388:21;;47376:7;:11;;:34;;;;:::i;:85::-;47353:108;;47472:112;47524:10;;;;;;;;;-1:-1:-1;;;;;47524:10:0;-1:-1:-1;;;;;47512:32:0;;:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47472:112;47624:10;;47649:4;;;47612:43;;-1:-1:-1;;;47612:43:0;;47597:12;;-1:-1:-1;;;;;47624:10:0;;;;47612:28;;:43;;47649:4;;;47612:43;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;47597:58;-1:-1:-1;;;;;;47674:18:0;;47666:35;;;;-1:-1:-1;;;47666:35:0;;;;;;;:::i;:::-;47766:71;47792:4;47798:38;47823:12;47798:20;:7;47810;47798:11;:20::i;:::-;:24;;:38::i;:::-;47773:4;;-1:-1:-1;;;;;47773:4:0;;47766:71;:25;:71::i;:::-;46823:1022;;;;;:::o;82612:63::-;;;-1:-1:-1;;;;;82612:63:0;;:::o;82504:99::-;;;;:::o;42573:73::-;42604:42;42573:73;:::o;84285:1373::-;43612:10;43601:22;;;;:10;:22;;;;;;;;;:67;;-1:-1:-1;43658:10:0;;-1:-1:-1;;;;;43658:10:0;43644;:24;43601:67;:112;;;-1:-1:-1;43703:10:0;;-1:-1:-1;;;;;43703:10:0;43689;:24;43601:112;43579:145;;;;;;84375:3:::1;::::0;84368:36:::1;::::0;-1:-1:-1;;;84368:36:0;;84346:19:::1;::::0;-1:-1:-1;;;;;84375:3:0::1;::::0;84368:21:::1;::::0;:36:::1;::::0;84398:4:::1;::::0;84368:36:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;84346:58:::0;-1:-1:-1;84421:16:0;84417:55:::1;;84454:7;;;84417:55;84554:5;::::0;84537:3:::1;::::0;84530:33:::1;::::0;-1:-1:-1;;;;;84537:3:0;;::::1;::::0;84554:5:::1;;84530:23;:33::i;:::-;84598:5;::::0;84581:3:::1;::::0;84574:43:::1;::::0;-1:-1:-1;;;;;84581:3:0;;::::1;::::0;84598:5:::1;84605:11:::0;84574:23:::1;:43::i;:::-;84655:15;::::0;;84668:1:::1;84655:15:::0;;;84630:22:::1;84655:15:::0;;::::1;::::0;;84630:22;84655:15:::1;::::0;::::1;::::0;;::::1;::::0;::::1;-1:-1:-1::0;;84700:6:0::1;::::0;84681:9;;;;-1:-1:-1;;;;;;84700:6:0::1;::::0;84681:9;;-1:-1:-1;84700:6:0::1;::::0;84681:9:::1;;;;-1:-1:-1::0;;;;;84681:26:0;;::::1;:9;::::0;;::::1;::::0;;;;;:26;84737:6:::1;::::0;84718:9;;84737:6;::::1;::::0;84718;;84737;;84718:9;::::1;;;;;-1:-1:-1::0;;;;;84718:26:0;;;::::1;:9;::::0;;::::1;::::0;;;;;;:26;84889:16:::1;::::0;;84903:1:::1;84889:16:::0;;;84860:26:::1;84889:16:::0;;::::1;::::0;;84785:64:::1;::::0;84860:26;;84889:16;;::::1;::::0;;::::1;::::0;::::1;;::::0;-1:-1:-1;84889:16:0::1;84860:45;;84931:11;84916:9;84926:1;84916:12;;;;;;;;;;;;;:26;;;::::0;::::1;84968:1;84953:9;84963:1;84953:12;;;;;;;;;;;;;:16;;;::::0;::::1;84980:20;85003:1;84980:24;;85017:21;85052:8;85062:9;85073:12;85041:45;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;85017:69;;85099:38;;:::i;:::-;-1:-1:-1::0;85140:177:0::1;::::0;;::::1;::::0;::::1;::::0;;;;;::::1;::::0;::::1;::::0;;;;;;;;;-1:-1:-1;85140:177:0;;;;;;85355:4:::1;::::0;;85348:37;;-1:-1:-1;;;85348:37:0;;85140:177;;-1:-1:-1;;;;;;;85355:4:0;;::::1;::::0;85348:22:::1;::::0;:37:::1;::::0;85379:4:::1;::::0;85348:37:::1;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;85406:5;::::0;85422:6:::1;::::0;85398:70:::1;::::0;-1:-1:-1;;;85398:70:0;;85330:55;;-1:-1:-1;;;;;;85406:5:0;;::::1;::::0;85398:23:::1;::::0;:70:::1;::::0;85438:4:::1;::::0;;;85460:7;;85398:70:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;85505:4:0::1;::::0;;85498:37:::1;::::0;-1:-1:-1;;;85498:37:0;;85481:14:::1;::::0;-1:-1:-1;;;;;;85505:4:0;;::::1;::::0;-1:-1:-1;85498:22:0::1;::::0;:37:::1;::::0;85529:4:::1;::::0;85498:37:::1;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;85481:54:::0;-1:-1:-1;85546:15:0::1;85564:19;85481:54:::0;85575:7;85564:10:::1;:19::i;:::-;85546:37;;85594:56;85642:7;85594:47;:56::i;:::-;43735:1;;;;;;;;;;;84285:1373::o:0;42470:53::-;42517:6;42470:53;:::o;46458:289::-;46559:10;;46509:15;;-1:-1:-1;;;;;46559:10:0;46545;:24;46537:48;;;;-1:-1:-1;;;46537:48:0;;;;;;;:::i;:::-;46604:4;;-1:-1:-1;;;;;46604:23:0;;;:4;;:23;;46596:40;;;;-1:-1:-1;;;46596:40:0;;;;;;;:::i;:::-;46657:31;;-1:-1:-1;;;46657:31:0;;-1:-1:-1;;;;;46657:16:0;;;;;:31;;46682:4;;46657:31;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;46719:10;;46647:41;;-1:-1:-1;46699:40:0;;-1:-1:-1;;;;;46699:19:0;;;;46719:10;46647:41;46699:19;:40::i;:::-;46458:289;;;:::o;42424:39::-;;;;:::o;42026:41::-;;;;:::o;42677:25::-;;;-1:-1:-1;;;;;42677:25:0;;:::o;82778:29::-;;;;:::o;42818:71::-;;;-1:-1:-1;;;;;42818:71:0;;:::o;43978:113::-;44020:7;44047:36;44067:15;:13;:15::i;:::-;44047;:13;:15::i;:::-;:19;;:36::i;84112:165::-;84200:10;;-1:-1:-1;;;;;84200:10:0;84186;:24;84178:51;;;;-1:-1:-1;;;84178:51:0;;;;;;;:::i;:::-;84240:14;:29;;-1:-1:-1;;;;;;84240:29:0;-1:-1:-1;;;;;84240:29:0;;;;;;;;;;84112:165::o;45057:195::-;45165:8;;-1:-1:-1;;;;;45165:8:0;45151:10;:22;45143:44;;;;-1:-1:-1;;;45143:44:0;;;;;;;:::i;:::-;45198:21;:46;45057:195::o;48413:430::-;48504:10;;48454:15;;-1:-1:-1;;;;;48504:10:0;48490;:24;48482:48;;;;-1:-1:-1;;;48482:48:0;;;;;;;:::i;:::-;48541:14;:12;:14::i;:::-;48585:4;;;48578:37;;-1:-1:-1;;;48578:37:0;;-1:-1:-1;;;;;48585:4:0;;;;48578:22;;:37;;48609:4;;48578:37;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;48655:10;;48680:4;;;48643:43;;-1:-1:-1;;;48643:43:0;;48568:47;;-1:-1:-1;48628:12:0;;-1:-1:-1;;;;;48655:10:0;;;;48643:28;;:43;;48680:4;;;;48643:43;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;48628:58;-1:-1:-1;;;;;;48705:18:0;;48697:35;;;;-1:-1:-1;;;48697:35:0;;;;;;;:::i;:::-;48802:4;;48795:40;;-1:-1:-1;;;;;48802:4:0;48821;48827:7;48795:25;:40::i;:::-;48413:430;;:::o;42898:42::-;;;;;;;;;;;;;;;:::o;42137:36::-;;;;:::o;42314:40::-;;;;:::o;46145:151::-;46231:8;;-1:-1:-1;;;;;46231:8:0;46217:10;:22;46209:44;;;;-1:-1:-1;;;46209:44:0;;;;;;;:::i;:::-;46264:10;:24;;-1:-1:-1;;;;;;46264:24:0;-1:-1:-1;;;;;46264:24:0;;;;;;;;;;46145:151::o;45831:155::-;45917:10;;-1:-1:-1;;;;;45917:10:0;45903;:24;45895:48;;;;-1:-1:-1;;;45895:48:0;;;;;;;:::i;:::-;45954:10;:24;;-1:-1:-1;;;;;;45954:24:0;-1:-1:-1;;;;;45954:24:0;;;;;;;;;;45831:155::o;44858:191::-;44964:8;;-1:-1:-1;;;;;44964:8:0;44950:10;:22;44942:44;;;;-1:-1:-1;;;44942:44:0;;;;;;;:::i;:::-;44997:20;:44;44858:191::o;44551:299::-;44651:10;;-1:-1:-1;;;;;44651:10:0;44637;:24;;:66;;-1:-1:-1;44693:10:0;;-1:-1:-1;;;;;44693:10:0;44679;:24;44637:66;44629:93;;;;-1:-1:-1;;;44629:93:0;;;;;;;:::i;:::-;44740:6;44735:108;44752:22;;;44735:108;;;44826:5;44797:10;:26;44808:11;;44820:1;44808:14;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;44797:26:0;;;;;;;;;;;;-1:-1:-1;44797:26:0;:34;;-1:-1:-1;;44797:34:0;;;;;;;;;;-1:-1:-1;44776:4:0;44735:108;;45994:143;46076:8;;-1:-1:-1;;;;;46076:8:0;46062:10;:22;46054:44;;;;-1:-1:-1;;;46054:44:0;;;;;;;:::i;:::-;46109:8;:20;;-1:-1:-1;;;;;;46109:20:0;-1:-1:-1;;;;;46109:20:0;;;;;;;;;;45994:143::o;43781:118::-;43861:4;;;43854:37;;-1:-1:-1;;;43854:37:0;;43827:7;;-1:-1:-1;;;;;43861:4:0;;;;43854:22;;:37;;43885:4;;43854:37;;:::i;47909:428::-;48042:10;;47987:15;;-1:-1:-1;;;;;48042:10:0;48028;:24;48020:48;;;;-1:-1:-1;;;48020:48:0;;;;;;;:::i;:::-;48079:22;48093:7;48079:13;:22::i;:::-;-1:-1:-1;48131:4:0;;;48124:37;;-1:-1:-1;;;48124:37:0;;-1:-1:-1;;;;;48131:4:0;;;;48124:22;;:37;;48155:4;;48124:37;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;48201:10;;48226:4;;;48189:43;;-1:-1:-1;;;48189:43:0;;48114:47;;-1:-1:-1;48174:12:0;;-1:-1:-1;;;;;48201:10:0;;;;48189:28;;:43;;48226:4;;;;48189:43;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;48174:58;-1:-1:-1;;;;;;48251:18:0;;48243:35;;;;-1:-1:-1;;;48243:35:0;;;;;;;:::i;:::-;48296:4;;48289:40;;-1:-1:-1;;;;;48296:4:0;48315;48321:7;48289:25;:40::i;:::-;47909:428;;;;:::o;45260:179::-;45360:8;;-1:-1:-1;;;;;45360:8:0;45346:10;:22;45338:44;;;;-1:-1:-1;;;45338:44:0;;;;;;;:::i;:::-;45393:17;:38;45260:179::o;45668:155::-;45754:10;;-1:-1:-1;;;;;45754:10:0;45740;:24;45732:48;;;;-1:-1:-1;;;45732:48:0;;;;;;;:::i;:::-;45791:10;:24;;-1:-1:-1;;;;;;45791:24:0;-1:-1:-1;;;;;45791:24:0;;;;;;;;;;45668:155::o;82716:28::-;;;-1:-1:-1;;;;;82716:28:0;;:::o;42773:23::-;;;-1:-1:-1;;;;;42773:23:0;;:::o;42709:25::-;;;-1:-1:-1;;;;;42709:25:0;;:::o;82432:65::-;;;-1:-1:-1;;;;;82432:65:0;;:::o;1463:136::-;1521:7;1548:43;1552:1;1555;1548:43;;;;;;;;;;;;;;;;;:3;:43::i;:::-;1541:50;;1463:136;;;;;:::o;83635:141::-;83761:7;83635:141::o;999:181::-;1057:7;1089:5;;;1113:6;;;;1105:46;;;;-1:-1:-1;;;1105:46:0;;;;;;;:::i;2353:471::-;2411:7;2656:6;2652:47;;-1:-1:-1;2686:1:0;2679:8;;2652:47;2723:5;;;2727:1;2723;:5;:1;2747:5;;;;;:10;2739:56;;;;-1:-1:-1;;;2739:56:0;;;;;;;:::i;3300:132::-;3358:7;3385:39;3389:1;3392;3385:39;;;;;;;;;;;;;;;;;:3;:39::i;26789:177::-;26872:86;26892:5;26922:23;;;26947:2;26951:5;26899:58;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;26899:58:0;;;;;;;;;;;;;;-1:-1:-1;;;;;26899:58:0;-1:-1:-1;;;;;;26899:58:0;;;;;;;;;;26872:19;:86::i;27448:622::-;27818:10;;;27817:62;;-1:-1:-1;27834:39:0;;-1:-1:-1;;;27834:39:0;;-1:-1:-1;;;;;27834:15:0;;;;;:39;;27858:4;;27865:7;;27834:39;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:44;27817:62;27809:152;;;;-1:-1:-1;;;27809:152:0;;;;;;;:::i;:::-;27972:90;27992:5;28022:22;;;28046:7;28055:5;27999:62;;;;;;;;;:::i;52102:730::-;52219:4;;;52212:37;;-1:-1:-1;;;52212:37:0;;52196:13;;-1:-1:-1;;;;;52219:4:0;;;;52212:22;;:37;;52243:4;;52212:37;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;52196:53;;52276:5;52266:7;:15;52262:63;;;52308:5;52298:15;;52262:63;52341:11;;52337:488;;52455:10;;52443:34;;;-1:-1:-1;;;52443:34:0;;;;52399:175;;-1:-1:-1;;;;;52455:10:0;;52443:32;;:34;;;;;;;;;;;;;;52455:10;52443:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;52496:63;42123:5;52496:35;52508:22;;52496:7;:11;;:35;;;;:::i;52399:175::-;52679:10;;52667:33;;;-1:-1:-1;;;52667:33:0;;;;52623:164;;-1:-1:-1;;;;;52679:10:0;;52667:31;;:33;;;;;;;;;;;;;;52679:10;52667:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;52719:53;42224:5;52719:30;52731:17;;52719:7;:11;;:30;;;;:::i;52623:164::-;52804:9;:7;:9::i;:::-;52102:730;;:::o;48851:82::-;48895:30;48909:15;:13;:15::i;48895:30::-;;48851:82::o;1902:192::-;1988:7;2024:12;2016:6;;;;2008:29;;;;-1:-1:-1;;;2008:29:0;;;;;;;;:::i;:::-;-1:-1:-1;;;2060:5:0;;;1902:192::o;3928:278::-;4014:7;4049:12;4042:5;4034:28;;;;-1:-1:-1;;;4034:28:0;;;;;;;;:::i;:::-;;4073:9;4089:1;4085;:5;;;;;;;3928:278;-1:-1:-1;;;;;3928:278:0:o;29094:761::-;29518:23;29544:69;29572:4;29544:69;;;;;;;;;;;;;;;;;29552:5;-1:-1:-1;;;;;29544:27:0;;;:69;;;;;:::i;:::-;29628:17;;29518:95;;-1:-1:-1;29628:21:0;29624:224;;29770:10;29759:30;;;;;;;;;;;;:::i;:::-;29751:85;;;;-1:-1:-1;;;29751:85:0;;;;;;;:::i;12915:196::-;13018:12;13050:53;13073:6;13081:4;13087:1;13090:12;13050:22;:53::i;:::-;13043:60;12915:196;-1:-1:-1;;;;12915:196:0:o;14292:979::-;14422:12;14455:18;14466:6;14455:10;:18::i;:::-;14447:60;;;;-1:-1:-1;;;14447:60:0;;;;;;;:::i;:::-;14581:12;14595:23;14622:6;-1:-1:-1;;;;;14622:11:0;14642:8;14653:4;14622:36;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14580:78;;;;14673:7;14669:595;;;14704:10;-1:-1:-1;14697:17:0;;-1:-1:-1;14697:17:0;14669:595;14818:17;;:21;14814:439;;15081:10;15075:17;15142:15;15129:10;15125:2;15121:19;15114:44;15029:148;15224:12;15217:20;;-1:-1:-1;;;15217:20:0;;;;;;;;:::i;9997:422::-;10364:20;10403:8;;;9997:422::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;2558:241::-;;2662:2;2650:9;2641:7;2637:23;2633:32;2630:2;;;-1:-1;;2668:12;2630:2;85:6;72:20;97:33;124:5;97:33;:::i;2806:263::-;;2921:2;2909:9;2900:7;2896:23;2892:32;2889:2;;;-1:-1;;2927:12;2889:2;226:6;220:13;238:33;265:5;238:33;:::i;3076:470::-;;;3206:2;3194:9;3185:7;3181:23;3177:32;3174:2;;;-1:-1;;3212:12;3174:2;85:6;72:20;97:33;124:5;97:33;:::i;:::-;3264:63;-1:-1;3392:2;3377:18;;;3364:32;3416:18;3405:30;;;3402:2;;;-1:-1;;3438:12;3402:2;3513:6;3502:9;3498:22;;;1768:3;1761:4;1753:6;1749:17;1745:27;1735:2;;-1:-1;;1776:12;1735:2;1823:6;1810:20;3416:18;27314:6;27311:30;27308:2;;;-1:-1;;27344:12;27308:2;1845:64;27417:9;27398:17;;-1:-1;;27394:33;27475:15;;1845:64;:::i;:::-;1836:73;;1929:6;1922:5;1915:21;2033:3;3392:2;2024:6;1957;2015:16;;2012:25;2009:2;;;-1:-1;;2040:12;2009:2;31681:6;3392:2;1957:6;1953:17;3392:2;1991:5;1987:16;31658:30;31719:16;;;;;31712:27;;;;3168:378;;1991:5;;-1:-1;3168:378;;-1:-1;;3168:378::o;3553:397::-;;;3692:2;3680:9;3671:7;3667:23;3663:32;3660:2;;;-1:-1;;3698:12;3660:2;3756:17;3743:31;3794:18;;3786:6;3783:30;3780:2;;;-1:-1;;3816:12;3780:2;3917:6;3906:9;3902:22;;;431:3;424:4;416:6;412:17;408:27;398:2;;-1:-1;;439:12;398:2;482:6;469:20;3794:18;501:6;498:30;495:2;;;-1:-1;;531:12;495:2;626:3;3692:2;;610:6;606:17;567:6;592:32;;589:41;586:2;;;-1:-1;;633:12;586:2;3692;563:17;;;;;3836:98;;-1:-1;3654:296;;-1:-1;;;;3654:296::o;3957:257::-;;4069:2;4057:9;4048:7;4044:23;4040:32;4037:2;;;-1:-1;;4075:12;4037:2;1475:6;1469:13;32451:5;30609:13;30602:21;32429:5;32426:32;32416:2;;-1:-1;;32462:12;4497:241;;4601:2;4589:9;4580:7;4576:23;4572:32;4569:2;;;-1:-1;;4607:12;4569:2;-1:-1;2347:20;;4563:175;-1:-1;4563:175::o;4745:263::-;;4860:2;4848:9;4839:7;4835:23;4831:32;4828:2;;;-1:-1;;4866:12;4828:2;-1:-1;2495:13;;4822:186;-1:-1;4822:186::o;5015:627::-;;;;5178:2;5166:9;5157:7;5153:23;5149:32;5146:2;;;-1:-1;;5184:12;5146:2;2360:6;2347:20;5236:63;;5336:2;;5379:9;5375:22;2347:20;5344:63;;5472:2;5461:9;5457:18;5444:32;5496:18;5488:6;5485:30;5482:2;;;-1:-1;;5518:12;5482:2;5594:22;;789:4;777:17;;773:27;-1:-1;763:2;;-1:-1;;804:12;763:2;851:6;838:20;873:80;888:64;945:6;888:64;:::i;:::-;873:80;:::i;:::-;981:21;;;1038:14;;;;1013:17;;;1127;;;1118:27;;;;1115:36;-1:-1;1112:2;;;-1:-1;;1154:12;1112:2;-1:-1;1180:10;;1174:206;1199:6;1196:1;1193:13;1174:206;;;1596:20;;1267:50;;1221:1;1214:9;;;;;1331:14;;;;1359;;1174:206;;;1178:14;5538:88;;;;;;;;5140:502;;;;;:::o;5832:203::-;-1:-1;;;;;31027:54;10865:65;;6024:4;6015:14;;5927:108::o;6044:173::-;9577:37;;6206:4;6197:14;;6124:93::o;9304:94::-;30609:13;30602:21;9359:34;;9353:45::o;9746:323::-;;9878:5;28099:12;29181:6;29176:3;29169:19;9961:52;10006:6;29218:4;29213:3;29209:14;29218:4;9987:5;9983:16;9961:52;:::i;:::-;27417:9;32098:14;-1:-1;;32094:28;10025:39;;;;29218:4;10025:39;;9826:243;-1:-1;;9826:243::o;16962:271::-;;10586:5;28099:12;10697:52;10742:6;10737:3;10730:4;10723:5;10719:16;10697:52;:::i;:::-;10761:16;;;;;17096:137;-1:-1;;17096:137::o;17240:222::-;-1:-1;;;;;31027:54;;;;6296:37;;17367:2;17352:18;;17338:124::o;17469:333::-;-1:-1;;;;;31027:54;;;6296:37;;31027:54;;17788:2;17773:18;;6296:37;17624:2;17609:18;;17595:207::o;17809:333::-;-1:-1;;;;;31027:54;;;;6296:37;;18128:2;18113:18;;9577:37;17964:2;17949:18;;17935:207::o;18149:704::-;-1:-1;;;;;31027:54;;6296:37;;18575:2;18560:18;;;9577:37;;;18658:2;18643:18;;9577:37;;;18410:3;18695:2;18680:18;;18673:48;;;28099:12;;18395:19;;;29169;;;18149:704;;27622:14;;;;31038:42;29209:14;;;18149:704;6784:260;6809:6;6806:1;6803:13;6784:260;;;6870:13;;9577:37;;28789:14;;;;5803;;;;6831:1;6824:9;6784:260;;;-1:-1;18727:116;;18381:472;-1:-1;;;;;;;;;18381:472::o;18860:210::-;30609:13;;30602:21;9359:34;;18981:2;18966:18;;18952:118::o;19077:222::-;9577:37;;;19204:2;19189:18;;19175:124::o;19306:736::-;;9607:5;9584:3;9577:37;19748:2;3416:18;;31038:42;;;;30525:5;31027:54;19748:2;19737:9;19733:18;6296:37;31038:42;30525:5;31027:54;19831:2;19820:9;19816:18;6296:37;;19583:3;19868:2;19857:9;19853:18;19846:48;15740:14;19572:9;15740:14;15823:16;15817:23;19583:3;;19572:9;19568:19;15853:38;15906:118;7326:5;28099:12;7345:76;7414:6;7409:3;7345:76;:::i;:::-;27622:14;;;;-1:-1;;;7338:83;-1:-1;7546:290;7571:6;7568:1;7565:13;7546:290;;;7659:78;7733:3;7638:6;7632:13;7659:78;:::i;:::-;7652:85;;19748:2;7822:6;28789:14;7744:85;;7593:1;7590;7586:9;7581:14;;7546:290;;;7550:14;19748:2;16110:5;16106:16;16100:23;16080:43;;16159:14;;;;;19572:9;16163:4;16159:14;;16143;19572:9;16143:14;16136:38;16189:103;8080:5;28099:12;8099:76;8168:6;8163:3;8099:76;:::i;:::-;27622:14;;;;-1:-1;;;8092:83;-1:-1;8285:260;8310:6;8307:1;8304:13;8285:260;;;8398:63;8457:3;8377:6;8371:13;8398:63;:::i;:::-;8391:70;;19748:2;8531:6;28789:14;8468:70;;7593:1;8329;8325:9;8320:14;;8285:260;;;8289:14;19831:2;16374:5;16370:16;16364:23;16344:43;;16159:14;19572:9;16427:4;16423:14;;16407;19572:9;16407:14;16400:38;16453:71;16519:4;16505:12;16453:71;:::i;:::-;16445:79;;;;;;19868:2;16617:5;16613:16;16607:23;16636:57;16678:14;19572:9;16678:14;16664:12;16636:57;:::i;:::-;-1:-1;19900:132;19554:488;-1:-1;;;;;;19554:488::o;20049:306::-;;20194:2;20215:17;20208:47;20269:76;20194:2;20183:9;20179:18;20331:6;20269:76;:::i;20362:614::-;;20606:2;20595:9;20591:18;32217:1;32210:5;32207:12;32197:2;;32223:9;32197:2;31550:37;11031:3;11024:61;20735:2;20606;20735;20724:9;20720:18;20713:48;20775:108;8799:5;28099:12;29181:6;29176:3;29169:19;29209:14;20595:9;29209:14;8811:93;;20735:2;8975:5;27622:14;8987:21;;-1:-1;9014:260;9039:6;9036:1;9033:13;9014:260;;;9100:13;;9577:37;;28789:14;;;;6197;;;;9061:1;9054:9;9014:260;;;9018:14;;20767:116;;;;;;9607:5;20962:2;20951:9;20947:18;9577:37;20577:399;;;;;;:::o;21300:416::-;21500:2;21514:47;;;11676:2;21485:18;;;29169:19;-1:-1;;;29209:14;;;11692:34;11745:12;;;21471:245::o;21723:416::-;21923:2;21937:47;;;11996:1;21908:18;;;29169:19;-1:-1;;;29209:14;;;12011:30;12060:12;;;21894:245::o;22146:416::-;22346:2;22360:47;;;12311:2;22331:18;;;29169:19;-1:-1;;;29209:14;;;12327:34;12380:12;;;22317:245::o;22569:416::-;22769:2;22783:47;;;12631:2;22754:18;;;29169:19;12667:29;29209:14;;;12647:50;12716:12;;;22740:245::o;22992:416::-;23192:2;23206:47;;;12967:1;23177:18;;;29169:19;-1:-1;;;29209:14;;;12982:27;13028:12;;;23163:245::o;23415:416::-;23615:2;23629:47;;;13279:2;23600:18;;;29169:19;-1:-1;;;29209:14;;;13295:37;13351:12;;;23586:245::o;23838:416::-;24038:2;24052:47;;;13602:2;24023:18;;;29169:19;13638:34;29209:14;;;13618:55;-1:-1;;;13693:12;;;13686:25;13730:12;;;24009:245::o;24261:416::-;24461:2;24475:47;;;13981:1;24446:18;;;29169:19;-1:-1;;;29209:14;;;13996:27;14042:12;;;24432:245::o;24684:416::-;24884:2;24898:47;;;14293:2;24869:18;;;29169:19;14329:31;29209:14;;;14309:52;14380:12;;;24855:245::o;25107:416::-;25307:2;25321:47;;;14631:2;25292:18;;;29169:19;14667:34;29209:14;;;14647:55;-1:-1;;;14722:12;;;14715:34;14768:12;;;25278:245::o;25530:416::-;25730:2;25744:47;;;15019:1;25715:18;;;29169:19;-1:-1;;;29209:14;;;15034:32;15085:12;;;25701:245::o;25953:416::-;26153:2;26167:47;;;15336:2;26138:18;;;29169:19;15372:34;29209:14;;;15352:55;-1:-1;;;15427:12;;;15420:46;15485:12;;;26124:245::o;26605:256::-;26667:2;26661:9;26693:17;;;26768:18;26753:34;;26789:22;;;26750:62;26747:2;;;26825:1;;26815:12;26747:2;26667;26834:22;26645:216;;-1:-1;26645:216::o;26868:304::-;;27027:18;27019:6;27016:30;27013:2;;;-1:-1;;27049:12;27013:2;-1:-1;27094:4;27082:17;;;27147:15;;26950:222::o;31754:268::-;31819:1;31826:101;31840:6;31837:1;31834:13;31826:101;;;31907:11;;;31901:18;31888:11;;;31881:39;31862:2;31855:10;31826:101;;;31942:6;31939:1;31936:13;31933:2;;;31819:1;31998:6;31993:3;31989:16;31982:27;31933:2;;31803:219;;;:::o;32246:117::-;-1:-1;;;;;31027:54;;32305:35;;32295:2;;32354:1;;32344:12
Metadata Hash
2769630caea7fefecc71fe35aba79c573a640409b3c2ccdbfae18c07ab38116c
Age | Block | Fee Address | BC Fee Address | Voting Power | Jailed | Incoming |
---|
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.