More Info
Private Name Tags
ContractCreator
TokenTracker
Latest 17 from a total of 17 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
Value | ||||
---|---|---|---|---|---|---|---|---|---|
Approve | 18425697 | 258 days ago | IN | 0 ETH | 0.00032434 | ||||
Approve | 18377616 | 265 days ago | IN | 0 ETH | 0.00074459 | ||||
Approve | 18377561 | 265 days ago | IN | 0 ETH | 0.00082553 | ||||
Approve | 18377552 | 265 days ago | IN | 0 ETH | 0.00084387 | ||||
Approve | 18377544 | 265 days ago | IN | 0 ETH | 0.00093094 | ||||
Approve | 18377541 | 265 days ago | IN | 0 ETH | 0.00085636 | ||||
Approve | 18377535 | 265 days ago | IN | 0 ETH | 0.00081236 | ||||
Approve | 18377535 | 265 days ago | IN | 0 ETH | 0.00090541 | ||||
Approve | 18377535 | 265 days ago | IN | 0 ETH | 0.00090541 | ||||
Approve | 18377535 | 265 days ago | IN | 0 ETH | 0.0013717 | ||||
Approve | 18377408 | 265 days ago | IN | 0 ETH | 0.00055282 | ||||
Renounce Ownersh... | 18377230 | 265 days ago | IN | 0 ETH | 0.00027367 | ||||
Renounce Role | 18377228 | 265 days ago | IN | 0 ETH | 0.00038856 | ||||
Renounce Role | 18377225 | 265 days ago | IN | 0 ETH | 0.00052549 | ||||
Grant Role | 18377173 | 265 days ago | IN | 0 ETH | 0.00082288 | ||||
Set Farm Address | 18377170 | 265 days ago | IN | 0 ETH | 0.00044811 | ||||
0x60806040 | 18377117 | 265 days ago | IN | Create: DebaseToken | 0 ETH | 0.049512 |
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Contract Name:
DebaseToken
Compiler Version
v0.8.14+commit.80d49f37
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2023-10-18 */ // Potato Farm Socials: // Twitter: https://twitter.com/PotatoFarmERC // Telegram: https://t.me/PotatoFarmERC // Dapp: https://potatoes.farm/ // Docs: https://docs.potatoes.farm/ // SPDX-License-Identifier: MIT // Sources flattened with hardhat v2.7.1 https://hardhat.org // File @uniswap/v2-periphery/contracts/interfaces/[email protected] pragma solidity >=0.6.2; interface IUniswapV2Router01 { function factory() external pure returns (address); function WETH() external pure returns (address); function addLiquidity( address tokenA, address tokenB, uint amountADesired, uint amountBDesired, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB, uint liquidity); function addLiquidityETH( address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external payable returns (uint amountToken, uint amountETH, uint liquidity); function removeLiquidity( address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB); function removeLiquidityETH( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external returns (uint amountToken, uint amountETH); function removeLiquidityWithPermit( address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountA, uint amountB); function removeLiquidityETHWithPermit( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountToken, uint amountETH); function swapExactTokensForTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); function swapTokensForExactTokens( uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB); function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut); function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn); function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts); function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts); } // File @uniswap/v2-periphery/contracts/interfaces/[email protected] pragma solidity >=0.6.2; interface IUniswapV2Router02 is IUniswapV2Router01 { function removeLiquidityETHSupportingFeeOnTransferTokens( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external returns (uint amountETH); function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountETH); function swapExactTokensForTokensSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; function swapExactETHForTokensSupportingFeeOnTransferTokens( uint amountOutMin, address[] calldata path, address to, uint deadline ) external payable; function swapExactTokensForETHSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; } // File @uniswap/v2-core/contracts/interfaces/[email protected] pragma solidity >=0.5.0; interface IUniswapV2Factory { event PairCreated(address indexed token0, address indexed token1, address pair, uint); function feeTo() external view returns (address); function feeToSetter() external view returns (address); function getPair(address tokenA, address tokenB) external view returns (address pair); function allPairs(uint) external view returns (address pair); function allPairsLength() external view returns (uint); function createPair(address tokenA, address tokenB) external returns (address pair); function setFeeTo(address) external; function setFeeToSetter(address) external; } // File @uniswap/v2-core/contracts/interfaces/[email protected] pragma solidity >=0.5.0; interface IUniswapV2Pair { event Approval(address indexed owner, address indexed spender, uint value); event Transfer(address indexed from, address indexed to, uint 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 (uint); function balanceOf(address owner) external view returns (uint); function allowance(address owner, address spender) external view returns (uint); function approve(address spender, uint value) external returns (bool); function transfer(address to, uint value) external returns (bool); function transferFrom(address from, address to, uint 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 (uint); function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external; event Mint(address indexed sender, uint amount0, uint amount1); event Burn(address indexed sender, uint amount0, uint amount1, address indexed to); event Swap( address indexed sender, uint amount0In, uint amount1In, uint amount0Out, uint amount1Out, address indexed to ); event Sync(uint112 reserve0, uint112 reserve1); function MINIMUM_LIQUIDITY() external pure returns (uint); 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 (uint); function price1CumulativeLast() external view returns (uint); function kLast() external view returns (uint); function mint(address to) external returns (uint liquidity); function burn(address to) external returns (uint amount0, uint amount1); function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external; function skim(address to) external; function sync() external; function initialize(address, address) external; } // File @openzeppelin/contracts/utils/[email protected] // OpenZeppelin Contracts v4.4.1 (utils/Context.sol) pragma solidity ^0.8.0; /** * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } } // File @openzeppelin/contracts/access/[email protected] // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol) pragma solidity ^0.8.0; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor() { _transferOwnership(_msgSender()); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { require(owner() == _msgSender(), "Ownable: caller is not the owner"); } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions anymore. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby removing any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } } // File @openzeppelin/contracts/token/ERC20/[email protected] // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @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); /** * @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 `to`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address to, 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 `from` to `to` 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 from, address to, uint256 amount ) external returns (bool); } // File @openzeppelin/contracts/token/ERC20/extensions/[email protected] // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol) pragma solidity ^0.8.0; /** * @dev Interface for the optional metadata functions from the ERC20 standard. * * _Available since v4.1._ */ interface IERC20Metadata is IERC20 { /** * @dev Returns the name of the token. */ function name() external view returns (string memory); /** * @dev Returns the symbol of the token. */ function symbol() external view returns (string memory); /** * @dev Returns the decimals places of the token. */ function decimals() external view returns (uint8); } // File @openzeppelin/contracts/token/ERC20/[email protected] // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/ERC20.sol) pragma solidity ^0.8.0; /** * @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.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How * to implement supply mechanisms]. * * We have followed general OpenZeppelin Contracts guidelines: functions revert * instead 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, IERC20Metadata { mapping(address => uint256) private _balances; mapping(address => mapping(address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; /** * @dev Sets the values for {name} and {symbol}. * * The default value of {decimals} is 18. To select a different value for * {decimals} you should overload it. * * All two of these values are immutable: they can only be set once during * construction. */ constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; } /** * @dev Returns the name of the token. */ function name() public view virtual override returns (string memory) { return _name; } /** * @dev Returns the symbol of the token, usually a shorter version of the * name. */ function symbol() public view virtual override 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 this function is * overridden; * * 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 virtual override returns (uint8) { return 18; } /** * @dev See {IERC20-totalSupply}. */ function totalSupply() public view virtual override returns (uint256) { return _totalSupply; } /** * @dev See {IERC20-balanceOf}. */ function balanceOf(address account) public view virtual override returns (uint256) { return _balances[account]; } /** * @dev See {IERC20-transfer}. * * Requirements: * * - `to` cannot be the zero address. * - the caller must have a balance of at least `amount`. */ function transfer(address to, uint256 amount) public virtual override returns (bool) { address owner = _msgSender(); _transfer(owner, to, 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}. * * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on * `transferFrom`. This is semantically equivalent to an infinite approval. * * Requirements: * * - `spender` cannot be the zero address. */ function approve(address spender, uint256 amount) public virtual override returns (bool) { address owner = _msgSender(); _approve(owner, 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}. * * NOTE: Does not update the allowance if the current allowance * is the maximum `uint256`. * * Requirements: * * - `from` and `to` cannot be the zero address. * - `from` must have a balance of at least `amount`. * - the caller must have allowance for ``from``'s tokens of at least * `amount`. */ function transferFrom( address from, address to, uint256 amount ) public virtual override returns (bool) { address spender = _msgSender(); _spendAllowance(from, spender, amount); _transfer(from, to, amount); 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) { address owner = _msgSender(); _approve(owner, spender, allowance(owner, spender) + 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) { address owner = _msgSender(); uint256 currentAllowance = allowance(owner, spender); require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero"); unchecked { _approve(owner, spender, currentAllowance - subtractedValue); } return true; } /** * @dev Moves `amount` of tokens from `from` to `to`. * * This 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: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `from` must have a balance of at least `amount`. */ function _transfer( address from, address to, uint256 amount ) internal virtual { require(from != address(0), "ERC20: transfer from the zero address"); require(to != address(0), "ERC20: transfer to the zero address"); _beforeTokenTransfer(from, to, amount); uint256 fromBalance = _balances[from]; require(fromBalance >= amount, "ERC20: transfer amount exceeds balance"); unchecked { _balances[from] = fromBalance - amount; // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by // decrementing then incrementing. _balances[to] += amount; } emit Transfer(from, to, amount); _afterTokenTransfer(from, to, 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: * * - `account` 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 += amount; unchecked { // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above. _balances[account] += amount; } emit Transfer(address(0), account, amount); _afterTokenTransfer(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); uint256 accountBalance = _balances[account]; require(accountBalance >= amount, "ERC20: burn amount exceeds balance"); unchecked { _balances[account] = accountBalance - amount; // Overflow not possible: amount <= accountBalance <= totalSupply. _totalSupply -= amount; } emit Transfer(account, address(0), amount); _afterTokenTransfer(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 Updates `owner` s allowance for `spender` based on spent `amount`. * * Does not update the allowance amount in case of infinite allowance. * Revert if not enough allowance is available. * * Might emit an {Approval} event. */ function _spendAllowance( address owner, address spender, uint256 amount ) internal virtual { uint256 currentAllowance = allowance(owner, spender); if (currentAllowance != type(uint256).max) { require(currentAllowance >= amount, "ERC20: insufficient allowance"); unchecked { _approve(owner, spender, currentAllowance - amount); } } } /** * @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 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 {} /** * @dev Hook that is called after any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * has been transferred to `to`. * - when `from` is zero, `amount` tokens have been minted for `to`. * - when `to` is zero, `amount` of ``from``'s tokens have been 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 _afterTokenTransfer( address from, address to, uint256 amount ) internal virtual {} } // File @openzeppelin/contracts/token/ERC20/extensions/[email protected] // OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/extensions/ERC20Burnable.sol) pragma solidity ^0.8.0; /** * @dev Extension of {ERC20} that allows token holders to destroy both their own * tokens and those that they have an allowance for, in a way that can be * recognized off-chain (via event analysis). */ abstract contract ERC20Burnable is Context, ERC20 { /** * @dev Destroys `amount` tokens from the caller. * * See {ERC20-_burn}. */ function burn(uint256 amount) public virtual { _burn(_msgSender(), amount); } /** * @dev Destroys `amount` tokens from `account`, deducting from the caller's * allowance. * * See {ERC20-_burn} and {ERC20-allowance}. * * Requirements: * * - the caller must have allowance for ``accounts``'s tokens of at least * `amount`. */ function burnFrom(address account, uint256 amount) public virtual { _spendAllowance(account, _msgSender(), amount); _burn(account, amount); } } // File @openzeppelin/contracts/access/[email protected] // OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol) pragma solidity ^0.8.0; /** * @dev External interface of AccessControl declared to support ERC165 detection. */ interface IAccessControl { /** * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole` * * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite * {RoleAdminChanged} not being emitted signaling this. * * _Available since v3.1._ */ event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole); /** * @dev Emitted when `account` is granted `role`. * * `sender` is the account that originated the contract call, an admin role * bearer except when using {AccessControl-_setupRole}. */ event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender); /** * @dev Emitted when `account` is revoked `role`. * * `sender` is the account that originated the contract call: * - if using `revokeRole`, it is the admin role bearer * - if using `renounceRole`, it is the role bearer (i.e. `account`) */ event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender); /** * @dev Returns `true` if `account` has been granted `role`. */ function hasRole(bytes32 role, address account) external view returns (bool); /** * @dev Returns the admin role that controls `role`. See {grantRole} and * {revokeRole}. * * To change a role's admin, use {AccessControl-_setRoleAdmin}. */ function getRoleAdmin(bytes32 role) external view returns (bytes32); /** * @dev Grants `role` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. * * Requirements: * * - the caller must have ``role``'s admin role. */ function grantRole(bytes32 role, address account) external; /** * @dev Revokes `role` from `account`. * * If `account` had been granted `role`, emits a {RoleRevoked} event. * * Requirements: * * - the caller must have ``role``'s admin role. */ function revokeRole(bytes32 role, address account) external; /** * @dev Revokes `role` from the calling account. * * Roles are often managed via {grantRole} and {revokeRole}: this function's * purpose is to provide a mechanism for accounts to lose their privileges * if they are compromised (such as when a trusted device is misplaced). * * If the calling account had been granted `role`, emits a {RoleRevoked} * event. * * Requirements: * * - the caller must be `account`. */ function renounceRole(bytes32 role, address account) external; } // File @openzeppelin/contracts/access/[email protected] // OpenZeppelin Contracts v4.4.1 (access/IAccessControlEnumerable.sol) pragma solidity ^0.8.0; /** * @dev External interface of AccessControlEnumerable declared to support ERC165 detection. */ interface IAccessControlEnumerable is IAccessControl { /** * @dev Returns one of the accounts that have `role`. `index` must be a * value between 0 and {getRoleMemberCount}, non-inclusive. * * Role bearers are not sorted in any particular way, and their ordering may * change at any point. * * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure * you perform all queries on the same block. See the following * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post] * for more information. */ function getRoleMember(bytes32 role, uint256 index) external view returns (address); /** * @dev Returns the number of accounts that have `role`. Can be used * together with {getRoleMember} to enumerate all bearers of a role. */ function getRoleMemberCount(bytes32 role) external view returns (uint256); } // File @openzeppelin/contracts/utils/math/[email protected] // OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol) pragma solidity ^0.8.0; /** * @dev Standard math utilities missing in the Solidity language. */ library Math { enum Rounding { Down, // Toward negative infinity Up, // Toward infinity Zero // Toward zero } /** * @dev Returns the largest of two numbers. */ function max(uint256 a, uint256 b) internal pure returns (uint256) { return a > b ? a : b; } /** * @dev Returns the smallest of two numbers. */ function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } /** * @dev Returns the average of two numbers. The result is rounded towards * zero. */ function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow. return (a & b) + (a ^ b) / 2; } /** * @dev Returns the ceiling of the division of two numbers. * * This differs from standard division with `/` in that it rounds up instead * of rounding down. */ function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b - 1) / b can overflow on addition, so we distribute. return a == 0 ? 0 : (a - 1) / b + 1; } /** * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0 * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) * with further edits by Uniswap Labs also under MIT license. */ function mulDiv( uint256 x, uint256 y, uint256 denominator ) internal pure returns (uint256 result) { unchecked { // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256 // variables such that product = prod1 * 2^256 + prod0. uint256 prod0; // Least significant 256 bits of the product uint256 prod1; // Most significant 256 bits of the product assembly { let mm := mulmod(x, y, not(0)) prod0 := mul(x, y) prod1 := sub(sub(mm, prod0), lt(mm, prod0)) } // Handle non-overflow cases, 256 by 256 division. if (prod1 == 0) { return prod0 / denominator; } // Make sure the result is less than 2^256. Also prevents denominator == 0. require(denominator > prod1); /////////////////////////////////////////////// // 512 by 256 division. /////////////////////////////////////////////// // Make division exact by subtracting the remainder from [prod1 prod0]. uint256 remainder; assembly { // Compute remainder using mulmod. remainder := mulmod(x, y, denominator) // Subtract 256 bit number from 512 bit number. prod1 := sub(prod1, gt(remainder, prod0)) prod0 := sub(prod0, remainder) } // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1. // See https://cs.stackexchange.com/q/138556/92363. // Does not overflow because the denominator cannot be zero at this stage in the function. uint256 twos = denominator & (~denominator + 1); assembly { // Divide denominator by twos. denominator := div(denominator, twos) // Divide [prod1 prod0] by twos. prod0 := div(prod0, twos) // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one. twos := add(div(sub(0, twos), twos), 1) } // Shift in bits from prod1 into prod0. prod0 |= prod1 * twos; // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for // four bits. That is, denominator * inv = 1 mod 2^4. uint256 inverse = (3 * denominator) ^ 2; // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works // in modular arithmetic, doubling the correct bits in each step. inverse *= 2 - denominator * inverse; // inverse mod 2^8 inverse *= 2 - denominator * inverse; // inverse mod 2^16 inverse *= 2 - denominator * inverse; // inverse mod 2^32 inverse *= 2 - denominator * inverse; // inverse mod 2^64 inverse *= 2 - denominator * inverse; // inverse mod 2^128 inverse *= 2 - denominator * inverse; // inverse mod 2^256 // Because the division is now exact we can divide by multiplying with the modular inverse of denominator. // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1 // is no longer required. result = prod0 * inverse; return result; } } /** * @notice Calculates x * y / denominator with full precision, following the selected rounding direction. */ function mulDiv( uint256 x, uint256 y, uint256 denominator, Rounding rounding ) internal pure returns (uint256) { uint256 result = mulDiv(x, y, denominator); if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) { result += 1; } return result; } /** * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down. * * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11). */ function sqrt(uint256 a) internal pure returns (uint256) { if (a == 0) { return 0; } // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target. // // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`. // // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)` // Ôćĺ `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))` // Ôćĺ `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)` // // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit. uint256 result = 1 << (log2(a) >> 1); // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128, // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision // into the expected uint128 result. unchecked { result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; return min(result, a / result); } } /** * @notice Calculates sqrt(a), following the selected rounding direction. */ function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = sqrt(a); return result + (rounding == Rounding.Up && result * result < a ? 1 : 0); } } /** * @dev Return the log in base 2, rounded down, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 128; } if (value >> 64 > 0) { value >>= 64; result += 64; } if (value >> 32 > 0) { value >>= 32; result += 32; } if (value >> 16 > 0) { value >>= 16; result += 16; } if (value >> 8 > 0) { value >>= 8; result += 8; } if (value >> 4 > 0) { value >>= 4; result += 4; } if (value >> 2 > 0) { value >>= 2; result += 2; } if (value >> 1 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 2, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log2(value); return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0); } } /** * @dev Return the log in base 10, rounded down, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >= 10**64) { value /= 10**64; result += 64; } if (value >= 10**32) { value /= 10**32; result += 32; } if (value >= 10**16) { value /= 10**16; result += 16; } if (value >= 10**8) { value /= 10**8; result += 8; } if (value >= 10**4) { value /= 10**4; result += 4; } if (value >= 10**2) { value /= 10**2; result += 2; } if (value >= 10**1) { result += 1; } } return result; } /** * @dev Return the log in base 10, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log10(value); return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0); } } /** * @dev Return the log in base 256, rounded down, of a positive value. * Returns 0 if given 0. * * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string. */ function log256(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 16; } if (value >> 64 > 0) { value >>= 64; result += 8; } if (value >> 32 > 0) { value >>= 32; result += 4; } if (value >> 16 > 0) { value >>= 16; result += 2; } if (value >> 8 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 10, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log256(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log256(value); return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0); } } } // File @openzeppelin/contracts/utils/[email protected] // OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol) pragma solidity ^0.8.0; /** * @dev String operations. */ library Strings { bytes16 private constant _SYMBOLS = "0123456789abcdef"; uint8 private constant _ADDRESS_LENGTH = 20; /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { unchecked { uint256 length = Math.log10(value) + 1; string memory buffer = new string(length); uint256 ptr; /// @solidity memory-safe-assembly assembly { ptr := add(buffer, add(32, length)) } while (true) { ptr--; /// @solidity memory-safe-assembly assembly { mstore8(ptr, byte(mod(value, 10), _SYMBOLS)) } value /= 10; if (value == 0) break; } return buffer; } } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { unchecked { return toHexString(value, Math.log256(value) + 1); } } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length. */ function toHexString(uint256 value, uint256 length) internal pure returns (string memory) { bytes memory buffer = new bytes(2 * length + 2); buffer[0] = "0"; buffer[1] = "x"; for (uint256 i = 2 * length + 1; i > 1; --i) { buffer[i] = _SYMBOLS[value & 0xf]; value >>= 4; } require(value == 0, "Strings: hex length insufficient"); return string(buffer); } /** * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation. */ function toHexString(address addr) internal pure returns (string memory) { return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH); } } // File @openzeppelin/contracts/utils/introspection/[email protected] // OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[EIP]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165 { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); } // File @openzeppelin/contracts/utils/introspection/[email protected] // OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol) pragma solidity ^0.8.0; /** * @dev Implementation of the {IERC165} interface. * * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check * for the additional interface id that will be supported. For example: * * ```solidity * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId); * } * ``` * * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation. */ abstract contract ERC165 is IERC165 { /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IERC165).interfaceId; } } // File @openzeppelin/contracts/access/[email protected] // OpenZeppelin Contracts (last updated v4.8.0) (access/AccessControl.sol) pragma solidity ^0.8.0; /** * @dev Contract module that allows children to implement role-based access * control mechanisms. This is a lightweight version that doesn't allow enumerating role * members except through off-chain means by accessing the contract event logs. Some * applications may benefit from on-chain enumerability, for those cases see * {AccessControlEnumerable}. * * Roles are referred to by their `bytes32` identifier. These should be exposed * in the external API and be unique. The best way to achieve this is by * using `public constant` hash digests: * * ``` * bytes32 public constant MY_ROLE = keccak256("MY_ROLE"); * ``` * * Roles can be used to represent a set of permissions. To restrict access to a * function call, use {hasRole}: * * ``` * function foo() public { * require(hasRole(MY_ROLE, msg.sender)); * ... * } * ``` * * Roles can be granted and revoked dynamically via the {grantRole} and * {revokeRole} functions. Each role has an associated admin role, and only * accounts that have a role's admin role can call {grantRole} and {revokeRole}. * * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means * that only accounts with this role will be able to grant or revoke other * roles. More complex role relationships can be created by using * {_setRoleAdmin}. * * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to * grant and revoke this role. Extra precautions should be taken to secure * accounts that have been granted it. */ abstract contract AccessControl is Context, IAccessControl, ERC165 { struct RoleData { mapping(address => bool) members; bytes32 adminRole; } mapping(bytes32 => RoleData) private _roles; bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00; /** * @dev Modifier that checks that an account has a specific role. Reverts * with a standardized message including the required role. * * The format of the revert reason is given by the following regular expression: * * /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/ * * _Available since v4.1._ */ modifier onlyRole(bytes32 role) { _checkRole(role); _; } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId); } /** * @dev Returns `true` if `account` has been granted `role`. */ function hasRole(bytes32 role, address account) public view virtual override returns (bool) { return _roles[role].members[account]; } /** * @dev Revert with a standard message if `_msgSender()` is missing `role`. * Overriding this function changes the behavior of the {onlyRole} modifier. * * Format of the revert message is described in {_checkRole}. * * _Available since v4.6._ */ function _checkRole(bytes32 role) internal view virtual { _checkRole(role, _msgSender()); } /** * @dev Revert with a standard message if `account` is missing `role`. * * The format of the revert reason is given by the following regular expression: * * /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/ */ function _checkRole(bytes32 role, address account) internal view virtual { if (!hasRole(role, account)) { revert( string( abi.encodePacked( "AccessControl: account ", Strings.toHexString(account), " is missing role ", Strings.toHexString(uint256(role), 32) ) ) ); } } /** * @dev Returns the admin role that controls `role`. See {grantRole} and * {revokeRole}. * * To change a role's admin, use {_setRoleAdmin}. */ function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) { return _roles[role].adminRole; } /** * @dev Grants `role` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. * * Requirements: * * - the caller must have ``role``'s admin role. * * May emit a {RoleGranted} event. */ function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) { _grantRole(role, account); } /** * @dev Revokes `role` from `account`. * * If `account` had been granted `role`, emits a {RoleRevoked} event. * * Requirements: * * - the caller must have ``role``'s admin role. * * May emit a {RoleRevoked} event. */ function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) { _revokeRole(role, account); } /** * @dev Revokes `role` from the calling account. * * Roles are often managed via {grantRole} and {revokeRole}: this function's * purpose is to provide a mechanism for accounts to lose their privileges * if they are compromised (such as when a trusted device is misplaced). * * If the calling account had been revoked `role`, emits a {RoleRevoked} * event. * * Requirements: * * - the caller must be `account`. * * May emit a {RoleRevoked} event. */ function renounceRole(bytes32 role, address account) public virtual override { require(account == _msgSender(), "AccessControl: can only renounce roles for self"); _revokeRole(role, account); } /** * @dev Grants `role` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. Note that unlike {grantRole}, this function doesn't perform any * checks on the calling account. * * May emit a {RoleGranted} event. * * [WARNING] * ==== * This function should only be called from the constructor when setting * up the initial roles for the system. * * Using this function in any other way is effectively circumventing the admin * system imposed by {AccessControl}. * ==== * * NOTE: This function is deprecated in favor of {_grantRole}. */ function _setupRole(bytes32 role, address account) internal virtual { _grantRole(role, account); } /** * @dev Sets `adminRole` as ``role``'s admin role. * * Emits a {RoleAdminChanged} event. */ function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual { bytes32 previousAdminRole = getRoleAdmin(role); _roles[role].adminRole = adminRole; emit RoleAdminChanged(role, previousAdminRole, adminRole); } /** * @dev Grants `role` to `account`. * * Internal function without access restriction. * * May emit a {RoleGranted} event. */ function _grantRole(bytes32 role, address account) internal virtual { if (!hasRole(role, account)) { _roles[role].members[account] = true; emit RoleGranted(role, account, _msgSender()); } } /** * @dev Revokes `role` from `account`. * * Internal function without access restriction. * * May emit a {RoleRevoked} event. */ function _revokeRole(bytes32 role, address account) internal virtual { if (hasRole(role, account)) { _roles[role].members[account] = false; emit RoleRevoked(role, account, _msgSender()); } } } // File @openzeppelin/contracts/utils/structs/[email protected] // OpenZeppelin Contracts (last updated v4.8.0) (utils/structs/EnumerableSet.sol) // This file was procedurally generated from scripts/generate/templates/EnumerableSet.js. pragma solidity ^0.8.0; /** * @dev Library for managing * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive * types. * * Sets have the following properties: * * - Elements are added, removed, and checked for existence in constant time * (O(1)). * - Elements are enumerated in O(n). No guarantees are made on the ordering. * * ``` * contract Example { * // Add the library methods * using EnumerableSet for EnumerableSet.AddressSet; * * // Declare a set state variable * EnumerableSet.AddressSet private mySet; * } * ``` * * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`) * and `uint256` (`UintSet`) are supported. * * [WARNING] * ==== * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure * unusable. * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info. * * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an * array of EnumerableSet. * ==== */ library EnumerableSet { // To implement this library for multiple types with as little code // repetition as possible, we write it in terms of a generic Set type with // bytes32 values. // The Set implementation uses private functions, and user-facing // implementations (such as AddressSet) are just wrappers around the // underlying Set. // This means that we can only create new EnumerableSets for types that fit // in bytes32. struct Set { // Storage of set values bytes32[] _values; // Position of the value in the `values` array, plus 1 because index 0 // means a value is not in the set. mapping(bytes32 => uint256) _indexes; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function _add(Set storage set, bytes32 value) private returns (bool) { if (!_contains(set, value)) { set._values.push(value); // The value is stored at length-1, but we add 1 to all indexes // and use 0 as a sentinel value set._indexes[value] = set._values.length; return true; } else { return false; } } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function _remove(Set storage set, bytes32 value) private returns (bool) { // We read and store the value's index to prevent multiple reads from the same storage slot uint256 valueIndex = set._indexes[value]; if (valueIndex != 0) { // Equivalent to contains(set, value) // To delete an element from the _values array in O(1), we swap the element to delete with the last one in // the array, and then remove the last element (sometimes called as 'swap and pop'). // This modifies the order of the array, as noted in {at}. uint256 toDeleteIndex = valueIndex - 1; uint256 lastIndex = set._values.length - 1; if (lastIndex != toDeleteIndex) { bytes32 lastValue = set._values[lastIndex]; // Move the last value to the index where the value to delete is set._values[toDeleteIndex] = lastValue; // Update the index for the moved value set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex } // Delete the slot where the moved value was stored set._values.pop(); // Delete the index for the deleted slot delete set._indexes[value]; return true; } else { return false; } } /** * @dev Returns true if the value is in the set. O(1). */ function _contains(Set storage set, bytes32 value) private view returns (bool) { return set._indexes[value] != 0; } /** * @dev Returns the number of values on the set. O(1). */ function _length(Set storage set) private view returns (uint256) { return set._values.length; } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function _at(Set storage set, uint256 index) private view returns (bytes32) { return set._values[index]; } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function _values(Set storage set) private view returns (bytes32[] memory) { return set._values; } // Bytes32Set struct Bytes32Set { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _add(set._inner, value); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _remove(set._inner, value); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) { return _contains(set._inner, value); } /** * @dev Returns the number of values in the set. O(1). */ function length(Bytes32Set storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) { return _at(set._inner, index); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(Bytes32Set storage set) internal view returns (bytes32[] memory) { bytes32[] memory store = _values(set._inner); bytes32[] memory result; /// @solidity memory-safe-assembly assembly { result := store } return result; } // AddressSet struct AddressSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(AddressSet storage set, address value) internal returns (bool) { return _add(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(AddressSet storage set, address value) internal returns (bool) { return _remove(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(AddressSet storage set, address value) internal view returns (bool) { return _contains(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Returns the number of values in the set. O(1). */ function length(AddressSet storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(AddressSet storage set, uint256 index) internal view returns (address) { return address(uint160(uint256(_at(set._inner, index)))); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(AddressSet storage set) internal view returns (address[] memory) { bytes32[] memory store = _values(set._inner); address[] memory result; /// @solidity memory-safe-assembly assembly { result := store } return result; } // UintSet struct UintSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(UintSet storage set, uint256 value) internal returns (bool) { return _add(set._inner, bytes32(value)); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(UintSet storage set, uint256 value) internal returns (bool) { return _remove(set._inner, bytes32(value)); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(UintSet storage set, uint256 value) internal view returns (bool) { return _contains(set._inner, bytes32(value)); } /** * @dev Returns the number of values in the set. O(1). */ function length(UintSet storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(UintSet storage set, uint256 index) internal view returns (uint256) { return uint256(_at(set._inner, index)); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(UintSet storage set) internal view returns (uint256[] memory) { bytes32[] memory store = _values(set._inner); uint256[] memory result; /// @solidity memory-safe-assembly assembly { result := store } return result; } } // File @openzeppelin/contracts/access/[email protected] // OpenZeppelin Contracts (last updated v4.5.0) (access/AccessControlEnumerable.sol) pragma solidity ^0.8.0; /** * @dev Extension of {AccessControl} that allows enumerating the members of each role. */ abstract contract AccessControlEnumerable is IAccessControlEnumerable, AccessControl { using EnumerableSet for EnumerableSet.AddressSet; mapping(bytes32 => EnumerableSet.AddressSet) private _roleMembers; /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IAccessControlEnumerable).interfaceId || super.supportsInterface(interfaceId); } /** * @dev Returns one of the accounts that have `role`. `index` must be a * value between 0 and {getRoleMemberCount}, non-inclusive. * * Role bearers are not sorted in any particular way, and their ordering may * change at any point. * * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure * you perform all queries on the same block. See the following * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post] * for more information. */ function getRoleMember(bytes32 role, uint256 index) public view virtual override returns (address) { return _roleMembers[role].at(index); } /** * @dev Returns the number of accounts that have `role`. Can be used * together with {getRoleMember} to enumerate all bearers of a role. */ function getRoleMemberCount(bytes32 role) public view virtual override returns (uint256) { return _roleMembers[role].length(); } /** * @dev Overload {_grantRole} to track enumerable memberships */ function _grantRole(bytes32 role, address account) internal virtual override { super._grantRole(role, account); _roleMembers[role].add(account); } /** * @dev Overload {_revokeRole} to track enumerable memberships */ function _revokeRole(bytes32 role, address account) internal virtual override { super._revokeRole(role, account); _roleMembers[role].remove(account); } } // File contracts/BaseToken.sol pragma solidity =0.8.14; /** * @notice An abstract token contract that provides core functionalities, that can be further extended. * @author iHux3 */ abstract contract BaseToken is ERC20Burnable, Ownable, AccessControlEnumerable { uint32 constant public HUNDRED_PERCENT = 1e6; address constant internal ETH = address(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE); uint32 constant internal MAX_TOTAL_FEE = 22e4; uint32 constant internal DEFAULT_MIN_BALANCE_PERCENTAGE = 1e2; bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE"); struct BaseParameters { string name; string symbol; IUniswapV2Router02 router; IERC20 pairToken; uint32[] feePercentages; address teamWallet; uint initSupply; } IUniswapV2Router02 public router; IERC20 public pairToken; IUniswapV2Pair public pair; uint32[] public feePercentages; // team, farm rewards address public teamWallet; address public farmAddress; uint32 public minBalancePercentage; mapping(address => bool) public isExcludedFromFees; bool internal _processingFee; bool internal _totalSupplyInitialized; event InitTotalSupply( uint totalSupply ); event ExcludeFromFees( address targetAddress, bool state ); event SetMinBalancePercentage( uint minBalancePercentage ); event SetTeamWallet( address teamWallet ); event SetFarmAddress( address farmAddress ); /** * @notice Initializes the BaseToken contract. * @param baseParameters The parameters to initialize the contract with. */ constructor( BaseParameters memory baseParameters ) ERC20(baseParameters.name, baseParameters.symbol) { router = baseParameters.router; pairToken = address(baseParameters.pairToken) == ETH ? IERC20(router.WETH()) : baseParameters.pairToken; pair = IUniswapV2Pair(IUniswapV2Factory( baseParameters.router.factory()).createPair(address(this), address(pairToken) )); feePercentages = baseParameters.feePercentages; require(feePercentages.length >= 2, "invalid fees length"); require( getTotalFeePercentage() <= MAX_TOTAL_FEE, "total fees greater than the max fee" ); require(baseParameters.teamWallet != address(0)); teamWallet = baseParameters.teamWallet; isExcludedFromFees[owner()] = true; isExcludedFromFees[address(this)] = true; isExcludedFromFees[address(0xdead)] = true; minBalancePercentage = DEFAULT_MIN_BALANCE_PERCENTAGE; _approve(address(this), address(router), 2 ** 256 - 1); _initTotalSupply(baseParameters.initSupply); _setupRole(DEFAULT_ADMIN_ROLE, _msgSender()); _setupRole(MINTER_ROLE, _msgSender()); } // ================ OWNER FUNCTIONS ================ // /** * @notice Transfers ownership of the contract to a new owner. * @dev Overrides parent function by swapping `isExcludedFromFees`. * * @param newOwner The address of the new owner. * * Requirements: * - The caller must be the current owner. * * Emits an {OwnershipTransferred} event. */ function transferOwnership( address newOwner ) public override onlyOwner { isExcludedFromFees[owner()] = false; super.transferOwnership(newOwner); isExcludedFromFees[newOwner] = true; } /** * @notice Allows the contract owner to exclude or include an address from fees on transfer. * * @param targetAddress The address to exclude or include. * @param state A boolean indicating whether the address should be excluded (true) or included (false). * * Requirements: * - The caller must be the contract owner. * * Emits an {ExcludeFromFees} event. */ function excludeFromFees( address targetAddress, bool state ) external onlyOwner { isExcludedFromFees[targetAddress] = state; emit ExcludeFromFees(targetAddress, state); } /** * @notice Sets the farm address that receives tx fees. * @param _farmAddress The farm address. */ function setFarmAddress(address _farmAddress) external onlyOwner { farmAddress = _farmAddress; isExcludedFromFees[_farmAddress] = true; emit SetFarmAddress(_farmAddress); } /** * @notice Allows to mint tokens if the sender has the minter role. * @param account The account to mint tokens for * @param amount Amount of tokens to mint */ function mint(address account, uint amount) external returns (bool) { require(hasRole(MINTER_ROLE, msg.sender), "E_M"); _mint(account, amount); return true; } // ================ TEAM WALLET FUNCTIONS ================ // /** * @notice Allows to change team wallet to set a new team wallet address. * @param newTeamWallet The address of the new team wallet */ function setTeamWallet( address newTeamWallet ) external { require(msg.sender == teamWallet, "E_M"); require(newTeamWallet != address(0), "zero address"); teamWallet = newTeamWallet; emit SetTeamWallet(newTeamWallet); } // ================ INTERNAL FUNCTIONS ================ // /** * @notice Transfers tokens from one address to another address. * @param from The address to transfer tokens from * @param to The address to transfer tokens to * @param amount The amount of tokens to transfer * * Requirements: * - from and to cannot be the zero address * - The from address must have a balance of at least amount * - The contract must have sufficient allowance from from to spend amount * * Emits a {Transfer} event. */ function _transfer( address from, address to, uint amount ) internal virtual override { (uint fee,) = _processFee(from, to, amount); amount -= fee; super._transfer(from, to, amount); } /** * @notice Processes the fees for the transaction and returns the total fee and a flag indicating if the fee was taken. * * @param from The address from which the tokens are transferred * @param to The address to which the tokens are transferred * @param amount The amount of tokens being transferred * * @return fee The total fee amount * @return tookFee A boolean indicating if the fee was taken * * Emits a {Transfer} event if any fee is transferred to another address. */ function _processFee( address from, address to, uint amount ) internal virtual returns ( uint fee, bool tookFee ) { if ( isExcludedFromFees[from] || isExcludedFromFees[to] || _processingFee ) { return (0, false); } _processingFee = true; uint teamAmount = _applyPercentage(amount, feePercentages[0]); if (teamAmount > 0 && teamWallet != address(0)) { fee += teamAmount; _transfer(from, address(this), teamAmount); } uint farmRewardAmount = _applyPercentage(amount, feePercentages[1]); if (farmRewardAmount > 0 && farmAddress != address(0)) { fee += farmRewardAmount; _transfer(from, farmAddress, farmRewardAmount); } uint minBalance = _applyPercentage(totalSupply(), minBalancePercentage); if ( balanceOf(address(this)) >= minBalance && from != address(pair) ) { _swapTokensForETH(); } _processingFee = false; return (fee, true); } /** * @notice Swaps accumulated team fee tokens for ETH tokens. */ function _swapTokensForETH() internal { uint swapAmount = balanceOf(address(this)); if (swapAmount == 0) return; address[] memory swapPath = new address[](2); swapPath[0] = address(this); swapPath[1] = router.WETH(); try router.swapExactTokensForETH( swapAmount, 0, swapPath, teamWallet, block.timestamp ) {} catch {} } /** * @notice Initializes total supply of the token. * @param initSupply The initial total supply. */ function _initTotalSupply(uint initSupply) internal virtual { require(!_totalSupplyInitialized, "initialized already"); require(initSupply > 0, "0 total supply"); _mint(owner(), initSupply); emit InitTotalSupply(initSupply); _totalSupplyInitialized = true; } // ================ VIEW FUNCTIONS ================ // /** * @notice Returns the total fee percentage applied to transactions. * @return totalFeePercentage The total fee percentage. */ function getTotalFeePercentage() public view returns ( uint totalFeePercentage ) { for (uint i; i < feePercentages.length; i++) { totalFeePercentage += feePercentages[i]; } } /** * @notice This function is used to calculate the result of applying a percentage to a given value. * * @param value The value to which the percentage will be applied. * @param percentage The percentage to apply to the value. * * @return The result of applying the percentage to the value. */ function _applyPercentage( uint value, uint percentage ) internal pure returns (uint) { return value * percentage / HUNDRED_PERCENT; } } // File contracts/DebaseProtect.sol pragma solidity =0.8.14; /** * @notice An abstract contract for `DebaseToken` which adds functions to protect tokens from debasing. * @author iHux3 */ abstract contract DebaseProtect { struct Depositor { uint amount; uint lockEndsAt; } uint public lockDuration; uint public totalDeposited; mapping(address => bool) public isExcludedFromDebase; mapping(address => Depositor) public depositors; event Deposit(address indexed depositor, uint amount); event Withdraw(address indexed depositor, uint amount); function _burn(address account, uint amount) internal virtual; function _mint(address account, uint amount) internal virtual; /** * @notice Allows users to deposit tokens and burn them in order to protect them from debasing. * * @param amount The amount of tokens to deposit and burn. * * @dev The deposited tokens are burned, reducing the total supply of tokens in circulation. * @dev The user's deposit amount is recorded, and the tokens are locked for a period of time, after which the user can withdraw them. * * Requirements: * - The amount must be greater than 0. * - The user must not be excluded from debase in order to make a deposit. * * @dev Emits a {Deposit} event with the user's address and deposit amount. */ function deposit(uint amount) external { require(amount > 0, "zero amount"); require(!isExcludedFromDebase[msg.sender], "excluded from debase"); Depositor storage depositor = depositors[msg.sender]; depositor.lockEndsAt = block.timestamp + lockDuration; _burn(msg.sender, amount); totalDeposited += amount; depositor.amount += amount; emit Deposit(msg.sender, amount); } /** * @notice Allows users to withdraw their protected deposited tokens by minting them. * * @param amount The amount of tokens to withdraw. * * Requirements: * - amount must be greater than 0. * - The depositor must have unlocked their deposit. * - The depositor must have enough deposited tokens. * * Emits a {Withdraw} event. */ function withdraw(uint amount) external { require(amount > 0, "zero amount"); Depositor storage depositor = depositors[msg.sender]; require(depositor.lockEndsAt <= block.timestamp, "locked"); require(depositor.amount >= amount, "not enough amount"); depositor.lockEndsAt = block.timestamp + lockDuration; depositor.amount -= amount; totalDeposited -= amount; _mint(address(msg.sender), amount); emit Withdraw(msg.sender, amount); } } // File contracts/DebaseToken.sol pragma solidity =0.8.14; /** * @dev `DebaseToken` extends `BaseToken` by adding decreasing (debasing) wallet balances. * @author iHux3 */ contract DebaseToken is BaseToken { uint64 public constant BASE = 1e18; struct Parameters { uint32 startTime; uint32 debasePeriod; uint64 debaseRate; } uint private _underlyingTotalSupply; uint private _totalSupplyExcluded; mapping(address => uint) private _balances; uint32 public startTime; uint32 public debasePeriod; uint64 public debaseRate; uint64 public debaseFactor; uint public lastDebaseTimestamp; mapping(address => bool) public isExcludedFromDebase; event ExcludeFromDebase( address addr, bool excluded ); event Debase( uint periodsPassed, uint debaseFactor ); modifier withDebase() { _; debase(); } /** * @notice Initializes the contract with the given parameters. * * @param baseParameters The base token parameters. * @param parameters The debase token parameters. */ constructor( BaseParameters memory baseParameters, Parameters memory parameters ) BaseToken(baseParameters) { require(parameters.startTime >= block.timestamp, "starts in past"); require(parameters.debasePeriod > 0, "debase period zero"); require(parameters.debaseRate > 0 && parameters.debaseRate < BASE / 2, "debase rate range"); startTime = parameters.startTime; debasePeriod = parameters.debasePeriod; debaseRate = parameters.debaseRate; lastDebaseTimestamp = startTime; debaseFactor = BASE; isExcludedFromDebase[address(this)] = true; isExcludedFromDebase[address(pair)] = true; } // ================ EXTERNAL FUNCTIONS ================ // /** * @notice This function debases the token based on the `debaseRate` and `debasePeriod`. * * @dev Decreases debaseFactor, resulting in a decrease of all wallets' non-underlying balances. * @dev If `debaseFactor` equals 1 or the current timestamp is less than `startTime`, this function will not execute. * @dev This function calculates the number of periods that have passed since the last time debase was called, * and updates debaseFactor accordingly. It limits the maximum number of periods to 1000. * * Emits a {Debase} event with the number of periods passed and the updated `debaseFactor`. */ function debase() public { uint currentTimestamp = block.timestamp; if (currentTimestamp < startTime || debaseFactor == 1) { return; } uint periodsPassed = (currentTimestamp - lastDebaseTimestamp) / debasePeriod; if (periodsPassed > 1000) { periodsPassed = 1000; } uint totalSupplyBefore = totalSupply(); if (periodsPassed > 0) { uint64 _debaseFactor = debaseFactor; uint64 _debaseRate = debaseRate; for (uint i = 0; i < periodsPassed; i++) { _debaseFactor = uint64(uint(_debaseFactor) * (BASE - _debaseRate) / BASE); } debaseFactor = _debaseFactor; lastDebaseTimestamp += periodsPassed * debasePeriod; if (debaseFactor == 0) debaseFactor = 1; emit Debase( periodsPassed, debaseFactor ); } uint totalSupplyAfter = totalSupply(); uint debasedTokens = totalSupplyBefore - totalSupplyAfter; if (debasedTokens > 1) { _mint(farmAddress, debasedTokens / 2); // mint 50% as rewards for stakers } } // ================ INTERNAL FUNCTIONS ================ // /** * @notice Transfer tokens from one address to another. * * @param from The address to transfer tokens from * @param to The address to transfer tokens to * @param amount The amount of tokens to be transferred * * @dev This function is internal and will only be called from within the contract. * It processes the transfer fees, converts the amount and fees to underlying, checks the balance of the from address, * updates the balances and total supply based on whether the addresses are excluded from debase or not. * * Emits a {Transfer} event. */ function _transfer( address from, address to, uint amount ) internal override withDebase { require(from != address(0), "ERC20: transfer from the zero address"); require(to != address(0), "ERC20: transfer to the zero address"); (uint fee, ) = _processFee(from, to, amount); uint underlyingAmount = convertToUnderlying(amount); uint underlyingFee = convertToUnderlying(fee); amount -= fee; underlyingAmount -= underlyingFee; uint fromBalance = _balances[from]; if (!isExcludedFromDebase[from]) { require( fromBalance >= underlyingAmount, "ERC20: transfer amount exceeds balance" ); _balances[from] -= underlyingAmount; } else { require( fromBalance >= amount, "ERC20: transfer amount exceeds balance" ); _balances[from] -= amount; _totalSupplyExcluded -= amount; _underlyingTotalSupply += underlyingAmount; } if (!isExcludedFromDebase[to]) { _balances[to] += underlyingAmount; } else { _balances[to] += amount; _totalSupplyExcluded += amount; _underlyingTotalSupply -= underlyingAmount; } emit Transfer(from, to, amount); } /** * @notice Destroys amount tokens from account, reducing the total supply of the token. * * @dev Decreases underlying balances (or non-underlying if the account is excluded from debase). * * @param account The address of the account to burn tokens from. * @param amount The amount of tokens to burn. * * Requirements: * - The account cannot be the zero address. * - The account must have at least amount tokens. * * Emits a {Transfer} event with to set to the zero address. */ function _burn(address account, uint amount) internal override withDebase { require(account != address(0), "ERC20: burn from the zero address"); uint underlyingAmount = convertToUnderlying(amount); uint accountBalance = _balances[account]; if (!isExcludedFromDebase[account]) { require(accountBalance >= underlyingAmount, "ERC20: burn amount exceeds balance"); _balances[account] -= underlyingAmount; _underlyingTotalSupply -= underlyingAmount; } else { require(accountBalance >= amount, "ERC20: burn amount exceeds balance"); _balances[account] -= amount; _totalSupplyExcluded -= amount; } emit Transfer(account, address(0), amount); } /** * @notice Mints new tokens to the specified account. * * @dev Increases the balance of account and the underlying total supply by underlyingAmount. * * @param account The account to receive the minted tokens. * @param amount The amount of tokens to mint. * * Requirements: * - The account cannot be the zero address. * - The account must not be excluded from debase. * * Emits a {Transfer} event with from address as the zero address and to address as the account address. */ function _mint(address account, uint amount) internal override withDebase { require(account != address(0), "ERC20: burn from the zero address"); uint underlyingAmount = convertToUnderlying(amount); if (!isExcludedFromDebase[account]) { _balances[account] += underlyingAmount; _underlyingTotalSupply += underlyingAmount; } else { _balances[account] += amount; _totalSupplyExcluded += amount; } emit Transfer(address(0), account, amount); } /** * @notice Initializes total supply of the token. * @param initSupply The initial total supply. */ function _initTotalSupply( uint initSupply ) internal override { require(!_totalSupplyInitialized, "initialized already"); require(initSupply > 0, "0 total supply"); _underlyingTotalSupply = initSupply; _balances[owner()] = _underlyingTotalSupply; emit Transfer(address(0), owner(), initSupply); emit InitTotalSupply(initSupply); _totalSupplyInitialized = true; } // ================ VIEW FUNCTIONS ================ // /** * @notice Converts given amount of tokens to underlying asset units. * @param amount Amount of tokens to convert. * @return The equivalent amount of underlying asset units. */ function convertToUnderlying(uint amount) public view returns (uint) { return amount * BASE / debaseFactor; } /** * @notice Converts a given amount of underlying token to its corresponding amount of token based on the current debase factor. * @param underlyingAmount The amount of underlying token to convert to token. * @return The corresponding amount of token based on the current debase factor. */ function convertFromUnderlying(uint underlyingAmount) public view returns (uint) { return underlyingAmount * debaseFactor / BASE; } /** * @notice Get the balance of an address. * * @dev If the address is excluded from debase, their balance is stored directly in the _balances mapping. * Otherwise, the balance is converted from underlying units to token units using the current debase factor. * * @param account The address to get the balance for. * * @return The balance of the address. */ function balanceOf( address account ) public view override returns (uint) { if (isExcludedFromDebase[account]) { return _balances[account]; } return convertFromUnderlying(_balances[account]); } /** * @notice Gets the token total supply. * @dev Gets total supply by converting underlying total supply and adding debase-excluded total supply. * @return The token total supply. */ function totalSupply() public view override returns (uint) { return convertFromUnderlying(_underlyingTotalSupply) + _totalSupplyExcluded; } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"components":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"contract IUniswapV2Router02","name":"router","type":"address"},{"internalType":"contract IERC20","name":"pairToken","type":"address"},{"internalType":"uint32[]","name":"feePercentages","type":"uint32[]"},{"internalType":"address","name":"teamWallet","type":"address"},{"internalType":"uint256","name":"initSupply","type":"uint256"}],"internalType":"struct BaseToken.BaseParameters","name":"baseParameters","type":"tuple"},{"components":[{"internalType":"uint32","name":"startTime","type":"uint32"},{"internalType":"uint32","name":"debasePeriod","type":"uint32"},{"internalType":"uint64","name":"debaseRate","type":"uint64"}],"internalType":"struct DebaseToken.Parameters","name":"parameters","type":"tuple"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"periodsPassed","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"debaseFactor","type":"uint256"}],"name":"Debase","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"addr","type":"address"},{"indexed":false,"internalType":"bool","name":"excluded","type":"bool"}],"name":"ExcludeFromDebase","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"targetAddress","type":"address"},{"indexed":false,"internalType":"bool","name":"state","type":"bool"}],"name":"ExcludeFromFees","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"totalSupply","type":"uint256"}],"name":"InitTotalSupply","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"farmAddress","type":"address"}],"name":"SetFarmAddress","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"minBalancePercentage","type":"uint256"}],"name":"SetMinBalancePercentage","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"teamWallet","type":"address"}],"name":"SetTeamWallet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"BASE","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"HUNDRED_PERCENT","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MINTER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burnFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"underlyingAmount","type":"uint256"}],"name":"convertFromUnderlying","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"convertToUnderlying","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"debase","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"debaseFactor","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"debasePeriod","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"debaseRate","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"targetAddress","type":"address"},{"internalType":"bool","name":"state","type":"bool"}],"name":"excludeFromFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"farmAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"feePercentages","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getRoleMember","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleMemberCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTotalFeePercentage","outputs":[{"internalType":"uint256","name":"totalFeePercentage","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isExcludedFromDebase","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isExcludedFromFees","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastDebaseTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minBalancePercentage","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pair","outputs":[{"internalType":"contract IUniswapV2Pair","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pairToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"router","outputs":[{"internalType":"contract IUniswapV2Router02","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_farmAddress","type":"address"}],"name":"setFarmAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newTeamWallet","type":"address"}],"name":"setTeamWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startTime","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"teamWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","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)
000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000652fd6d00000000000000000000000000000000000000000000000000000000000000e100000000000000000000000000000000000000000000000000005420d5a44800000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000001200000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d000000000000000000000000eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee00000000000000000000000000000000000000000000000000000000000001600000000000000000000000004c6f8a9d1342635932498a7e14cfd114887944f200000000000000000000000000000000000000000052b7d2dcc80cd2e4000000000000000000000000000000000000000000000000000000000000000000000b506f7461746f204661726d0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006504f5441544f000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000004e200000000000000000000000000000000000000000000000000000000000002710
-----Decoded View---------------
Arg [0] : baseParameters (tuple): System.Collections.Generic.List`1[Nethereum.ABI.FunctionEncoding.ParameterOutput]
Arg [1] : parameters (tuple): System.Collections.Generic.List`1[Nethereum.ABI.FunctionEncoding.ParameterOutput]
-----Encoded View---------------
18 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [1] : 00000000000000000000000000000000000000000000000000000000652fd6d0
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000e10
Arg [3] : 0000000000000000000000000000000000000000000000000005420d5a448000
Arg [4] : 00000000000000000000000000000000000000000000000000000000000000e0
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000120
Arg [6] : 0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d
Arg [7] : 000000000000000000000000eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee
Arg [8] : 0000000000000000000000000000000000000000000000000000000000000160
Arg [9] : 0000000000000000000000004c6f8a9d1342635932498a7e14cfd114887944f2
Arg [10] : 00000000000000000000000000000000000000000052b7d2dcc80cd2e4000000
Arg [11] : 000000000000000000000000000000000000000000000000000000000000000b
Arg [12] : 506f7461746f204661726d000000000000000000000000000000000000000000
Arg [13] : 0000000000000000000000000000000000000000000000000000000000000006
Arg [14] : 504f5441544f0000000000000000000000000000000000000000000000000000
Arg [15] : 0000000000000000000000000000000000000000000000000000000000000002
Arg [16] : 0000000000000000000000000000000000000000000000000000000000004e20
Arg [17] : 0000000000000000000000000000000000000000000000000000000000002710
Deployed Bytecode Sourcemap
89264:10886:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;74160:214;;;;;;:::i;:::-;;:::i;:::-;;;470:14:1;;463:22;445:41;;433:2;418:18;74160:214:0;;;;;;;;85489:224;;;:::i;:::-;;;643:25:1;;;631:2;616:18;85489:224:0;497:177:1;18084:100:0;;;:::i;:::-;;;;;;;:::i;20435:201::-;;;;;;:::i;:::-;;:::i;76961:30::-;;;;;;:::i;:::-;;:::i;:::-;;;2145:10:1;2133:23;;;2115:42;;2103:2;2088:18;76961:30:0;1971:192:1;81343:274:0;;;;;;:::i;:::-;;:::i;:::-;;99994:153;;;:::i;89703:26::-;;;;;-1:-1:-1;;;89703:26:0;;-1:-1:-1;;;;;89703:26:0;;;;;;-1:-1:-1;;;;;2582:31:1;;;2564:50;;2552:2;2537:18;89703:26:0;2420:200:1;98493:123:0;;;;;;:::i;:::-;;:::i;21216:295::-;;;;;;:::i;:::-;;:::i;56352:131::-;;;;;;:::i;:::-;56426:7;56453:12;;;:6;:12;;;;;:22;;;;56352:131;89672:24;;;;;-1:-1:-1;;;89672:24:0;;-1:-1:-1;;;;;89672:24:0;;;56793:147;;;;;;:::i;:::-;;:::i;19046:93::-;;;19129:2;3915:36:1;;3903:2;3888:18;19046:93:0;3773:184:1;57937:218:0;;;;;;:::i;:::-;;:::i;21920:238::-;;;;;;:::i;:::-;;:::i;76898:23::-;;;;;-1:-1:-1;;;;;76898:23:0;;;;;;-1:-1:-1;;;;;4140:32:1;;;4122:51;;4110:2;4095:18;76898:23:0;3962:217:1;80914:191:0;;;;;;:::i;:::-;;:::i;29861:91::-;;;;;;:::i;:::-;;:::i;77134:50::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;89737:31;;;;;;77020:25;;;;;-1:-1:-1;;;;;77020:25:0;;;91730:1254;;;:::i;76281:44::-;;76322:3;76281:44;;98945:145;;;;;;:::i;:::-;;:::i;99519:254::-;;;;;;:::i;:::-;;:::i;89777:52::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;11489:103;;;:::i;89609:23::-;;;;;;;;;30271:164;;;;;;:::i;:::-;;:::i;10841:87::-;10914:6;;-1:-1:-1;;;;;10914:6:0;10841:87;;74973:153;;;;;;:::i;:::-;;:::i;54825:147::-;;;;;;:::i;:::-;;:::i;18303:104::-;;;:::i;53930:49::-;;53975:4;53930:49;;22661:436;;;;;;:::i;:::-;;:::i;76928:26::-;;;;;-1:-1:-1;;;;;76928:26:0;;;19708:193;;;;;;:::i;:::-;;:::i;80159:218::-;;;;;;:::i;:::-;;:::i;77091:34::-;;;;;-1:-1:-1;;;77091:34:0;;;;;;75300:142;;;;;;:::i;:::-;;:::i;76548:62::-;;76586:24;76548:62;;57233:149;;;;;;:::i;:::-;;:::i;80510:204::-;;;;;;:::i;:::-;;:::i;19964:151::-;;;;;;:::i;:::-;;:::i;89314:34::-;;89344:4;89314:34;;79491:231;;;;;;:::i;:::-;;:::i;76859:32::-;;;;;-1:-1:-1;;;;;76859:32:0;;;77052:26;;;;;-1:-1:-1;;;;;77052:26:0;;;89639;;;;;;;;;;;;74160:214;74245:4;-1:-1:-1;;;;;;74269:57:0;;-1:-1:-1;;;74269:57:0;;:97;;;74330:36;74354:11;74330:23;:36::i;:::-;74262:104;74160:214;-1:-1:-1;;74160:214:0:o;85489:224::-;85553:23;85600:6;85595:111;85612:14;:21;85608:25;;85595:111;;;85677:14;85692:1;85677:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;85655:39;;85677:17;;;;;;;;;;85655:39;;:::i;:::-;;-1:-1:-1;85635:3:0;;;;:::i;:::-;;;;85595:111;;;;85489:224;:::o;18084:100::-;18138:13;18171:5;18164:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18084:100;:::o;20435:201::-;20518:4;9466:10;20574:32;9466:10;20590:7;20599:6;20574:8;:32::i;:::-;-1:-1:-1;20624:4:0;;20435:201;-1:-1:-1;;;20435:201:0:o;76961:30::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;81343:274::-;81447:10;;-1:-1:-1;;;;;81447:10:0;81433;:24;81425:40;;;;-1:-1:-1;;;81425:40:0;;7047:2:1;81425:40:0;;;7029:21:1;7086:1;7066:18;;;7059:29;-1:-1:-1;;;7104:18:1;;;7097:33;7147:18;;81425:40:0;;;;;;;;;-1:-1:-1;;;;;81484:27:0;;81476:52;;;;-1:-1:-1;;;81476:52:0;;7378:2:1;81476:52:0;;;7360:21:1;7417:2;7397:18;;;7390:30;-1:-1:-1;;;7436:18:1;;;7429:42;7488:18;;81476:52:0;7176:336:1;81476:52:0;81539:10;:26;;-1:-1:-1;;;;;;81539:26:0;-1:-1:-1;;;;;81539:26:0;;;;;;;;81581:28;;4122:51:1;;;81581:28:0;;4110:2:1;4095:18;81581:28:0;;;;;;;;81343:274;:::o;99994:153::-;100047:4;100119:20;;100071:45;100093:22;;100071:21;:45::i;:::-;:68;;;;:::i;:::-;100064:75;;99994:153;:::o;98493:123::-;98596:12;;98556:4;;-1:-1:-1;;;98596:12:0;;-1:-1:-1;;;;;98596:12:0;98580:13;89344:4;98580:6;:13;:::i;:::-;:28;;;;:::i;21216:295::-;21347:4;9466:10;21405:38;21421:4;9466:10;21436:6;21405:15;:38::i;:::-;21454:27;21464:4;21470:2;21474:6;21454:9;:27::i;:::-;-1:-1:-1;21499:4:0;;21216:295;-1:-1:-1;;;;21216:295:0:o;56793:147::-;56426:7;56453:12;;;:6;:12;;;;;:22;;;54421:16;54432:4;54421:10;:16::i;:::-;56907:25:::1;56918:4;56924:7;56907:10;:25::i;:::-;56793:147:::0;;;:::o;57937:218::-;-1:-1:-1;;;;;58033:23:0;;9466:10;58033:23;58025:83;;;;-1:-1:-1;;;58025:83:0;;8114:2:1;58025:83:0;;;8096:21:1;8153:2;8133:18;;;8126:30;8192:34;8172:18;;;8165:62;-1:-1:-1;;;8243:18:1;;;8236:45;8298:19;;58025:83:0;7912:411:1;58025:83:0;58121:26;58133:4;58139:7;58121:11;:26::i;:::-;57937:218;;:::o;21920:238::-;22008:4;9466:10;22064:64;9466:10;22080:7;22117:10;22089:25;9466:10;22080:7;22089:9;:25::i;:::-;:38;;;;:::i;:::-;22064:8;:64::i;80914:191::-;80976:4;81001:32;76586:24;81022:10;81001:7;:32::i;:::-;80993:48;;;;-1:-1:-1;;;80993:48:0;;7047:2:1;80993:48:0;;;7029:21:1;7086:1;7066:18;;;7059:29;-1:-1:-1;;;7104:18:1;;;7097:33;7147:18;;80993:48:0;6845:326:1;80993:48:0;81053:22;81059:7;81068:6;81053:5;:22::i;:::-;-1:-1:-1;81093:4:0;80914:191;;;;:::o;29861:91::-;29917:27;9466:10;29937:6;29917:5;:27::i;:::-;29861:91;:::o;91730:1254::-;91839:9;;91790:15;;91839:9;;91820:28;;;:49;;-1:-1:-1;91852:12:0;;-1:-1:-1;;;91852:12:0;;-1:-1:-1;;;;;91852:12:0;91868:1;91852:17;91820:49;91816:88;;;91886:7;91730:1254::o;91816:88::-;91980:12;;91957:19;;91916:18;;91980:12;;;;;;91938:38;;:16;:38;:::i;:::-;91937:55;;;;:::i;:::-;91916:76;;92023:4;92007:13;:20;92003:73;;;-1:-1:-1;92060:4:0;92003:73;92088:22;92113:13;:11;:13::i;:::-;92088:38;-1:-1:-1;92143:17:0;;92139:581;;92200:12;;-1:-1:-1;;;;;;;;92200:12:0;;;;;-1:-1:-1;;;92248:10:0;;;92177:20;92275:149;92296:13;92292:1;:17;92275:149;;;89344:4;92381:18;92388:11;89344:4;92381:18;:::i;:::-;-1:-1:-1;;;;;92358:42:0;92363:13;-1:-1:-1;;;;;92358:19:0;:42;;;;:::i;:::-;:49;;;;:::i;:::-;92335:73;-1:-1:-1;92311:3:0;;;;:::i;:::-;;;;92275:149;;;-1:-1:-1;92440:12:0;:28;;-1:-1:-1;;;;92440:28:0;-1:-1:-1;;;;;;;;92440:28:0;;;;;;;;92506;;92522:12;;;;;92506:13;:28;:::i;:::-;92483:19;;:51;;;;;;;:::i;:::-;;;;-1:-1:-1;;92567:12:0;;-1:-1:-1;;;92567:12:0;;-1:-1:-1;;;;;92567:12:0;92583:1;92567:17;92563:39;;92586:12;:16;;-1:-1:-1;;;;92586:16:0;-1:-1:-1;;;92586:16:0;;;92563:39;92681:12;;92624:84;;;8865:25:1;;;-1:-1:-1;;;92681:12:0;;;-1:-1:-1;;;;;92681:12:0;8921:2:1;8906:18;;8899:59;92624:84:0;;8838:18:1;92624:84:0;;;;;;;92162:558;;92139:581;92732:21;92756:13;:11;:13::i;:::-;92732:37;-1:-1:-1;92782:18:0;92803:36;92732:37;92803:17;:36;:::i;:::-;92782:57;;92872:1;92856:13;:17;92852:122;;;92896:11;;92890:37;;-1:-1:-1;;;;;92896:11:0;92909:17;92925:1;92909:13;:17;:::i;:::-;92890:5;:37::i;:::-;91755:1229;;;;;91730:1254::o;98945:145::-;99063:12;;99020:4;;89344;;99044:31;;-1:-1:-1;;;99063:12:0;;-1:-1:-1;;;;;99063:12:0;99044:16;:31;:::i;99519:254::-;-1:-1:-1;;;;;99622:29:0;;99601:4;99622:29;;;:20;:29;;;;;;;;99618:87;;;-1:-1:-1;;;;;;99675:18:0;;;;;:9;:18;;;;;;;99519:254::o;99618:87::-;-1:-1:-1;;;;;99746:18:0;;;;;;:9;:18;;;;;;99724:41;;:21;:41::i;11489:103::-;10727:13;:11;:13::i;:::-;11554:30:::1;11581:1;11554:18;:30::i;:::-;11489:103::o:0;30271:164::-;30348:46;30364:7;9466:10;30387:6;30348:15;:46::i;:::-;30405:22;30411:7;30420:6;30405:5;:22::i;74973:153::-;75063:7;75090:18;;;:12;:18;;;;;:28;;75112:5;75090:21;:28::i;:::-;75083:35;74973:153;-1:-1:-1;;;74973:153:0:o;54825:147::-;54911:4;54935:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;54935:29:0;;;;;;;;;;;;;;;54825:147::o;18303:104::-;18359:13;18392:7;18385:14;;;;;:::i;22661:436::-;22754:4;9466:10;22754:4;22837:25;9466:10;22854:7;22837:9;:25::i;:::-;22810:52;;22901:15;22881:16;:35;;22873:85;;;;-1:-1:-1;;;22873:85:0;;9171:2:1;22873:85:0;;;9153:21:1;9210:2;9190:18;;;9183:30;9249:34;9229:18;;;9222:62;-1:-1:-1;;;9300:18:1;;;9293:35;9345:19;;22873:85:0;8969:401:1;22873:85:0;22994:60;23003:5;23010:7;23038:15;23019:16;:34;22994:8;:60::i;19708:193::-;19787:4;9466:10;19843:28;9466:10;19860:2;19864:6;19843:9;:28::i;80159:218::-;10727:13;:11;:13::i;:::-;-1:-1:-1;;;;;80275:33:0;::::1;;::::0;;;:18:::1;:33;::::0;;;;;;;;:41;;-1:-1:-1;;80275:41:0::1;::::0;::::1;;::::0;;::::1;::::0;;;80332:37;;9543:51:1;;;9610:18;;;9603:50;80332:37:0::1;::::0;9516:18:1;80332:37:0::1;;;;;;;80159:218:::0;;:::o;75300:142::-;75380:7;75407:18;;;:12;:18;;;;;:27;;:25;:27::i;57233:149::-;56426:7;56453:12;;;:6;:12;;;;;:22;;;54421:16;54432:4;54421:10;:16::i;:::-;57348:26:::1;57360:4;57366:7;57348:11;:26::i;80510:204::-:0;10727:13;:11;:13::i;:::-;80586:11:::1;:26:::0;;-1:-1:-1;;;;;;80586:26:0::1;-1:-1:-1::0;;;;;80586:26:0;::::1;::::0;;::::1;::::0;;;-1:-1:-1;80623:32:0;;;:18:::1;:32;::::0;;;;;;;;:39;;-1:-1:-1;;80623:39:0::1;-1:-1:-1::0;80623:39:0::1;::::0;;80678:28;;4122:51:1;;;80678:28:0::1;::::0;4095:18:1;80678:28:0::1;3962:217:1::0;19964:151:0;-1:-1:-1;;;;;20080:18:0;;;20053:7;20080:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;19964:151::o;79491:231::-;10727:13;:11;:13::i;:::-;79619:5:::1;79589:18;:27;79608:7;10914:6:::0;;-1:-1:-1;;;;;10914:6:0;;10841:87;79608:7:::1;-1:-1:-1::0;;;;;79589:27:0::1;::::0;;::::1;::::0;::::1;::::0;;;;;;-1:-1:-1;79589:27:0;:35;;-1:-1:-1;;79589:35:0::1;::::0;::::1;;::::0;;;::::1;::::0;;79635:33:::1;79659:8:::0;79635:23:::1;:33::i;:::-;-1:-1:-1::0;;;;;79679:28:0::1;;::::0;;;:18:::1;:28;::::0;;;;:35;;-1:-1:-1;;79679:35:0::1;79710:4;79679:35;::::0;;79491:231::o;59534:238::-;59618:22;59626:4;59632:7;59618;:22::i;:::-;59613:152;;59657:12;;;;:6;:12;;;;;;;;-1:-1:-1;;;;;59657:29:0;;;;;;;;;:36;;-1:-1:-1;;59657:36:0;59689:4;59657:36;;;59740:12;9466:10;;9386:98;59740:12;-1:-1:-1;;;;;59713:40:0;59731:7;-1:-1:-1;;;;;59713:40:0;59725:4;59713:40;;;;;;;;;;59534:238;;:::o;68782:152::-;68852:4;68876:50;68881:3;-1:-1:-1;;;;;68901:23:0;;68876:4;:50::i;54529:204::-;54614:4;-1:-1:-1;;;;;;54638:47:0;;-1:-1:-1;;;54638:47:0;;:87;;-1:-1:-1;;;;;;;;;;51891:40:0;;;54689:36;51782:157;26688:380;-1:-1:-1;;;;;26824:19:0;;26816:68;;;;-1:-1:-1;;;26816:68:0;;9866:2:1;26816:68:0;;;9848:21:1;9905:2;9885:18;;;9878:30;9944:34;9924:18;;;9917:62;-1:-1:-1;;;9995:18:1;;;9988:34;10039:19;;26816:68:0;9664:400:1;26816:68:0;-1:-1:-1;;;;;26903:21:0;;26895:68;;;;-1:-1:-1;;;26895:68:0;;10271:2:1;26895:68:0;;;10253:21:1;10310:2;10290:18;;;10283:30;10349:34;10329:18;;;10322:62;-1:-1:-1;;;10400:18:1;;;10393:32;10442:19;;26895:68:0;10069:398:1;26895:68:0;-1:-1:-1;;;;;26976:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;27028:32;;643:25:1;;;27028:32:0;;616:18:1;27028:32:0;;;;;;;26688:380;;;:::o;27359:453::-;27494:24;27521:25;27531:5;27538:7;27521:9;:25::i;:::-;27494:52;;-1:-1:-1;;27561:16:0;:37;27557:248;;27643:6;27623:16;:26;;27615:68;;;;-1:-1:-1;;;27615:68:0;;10674:2:1;27615:68:0;;;10656:21:1;10713:2;10693:18;;;10686:30;10752:31;10732:18;;;10725:59;10801:18;;27615:68:0;10472:353:1;27615:68:0;27727:51;27736:5;27743:7;27771:6;27752:16;:25;27727:8;:51::i;:::-;27483:329;27359:453;;;:::o;93690:1433::-;-1:-1:-1;;;;;93832:18:0;::::1;93824:68;;;::::0;-1:-1:-1;;;93824:68:0;;11032:2:1;93824:68:0::1;::::0;::::1;11014:21:1::0;11071:2;11051:18;;;11044:30;11110:34;11090:18;;;11083:62;-1:-1:-1;;;11161:18:1;;;11154:35;11206:19;;93824:68:0::1;10830:401:1::0;93824:68:0::1;-1:-1:-1::0;;;;;93911:16:0;::::1;93903:64;;;::::0;-1:-1:-1;;;93903:64:0;;11438:2:1;93903:64:0::1;::::0;::::1;11420:21:1::0;11477:2;11457:18;;;11450:30;11516:34;11496:18;;;11489:62;-1:-1:-1;;;11567:18:1;;;11560:33;11610:19;;93903:64:0::1;11236:399:1::0;93903:64:0::1;93981:8;93995:29;94007:4;94013:2;94017:6;93995:11;:29::i;:::-;93980:44;;;94037:21;94061:27;94081:6;94061:19;:27::i;:::-;94037:51;;94099:18;94120:24;94140:3;94120:19;:24::i;:::-;94099:45:::0;-1:-1:-1;94157:13:0::1;94167:3:::0;94157:13;::::1;:::i;:::-;::::0;-1:-1:-1;94181:33:0::1;94201:13:::0;94181:33;::::1;:::i;:::-;-1:-1:-1::0;;;;;94246:15:0;::::1;94227:16;94246:15:::0;;;:9:::1;:15;::::0;;;;;;;;94277:20:::1;:26:::0;;;;;;;94181:33;;-1:-1:-1;94246:15:0;94277:26:::1;;94272:539;;94361:16;94346:11;:31;;94320:132;;;;-1:-1:-1::0;;;94320:132:0::1;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;94467:15:0;::::1;;::::0;;;:9:::1;:15;::::0;;;;:35;;94486:16;;94467:15;:35:::1;::::0;94486:16;;94467:35:::1;:::i;:::-;::::0;;;-1:-1:-1;94272:539:0::1;::::0;-1:-1:-1;94272:539:0::1;;94576:6;94561:11;:21;;94535:122;;;;-1:-1:-1::0;;;94535:122:0::1;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;94672:15:0;::::1;;::::0;;;:9:::1;:15;::::0;;;;:25;;94691:6;;94672:15;:25:::1;::::0;94691:6;;94672:25:::1;:::i;:::-;;;;;;;;94736:6;94712:20;;:30;;;;;;;:::i;:::-;;;;;;;;94783:16;94757:22;;:42;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;94272:539:0::1;-1:-1:-1::0;;;;;94828:24:0;::::1;;::::0;;;:20:::1;:24;::::0;;;;;::::1;;94823:249;;-1:-1:-1::0;;;;;94869:13:0;::::1;;::::0;;;:9:::1;:13;::::0;;;;:33;;94886:16;;94869:13;:33:::1;::::0;94886:16;;94869:33:::1;:::i;:::-;::::0;;;-1:-1:-1;94823:249:0::1;::::0;-1:-1:-1;94823:249:0::1;;-1:-1:-1::0;;;;;94935:13:0;::::1;;::::0;;;:9:::1;:13;::::0;;;;:23;;94952:6;;94935:13;:23:::1;::::0;94952:6;;94935:23:::1;:::i;:::-;;;;;;;;94997:6;94973:20;;:30;;;;;;;:::i;:::-;;;;;;;;95044:16;95018:22;;:42;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;94823:249:0::1;95104:2;-1:-1:-1::0;;;;;95089:26:0::1;95098:4;-1:-1:-1::0;;;;;95089:26:0::1;;95108:6;95089:26;;;;643:25:1::0;;631:2;616:18;;497:177;95089:26:0::1;;;;;;;;93813:1310;;;;90055:8:::0;:6;:8::i;55276:105::-;55343:30;55354:4;9466:10;55343;:30::i;75535:169::-;75623:31;75640:4;75646:7;75623:16;:31::i;:::-;75665:18;;;;:12;:18;;;;;:31;;75688:7;75665:22;:31::i;75798:174::-;75887:32;75905:4;75911:7;75887:17;:32::i;:::-;75930:18;;;;:12;:18;;;;;:34;;75956:7;75930:25;:34::i;97062:555::-;-1:-1:-1;;;;;97155:21:0;::::1;97147:67;;;;-1:-1:-1::0;;;97147:67:0::1;;;;;;;:::i;:::-;97227:21;97251:27;97271:6;97251:19;:27::i;:::-;-1:-1:-1::0;;;;;97296:29:0;::::1;;::::0;;;:20:::1;:29;::::0;;;;;97227:51;;-1:-1:-1;97296:29:0::1;;97291:264;;-1:-1:-1::0;;;;;97342:18:0;::::1;;::::0;;;:9:::1;:18;::::0;;;;:38;;97364:16;;97342:18;:38:::1;::::0;97364:16;;97342:38:::1;:::i;:::-;;;;;;;;97421:16;97395:22;;:42;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;97291:264:0::1;::::0;-1:-1:-1;97291:264:0::1;;-1:-1:-1::0;;;;;97470:18:0;::::1;;::::0;;;:9:::1;:18;::::0;;;;:28;;97492:6;;97470:18;:28:::1;::::0;97492:6;;97470:28:::1;:::i;:::-;;;;;;;;97537:6;97513:20;;:30;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;97291:264:0::1;97572:37;::::0;643:25:1;;;-1:-1:-1;;;;;97572:37:0;::::1;::::0;97589:1:::1;::::0;97572:37:::1;::::0;631:2:1;616:18;97572:37:0::1;;;;;;;97136:481;90055:8:::0;:6;:8::i;95698:788::-;-1:-1:-1;;;;;95791:21:0;::::1;95783:67;;;;-1:-1:-1::0;;;95783:67:0::1;;;;;;;:::i;:::-;95863:21;95887:27;95907:6;95887:19;:27::i;:::-;-1:-1:-1::0;;;;;95947:18:0;::::1;95925:19;95947:18:::0;;;:9:::1;:18;::::0;;;;;;;;95983:20:::1;:29:::0;;;;;;;95863:51;;-1:-1:-1;95947:18:0;95983:29:::1;;95978:446;;96055:16;96037:14;:34;;96029:81;;;;-1:-1:-1::0;;;96029:81:0::1;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;96125:18:0;::::1;;::::0;;;:9:::1;:18;::::0;;;;:38;;96147:16;;96125:18;:38:::1;::::0;96147:16;;96125:38:::1;:::i;:::-;;;;;;;;96204:16;96178:22;;:42;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;95978:446:0::1;::::0;-1:-1:-1;95978:446:0::1;;96279:6;96261:14;:24;;96253:71;;;;-1:-1:-1::0;;;96253:71:0::1;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;96339:18:0;::::1;;::::0;;;:9:::1;:18;::::0;;;;:28;;96361:6;;96339:18;:28:::1;::::0;96361:6;;96339:28:::1;:::i;:::-;;;;;;;;96406:6;96382:20;;:30;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;95978:446:0::1;96441:37;::::0;643:25:1;;;96467:1:0::1;::::0;-1:-1:-1;;;;;96441:37:0;::::1;::::0;::::1;::::0;631:2:1;616:18;96441:37:0::1;;;;;;;95772:714;;90055:8:::0;:6;:8::i;11006:132::-;10914:6;;-1:-1:-1;;;;;10914:6:0;9466:10;11070:23;11062:68;;;;-1:-1:-1;;;11062:68:0;;13054:2:1;11062:68:0;;;13036:21:1;;;13073:18;;;13066:30;13132:34;13112:18;;;13105:62;13184:18;;11062:68:0;12852:356:1;12108:191:0;12201:6;;;-1:-1:-1;;;;;12218:17:0;;;-1:-1:-1;;;;;;12218:17:0;;;;;;;12251:40;;12201:6;;;12218:17;12201:6;;12251:40;;12182:16;;12251:40;12171:128;12108:191;:::o;70078:158::-;70152:7;70203:22;70207:3;70219:5;70203:3;:22::i;69607:117::-;69670:7;69697:19;69705:3;64907:18;;64824:109;11747:201;10727:13;:11;:13::i;:::-;-1:-1:-1;;;;;11836:22:0;::::1;11828:73;;;::::0;-1:-1:-1;;;11828:73:0;;13415:2:1;11828:73:0::1;::::0;::::1;13397:21:1::0;13454:2;13434:18;;;13427:30;13493:34;13473:18;;;13466:62;-1:-1:-1;;;13544:18:1;;;13537:36;13590:19;;11828:73:0::1;13213:402:1::0;11828:73:0::1;11912:28;11931:8;11912:18;:28::i;62513:414::-:0;62576:4;64706:19;;;:12;;;:19;;;;;;62593:327;;-1:-1:-1;62636:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;62819:18;;62797:19;;;:12;;;:19;;;;;;:40;;;;62852:11;;62593:327;-1:-1:-1;62903:5:0;62896:12;;83023:1203;-1:-1:-1;;;;;83224:24:0;;83155:8;83224:24;;;:18;:24;;;;;;83155:8;;83224:24;;;:64;;-1:-1:-1;;;;;;83266:22:0;;;;;;:18;:22;;;;;;;;83224:64;:96;;;-1:-1:-1;83306:14:0;;;;83224:96;83206:170;;;-1:-1:-1;83355:1:0;;-1:-1:-1;83355:1:0;83347:17;;83206:170;83388:14;:21;;-1:-1:-1;;83388:21:0;83405:4;83388:21;;;83473:14;:17;;83388:14;;83448:43;;83465:6;;83473:14;83388;;83473:17;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;83448:16;:43::i;:::-;83430:61;;83519:1;83506:10;:14;:42;;;;-1:-1:-1;83524:10:0;;-1:-1:-1;;;;;83524:10:0;:24;;83506:42;83502:149;;;83565:17;83572:10;83565:17;;:::i;:::-;;;83597:42;83607:4;83621;83628:10;83597:9;:42::i;:::-;83663:21;83687:43;83704:6;83712:14;83727:1;83712:17;;;;;;;;:::i;83687:43::-;83663:67;;83764:1;83745:16;:20;:49;;;;-1:-1:-1;83769:11:0;;-1:-1:-1;;;;;83769:11:0;:25;;83745:49;83741:166;;;83811:23;83818:16;83811:23;;:::i;:::-;83865:11;;83811:23;;-1:-1:-1;83849:46:0;;83859:4;;-1:-1:-1;;;;;83865:11:0;83878:16;83849:9;:46::i;:::-;83919:15;83937:53;83954:13;:11;:13::i;:::-;83969:20;;-1:-1:-1;;;83969:20:0;;;;83937:16;:53::i;:::-;83919:71;;84047:10;84019:24;84037:4;84019:9;:24::i;:::-;:38;;:76;;;;-1:-1:-1;84090:4:0;;-1:-1:-1;;;;;84074:21:0;;;84090:4;;84074:21;;84019:76;84001:152;;;84122:19;:17;:19::i;:::-;-1:-1:-1;;84165:14:0;:22;;-1:-1:-1;;84165:22:0;;;-1:-1:-1;84165:22:0;;-1:-1:-1;83023:1203:0;;;;;;;:::o;55671:492::-;55760:22;55768:4;55774:7;55760;:22::i;:::-;55755:401;;55948:28;55968:7;55948:19;:28::i;:::-;56049:38;56077:4;56084:2;56049:19;:38::i;:::-;55853:257;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;55853:257:0;;;;;;;;;;-1:-1:-1;;;55799:345:0;;;;;;;:::i;59952:239::-;60036:22;60044:4;60050:7;60036;:22::i;:::-;60032:152;;;60107:5;60075:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;60075:29:0;;;;;;;;;;:37;;-1:-1:-1;;60075:37:0;;;60132:40;9466:10;;60075:12;;60132:40;;60107:5;60132:40;59952:239;;:::o;69110:158::-;69183:4;69207:53;69215:3;-1:-1:-1;;;;;69235:23:0;;69207:7;:53::i;65287:120::-;65354:7;65381:3;:11;;65393:5;65381:18;;;;;;;;:::i;:::-;;;;;;;;;65374:25;;65287:120;;;;:::o;86065:172::-;86169:4;76322:3;86193:18;86201:10;86193:5;:18;:::i;:::-;:36;;;;:::i;84318:503::-;84367:15;84385:24;84403:4;84385:9;:24::i;:::-;84367:42;;84424:10;84438:1;84424:15;84420:28;;84441:7;84318:503::o;84420:28::-;84488:16;;;84502:1;84488:16;;;;;;;;84460:25;;84488:16;;;;;;;;;;-1:-1:-1;84488:16:0;84460:44;;84537:4;84515:8;84524:1;84515:11;;;;;;;;:::i;:::-;-1:-1:-1;;;;;84515:27:0;;;:11;;;;;;;;;;:27;;;;84567:6;;:13;;;-1:-1:-1;;;84567:13:0;;;;:6;;;;;:11;;:13;;;;;84515:11;;84567:13;;;;;:6;:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;84553:8;84562:1;84553:11;;;;;;;;:::i;:::-;-1:-1:-1;;;;;84553:27:0;;;:11;;;;;;;;;:27;84611:6;;84734:10;;84611:182;;-1:-1:-1;;;84611:182:0;;:6;;;;:28;;:182;;84658:10;;84611:6;;84707:8;;84734:10;;;;84763:15;;84611:182;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;84611:182:0;;;;;;;;;;;;:::i;:::-;;;84593:221;;;;84356:465;;84318:503::o;49828:151::-;49886:13;49919:52;-1:-1:-1;;;;;49931:22:0;;47983:2;49224:447;49299:13;49325:19;49357:10;49361:6;49357:1;:10;:::i;:::-;:14;;49370:1;49357:14;:::i;:::-;-1:-1:-1;;;;;49347:25:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;49347:25:0;;49325:47;;-1:-1:-1;;;49383:6:0;49390:1;49383:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;49383:15:0;;;;;;;;;-1:-1:-1;;;49409:6:0;49416:1;49409:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;49409:15:0;;;;;;;;-1:-1:-1;49440:9:0;49452:10;49456:6;49452:1;:10;:::i;:::-;:14;;49465:1;49452:14;:::i;:::-;49440:26;;49435:131;49472:1;49468;:5;49435:131;;;-1:-1:-1;;;49516:5:0;49524:3;49516:11;49507:21;;;;;;;:::i;:::-;;;;49495:6;49502:1;49495:9;;;;;;;;:::i;:::-;;;;:33;-1:-1:-1;;;;;49495:33:0;;;;;;;;-1:-1:-1;49553:1:0;49543:11;;;;;49475:3;;;:::i;:::-;;;49435:131;;;-1:-1:-1;49584:10:0;;49576:55;;;;-1:-1:-1;;;49576:55:0;;17237:2:1;49576:55:0;;;17219:21:1;;;17256:18;;;17249:30;17315:34;17295:18;;;17288:62;17367:18;;49576:55:0;17035:356:1;63103:1420:0;63169:4;63308:19;;;:12;;;:19;;;;;;63344:15;;63340:1176;;63719:21;63743:14;63756:1;63743:10;:14;:::i;:::-;63792:18;;63719:38;;-1:-1:-1;63772:17:0;;63792:22;;63813:1;;63792:22;:::i;:::-;63772:42;;63848:13;63835:9;:26;63831:405;;63882:17;63902:3;:11;;63914:9;63902:22;;;;;;;;:::i;:::-;;;;;;;;;63882:42;;64056:9;64027:3;:11;;64039:13;64027:26;;;;;;;;:::i;:::-;;;;;;;;;;;;:38;;;;64141:23;;;:12;;;:23;;;;;:36;;;63831:405;64317:17;;:3;;:17;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;64412:3;:12;;:19;64425:5;64412:19;;;;;;;;;;;64405:26;;;64455:4;64448:11;;;;;;;63340:1176;64499:5;64492:12;;;;;14:286:1;72:6;125:2;113:9;104:7;100:23;96:32;93:52;;;141:1;138;131:12;93:52;167:23;;-1:-1:-1;;;;;;219:32:1;;209:43;;199:71;;266:1;263;256:12;679:258;751:1;761:113;775:6;772:1;769:13;761:113;;;851:11;;;845:18;832:11;;;825:39;797:2;790:10;761:113;;;892:6;889:1;886:13;883:48;;;-1:-1:-1;;927:1:1;909:16;;902:27;679:258::o;942:383::-;1091:2;1080:9;1073:21;1054:4;1123:6;1117:13;1166:6;1161:2;1150:9;1146:18;1139:34;1182:66;1241:6;1236:2;1225:9;1221:18;1216:2;1208:6;1204:15;1182:66;:::i;:::-;1309:2;1288:15;-1:-1:-1;;1284:29:1;1269:45;;;;1316:2;1265:54;;942:383;-1:-1:-1;;942:383:1:o;1330:131::-;-1:-1:-1;;;;;1405:31:1;;1395:42;;1385:70;;1451:1;1448;1441:12;1466:315;1534:6;1542;1595:2;1583:9;1574:7;1570:23;1566:32;1563:52;;;1611:1;1608;1601:12;1563:52;1650:9;1637:23;1669:31;1694:5;1669:31;:::i;:::-;1719:5;1771:2;1756:18;;;;1743:32;;-1:-1:-1;;;1466:315:1:o;1786:180::-;1845:6;1898:2;1886:9;1877:7;1873:23;1869:32;1866:52;;;1914:1;1911;1904:12;1866:52;-1:-1:-1;1937:23:1;;1786:180;-1:-1:-1;1786:180:1:o;2168:247::-;2227:6;2280:2;2268:9;2259:7;2255:23;2251:32;2248:52;;;2296:1;2293;2286:12;2248:52;2335:9;2322:23;2354:31;2379:5;2354:31;:::i;2625:456::-;2702:6;2710;2718;2771:2;2759:9;2750:7;2746:23;2742:32;2739:52;;;2787:1;2784;2777:12;2739:52;2826:9;2813:23;2845:31;2870:5;2845:31;:::i;:::-;2895:5;-1:-1:-1;2952:2:1;2937:18;;2924:32;2965:33;2924:32;2965:33;:::i;:::-;2625:456;;3017:7;;-1:-1:-1;;;3071:2:1;3056:18;;;;3043:32;;2625:456::o;3453:315::-;3521:6;3529;3582:2;3570:9;3561:7;3557:23;3553:32;3550:52;;;3598:1;3595;3588:12;3550:52;3634:9;3621:23;3611:33;;3694:2;3683:9;3679:18;3666:32;3707:31;3732:5;3707:31;:::i;:::-;3757:5;3747:15;;;3453:315;;;;;:::o;4392:248::-;4460:6;4468;4521:2;4509:9;4500:7;4496:23;4492:32;4489:52;;;4537:1;4534;4527:12;4489:52;-1:-1:-1;;4560:23:1;;;4630:2;4615:18;;;4602:32;;-1:-1:-1;4392:248:1:o;4875:416::-;4940:6;4948;5001:2;4989:9;4980:7;4976:23;4972:32;4969:52;;;5017:1;5014;5007:12;4969:52;5056:9;5043:23;5075:31;5100:5;5075:31;:::i;:::-;5125:5;-1:-1:-1;5182:2:1;5167:18;;5154:32;5224:15;;5217:23;5205:36;;5195:64;;5255:1;5252;5245:12;5296:388;5364:6;5372;5425:2;5413:9;5404:7;5400:23;5396:32;5393:52;;;5441:1;5438;5431:12;5393:52;5480:9;5467:23;5499:31;5524:5;5499:31;:::i;:::-;5549:5;-1:-1:-1;5606:2:1;5591:18;;5578:32;5619:33;5578:32;5619:33;:::i;5923:127::-;5984:10;5979:3;5975:20;5972:1;5965:31;6015:4;6012:1;6005:15;6039:4;6036:1;6029:15;6055:127;6116:10;6111:3;6107:20;6104:1;6097:31;6147:4;6144:1;6137:15;6171:4;6168:1;6161:15;6187:128;6227:3;6258:1;6254:6;6251:1;6248:13;6245:39;;;6264:18;;:::i;:::-;-1:-1:-1;6300:9:1;;6187:128::o;6320:135::-;6359:3;6380:17;;;6377:43;;6400:18;;:::i;:::-;-1:-1:-1;6447:1:1;6436:13;;6320:135::o;6460:380::-;6539:1;6535:12;;;;6582;;;6603:61;;6657:4;6649:6;6645:17;6635:27;;6603:61;6710:2;6702:6;6699:14;6679:18;6676:38;6673:161;;6756:10;6751:3;6747:20;6744:1;6737:31;6791:4;6788:1;6781:15;6819:4;6816:1;6809:15;6673:161;;6460:380;;;:::o;7517:168::-;7557:7;7623:1;7619;7615:6;7611:14;7608:1;7605:21;7600:1;7593:9;7586:17;7582:45;7579:71;;;7630:18;;:::i;:::-;-1:-1:-1;7670:9:1;;7517:168::o;7690:217::-;7730:1;7756;7746:132;;7800:10;7795:3;7791:20;7788:1;7781:31;7835:4;7832:1;7825:15;7863:4;7860:1;7853:15;7746:132;-1:-1:-1;7892:9:1;;7690:217::o;8328:125::-;8368:4;8396:1;8393;8390:8;8387:34;;;8401:18;;:::i;:::-;-1:-1:-1;8438:9:1;;8328:125::o;8458:229::-;8497:4;-1:-1:-1;;;;;8594:10:1;;;;8564;;8616:12;;;8613:38;;;8631:18;;:::i;:::-;8668:13;;8458:229;-1:-1:-1;;;8458:229:1:o;11640:402::-;11842:2;11824:21;;;11881:2;11861:18;;;11854:30;11920:34;11915:2;11900:18;;11893:62;-1:-1:-1;;;11986:2:1;11971:18;;11964:36;12032:3;12017:19;;11640:402::o;12047:397::-;12249:2;12231:21;;;12288:2;12268:18;;;12261:30;12327:34;12322:2;12307:18;;12300:62;-1:-1:-1;;;12393:2:1;12378:18;;12371:31;12434:3;12419:19;;12047:397::o;12449:398::-;12651:2;12633:21;;;12690:2;12670:18;;;12663:30;12729:34;12724:2;12709:18;;12702:62;-1:-1:-1;;;12795:2:1;12780:18;;12773:32;12837:3;12822:19;;12449:398::o;13620:786::-;14031:25;14026:3;14019:38;14001:3;14086:6;14080:13;14102:62;14157:6;14152:2;14147:3;14143:12;14136:4;14128:6;14124:17;14102:62;:::i;:::-;-1:-1:-1;;;14223:2:1;14183:16;;;14215:11;;;14208:40;14273:13;;14295:63;14273:13;14344:2;14336:11;;14329:4;14317:17;;14295:63;:::i;:::-;14378:17;14397:2;14374:26;;13620:786;-1:-1:-1;;;;13620:786:1:o;14411:127::-;14472:10;14467:3;14463:20;14460:1;14453:31;14503:4;14500:1;14493:15;14527:4;14524:1;14517:15;14543:251;14613:6;14666:2;14654:9;14645:7;14641:23;14637:32;14634:52;;;14682:1;14679;14672:12;14634:52;14714:9;14708:16;14733:31;14758:5;14733:31;:::i;14799:980::-;15061:4;15109:3;15098:9;15094:19;15140:6;15129:9;15122:25;15166:2;15204:6;15199:2;15188:9;15184:18;15177:34;15247:3;15242:2;15231:9;15227:18;15220:31;15271:6;15306;15300:13;15337:6;15329;15322:22;15375:3;15364:9;15360:19;15353:26;;15414:2;15406:6;15402:15;15388:29;;15435:1;15445:195;15459:6;15456:1;15453:13;15445:195;;;15524:13;;-1:-1:-1;;;;;15520:39:1;15508:52;;15615:15;;;;15580:12;;;;15556:1;15474:9;15445:195;;;-1:-1:-1;;;;;;;15696:32:1;;;;15691:2;15676:18;;15669:60;-1:-1:-1;;;15760:3:1;15745:19;15738:35;15657:3;14799:980;-1:-1:-1;;;14799:980:1:o;15784:1105::-;15879:6;15910:2;15953;15941:9;15932:7;15928:23;15924:32;15921:52;;;15969:1;15966;15959:12;15921:52;16002:9;15996:16;-1:-1:-1;;;;;16072:2:1;16064:6;16061:14;16058:34;;;16088:1;16085;16078:12;16058:34;16126:6;16115:9;16111:22;16101:32;;16171:7;16164:4;16160:2;16156:13;16152:27;16142:55;;16193:1;16190;16183:12;16142:55;16222:2;16216:9;16244:2;16240;16237:10;16234:36;;;16250:18;;:::i;:::-;16296:2;16293:1;16289:10;16328:2;16322:9;16391:2;16387:7;16382:2;16378;16374:11;16370:25;16362:6;16358:38;16446:6;16434:10;16431:22;16426:2;16414:10;16411:18;16408:46;16405:72;;;16457:18;;:::i;:::-;16493:2;16486:22;16543:18;;;16577:15;;;;-1:-1:-1;16619:11:1;;;16615:20;;;16647:19;;;16644:39;;;16679:1;16676;16669:12;16644:39;16703:11;;;;16723:135;16739:6;16734:3;16731:15;16723:135;;;16805:10;;16793:23;;16756:12;;;;16836;;;;16723:135;;;16877:6;15784:1105;-1:-1:-1;;;;;;;;15784:1105:1:o;16894:136::-;16933:3;16961:5;16951:39;;16970:18;;:::i;:::-;-1:-1:-1;;;17006:18:1;;16894:136::o;17396:127::-;17457:10;17452:3;17448:20;17445:1;17438:31;17488:4;17485:1;17478:15;17512:4;17509:1;17502:15
Swarm Source
ipfs://beddf6144333182183d0f7b932b55bfcd9b38c979a37fdbb873e8d540fd7d984
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 26 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
Loading...
Loading
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.