Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
Latest 25 from a total of 42 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Stake | 11200499 | 1429 days ago | IN | 0 ETH | 0.02017623 | ||||
Stake | 11196030 | 1430 days ago | IN | 0 ETH | 0.0207489 | ||||
Stake | 11194826 | 1430 days ago | IN | 0 ETH | 0.01497714 | ||||
Stake | 11194809 | 1430 days ago | IN | 0 ETH | 0.0044 | ||||
Stake | 11194785 | 1430 days ago | IN | 0 ETH | 0.12139999 | ||||
Stake | 11194769 | 1430 days ago | IN | 0 ETH | 0.02739504 | ||||
Stake | 11194758 | 1430 days ago | IN | 0 ETH | 0.02988554 | ||||
Stake | 11194755 | 1430 days ago | IN | 0 ETH | 0.06226155 | ||||
Stake | 11194704 | 1430 days ago | IN | 0 ETH | 0.01751624 | ||||
Stake | 11194700 | 1430 days ago | IN | 0 ETH | 0.00349996 | ||||
Stake | 11194665 | 1430 days ago | IN | 0 ETH | 0.02739508 | ||||
Stake | 11194624 | 1430 days ago | IN | 0 ETH | 0.0032 | ||||
Stake | 11194623 | 1430 days ago | IN | 0 ETH | 0.04150765 | ||||
Stake | 11194621 | 1430 days ago | IN | 0 ETH | 0.02573477 | ||||
Stake | 11194596 | 1430 days ago | IN | 0 ETH | 0.12320374 | ||||
Stake | 11194551 | 1430 days ago | IN | 0 ETH | 0.08920035 | ||||
Stake | 11194548 | 1430 days ago | IN | 0 ETH | 0.11921392 | ||||
Stake | 11194545 | 1430 days ago | IN | 0 ETH | 0.15308338 | ||||
Stake | 11194540 | 1430 days ago | IN | 0 ETH | 0.04594162 | ||||
Stake | 11194532 | 1430 days ago | IN | 0 ETH | 0.05108939 | ||||
Stake | 11194528 | 1430 days ago | IN | 0 ETH | 0.02905539 | ||||
Stake | 11194509 | 1430 days ago | IN | 0 ETH | 0.02324431 | ||||
Stake | 11194470 | 1430 days ago | IN | 0 ETH | 0.04980924 | ||||
Stake | 11194463 | 1430 days ago | IN | 0 ETH | 0.02324431 | ||||
Claim | 11194444 | 1430 days ago | IN | 0 ETH | 0.00518225 |
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Contract Name:
Turbulent
Compiler Version
v0.6.12+commit.27d51765
Optimization Enabled:
No with 200 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: Unlicensed pragma solidity ^0.6.12; import '@openzeppelin/contracts/token/ERC20/IERC20.sol'; import '@openzeppelin/contracts/token/ERC20/SafeERC20.sol'; import "@openzeppelin/contracts/math/Math.sol"; import "@openzeppelin/contracts/math/SafeMath.sol"; import "@openzeppelin/contracts/utils/Address.sol"; import "@openzeppelin/contracts/utils/ReentrancyGuard.sol"; import "@openzeppelin/contracts/access/Ownable.sol"; import "./uniswapv2/interfaces/IUniswapV2Factory.sol"; import "./uniswapv2/interfaces/IUniswapV2Pair.sol"; import "./uniswapv2/interfaces/IUniswapV2Router02.sol"; import "./Fountain.sol"; contract Turbulent is ReentrancyGuard, Ownable { using SafeMath for uint256; using Address for address; using SafeERC20 for IERC20; event Staked(address indexed from, uint256 amountETH, uint256 amountLP); event Withdrawn(address indexed to, uint256 amountETH, uint256 amountLP); event Claimed(address indexed to, uint256 amount); event Halving(uint256 amount); event Received(address indexed from, uint256 amount); Fountain public token; IUniswapV2Factory public factory; IUniswapV2Router02 public router; address public fluid; address payable public treasury; address payable public shareHolders; address public pairAddress; struct AccountInfo { // Staked LP token balance uint256 balance; uint256 peakBalance; uint256 withdrawTimestamp; uint256 reward; uint256 rewardPerTokenPaid; } mapping(address => AccountInfo) public accountInfos; // Staked LP token total supply uint256 private _totalSupply = 0; uint256 public constant HALVING_DURATION = 7 days; uint256 public rewardAllocation; uint256 public halvingTimestamp = 0; uint256 public lastUpdateTimestamp = 0; uint256 public rewardRate = 0; uint256 public rewardPerTokenStored = 0; // Farming will be open on this timestamp // Thursday, November 5, 2020 2:00:00 AM uint256 public farmingStartTimestamp = 1604541600; bool public farmingStarted = false; // Max 10% / day LP withdraw uint256 public constant WITHDRAW_LIMIT = 10; // Burn address address constant BURN_ADDRESS = 0x000000000000000000000000000000000000dEaD; // Dev decided to launch without whitelist but since it has been coded and tested, so dev will be leave it here. // Whitelisted address mapping (address => bool) public whitelists; // Whitelist deposited balance mapping (address => uint256) public whitelistBalance; // End period for whitelist advantage uint256 public whitelistEndTimestamp = 0; // Max stake for whitelist uint256 public constant WHITELIST_STAKE_LIMIT = 3 ether; // Whitelist advantage duration (reduced to 1 minutes since we dont have whitelist) uint256 public constant WHITELIST_DURATION = 1 minutes; uint256 public tokensPerFUN; constructor(address _routerAddress, address[] memory _whitelists, address payable _shareHolders, address _fluid, uint256 _rewardAllocation, uint256 _tokensPerFUN) public { router = IUniswapV2Router02(_routerAddress); factory = IUniswapV2Factory(router.factory()); treasury = msg.sender; fluid = _fluid; rewardAllocation = _rewardAllocation.mul(1 ether); tokensPerFUN = _tokensPerFUN; shareHolders = _shareHolders; // Calc reward rate rewardRate = rewardAllocation.div(HALVING_DURATION); // Init whitelist _setupWhitelists(_whitelists); whitelistEndTimestamp = farmingStartTimestamp.add(WHITELIST_DURATION); } receive() external payable { emit Received(msg.sender, msg.value); } function setMintable(address _token) external onlyOwner { require(address(token) == address(0), "Only Once"); token = Fountain(_token); pairAddress = factory.createPair(_token, fluid); } function stake(uint256 _amount) external nonReentrant { _checkFarming(); _updateReward(msg.sender); _halving(); require(_amount > 0, 'Cannot stake 0'); require(!address(msg.sender).isContract(), 'Please use your individual account'); uint256 amount = _amount; uint256 fluidAmount = IERC20(fluid).balanceOf(pairAddress); uint256 tokenAmount = IERC20(token).balanceOf(pairAddress); IERC20(fluid).transferFrom(msg.sender, address(this), amount); // If eth amount = 0 then set initial price to 1 FUN / tokensPerFUN uint256 amountTokenDesired = fluidAmount == 0 ? amount.div(tokensPerFUN) : amount.mul(tokenAmount).div(fluidAmount); // Mint borrowed Fountain token.mint(address(this), amountTokenDesired); // Add liquidity in uniswap uint256 amountFluidDesired = amount; token.approve(address(router), amountTokenDesired); IERC20(fluid).approve(address(router), amountFluidDesired); (,, uint256 liquidity) = router.addLiquidity(address(token), address(fluid), amountTokenDesired, amountFluidDesired, 1, 1, address(this), block.timestamp.add(1800)); // Add LP token to total supply _totalSupply = _totalSupply.add(liquidity); // Add to balance accountInfos[msg.sender].balance = accountInfos[msg.sender].balance.add(liquidity); // Set peak balance if (accountInfos[msg.sender].balance > accountInfos[msg.sender].peakBalance) { accountInfos[msg.sender].peakBalance = accountInfos[msg.sender].balance; } // Set stake timestamp as withdraw timestamp // to prevent withdraw immediately after first staking if (accountInfos[msg.sender].withdrawTimestamp == 0) { accountInfos[msg.sender].withdrawTimestamp = block.timestamp; } emit Staked(msg.sender, amount, liquidity); } function claim() external nonReentrant { _checkFarming(); _updateReward(msg.sender); _halving(); uint256 reward = accountInfos[msg.sender].reward; require(reward > 0, 'There is no reward to claim'); if (reward > 0) { // Reduce first accountInfos[msg.sender].reward = 0; // Apply tax uint256 taxDenominator = claimTaxDenominator(); uint256 tax = taxDenominator > 0 ? reward.div(taxDenominator) : 0; uint256 net = reward.sub(tax); // Send reward token.mint(msg.sender, net); if (tax > 0) { token.mint(address(shareHolders), tax); IDEE(shareHolders).addPendingTokenRewards(tax, address(token)); } emit Claimed(msg.sender, reward); } } function totalSupply() external view returns (uint256) { return _totalSupply; } function balanceOf(address account) external view returns (uint256) { return accountInfos[account].balance; } function burnedTokenAmount() public view returns (uint256) { return token.balanceOf(BURN_ADDRESS); } function rewardPerToken() public view returns (uint256) { if (_totalSupply == 0) { return rewardPerTokenStored; } return rewardPerTokenStored .add( lastRewardTimestamp() .sub(lastUpdateTimestamp) .mul(rewardRate) .mul(1e18) .div(_totalSupply) ); } function lastRewardTimestamp() public view returns (uint256) { return Math.min(block.timestamp, halvingTimestamp); } function rewardEarned(address account) public view returns (uint256) { return accountInfos[account].balance.mul( rewardPerToken().sub(accountInfos[account].rewardPerTokenPaid) ) .div(1e18) .add(accountInfos[account].reward); } // Token priced against pair. function tokenPrice() public view returns (uint256) { uint256 fluidAmount = IERC20(fluid).balanceOf(pairAddress); uint256 tokenAmount = IERC20(token).balanceOf(pairAddress); return tokenAmount > 0 ? // Current price fluidAmount.mul(1e18).div(tokenAmount) : // Initial price (uint256(1e18).div(2)); } function claimTaxDenominator() public view returns (uint256) { if (block.timestamp < farmingStartTimestamp + 1 days) { return 4; } else if (block.timestamp < farmingStartTimestamp + 2 days) { return 5; } else if (block.timestamp < farmingStartTimestamp + 3 days) { return 10; } else if (block.timestamp < farmingStartTimestamp + 4 days) { return 20; } else { return 0; } } function _updateReward(address account) internal { rewardPerTokenStored = rewardPerToken(); lastUpdateTimestamp = lastRewardTimestamp(); if (account != address(0)) { accountInfos[account].reward = rewardEarned(account); accountInfos[account].rewardPerTokenPaid = rewardPerTokenStored; } } // Do halving when timestamp reached function _halving() internal { if (block.timestamp >= halvingTimestamp) { rewardAllocation = rewardAllocation.div(2); rewardRate = rewardAllocation.div(HALVING_DURATION); halvingTimestamp = halvingTimestamp.add(HALVING_DURATION); _updateReward(msg.sender); emit Halving(rewardAllocation); } } // Check if farming is started function _checkFarming() internal { require(farmingStartTimestamp <= block.timestamp, 'Please wait until farming started'); if (!farmingStarted) { farmingStarted = true; halvingTimestamp = block.timestamp.add(HALVING_DURATION); lastUpdateTimestamp = block.timestamp; } } function _setupWhitelists(address[] memory addresses) internal { for (uint256 i = 0; i < addresses.length; i++) { whitelists[addresses[i]] = true; } } }
// SPDX-License-Identifier: Unlicensed pragma solidity ^0.6.12; import "@openzeppelin/contracts/GSN/Context.sol"; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/math/SafeMath.sol"; import "./interfaces/IDEE.sol"; contract Fountain is Context, IERC20 { using SafeMath for uint256; address payable shareHolders; address public admin; address[] cantBePausedList; mapping (address => uint256) private _balances; mapping (address => mapping (address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; uint8 private _decimals; bool public started = false; //Not started bool public ended = false; //Not ended bool public paused = true; //Start paused address[3] minters; modifier onlyAdmin { require(msg.sender == admin, "Only the admin can do this"); _; } /** * @dev Sets the values for {name} and {symbol}, initializes {decimals} with * a default value of 18. * * To select a different value for {decimals}, use {_setupDecimals}. * * All three of these values are immutable: they can only be set once during * construction. */ constructor (address [] memory _minters, address payable _shareHolder, address [] memory _unpausable) public { _name = "Fountain.Services"; _symbol = "FUN"; _decimals = 18; admin = msg.sender; cantBePausedList.push(msg.sender); for(uint i = 0; i < _minters.length ; i++) minters[i] = _minters[i]; for(uint i = 0; i < _unpausable.length ; i++) cantBePausedList.push(_unpausable[i]); shareHolders = _shareHolder; } /** * @dev Returns the name of the token. */ function name() public view returns (string memory) { return _name; } /** * @dev Returns the symbol of the token, usually a shorter version of the * name. */ function symbol() public view returns (string memory) { return _symbol; } /** * @dev Returns the number of decimals used to get its user representation. * For example, if `decimals` equals `2`, a balance of `505` tokens should * be displayed to a user as `5,05` (`505 / 10 ** 2`). * * Tokens usually opt for a value of 18, imitating the relationship between * Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is * called. * * NOTE: This information is only used for _display_ purposes: it in * no way affects any of the arithmetic of the contract, including * {IERC20-balanceOf} and {IERC20-transfer}. */ function decimals() public view returns (uint8) { return _decimals; } /** * @dev See {IERC20-totalSupply}. */ function totalSupply() public view override returns (uint256) { return _totalSupply; } /** * @dev See {IERC20-balanceOf}. */ function balanceOf(address account) public view override returns (uint256) { return _balances[account]; } function wipePauseList() external onlyAdmin { delete cantBePausedList; } function unlockPause() external onlyAdmin { paused = false; } /** * @dev See {IERC20-transfer}. * * Requirements: * * - `recipient` cannot be the zero address. * - the caller must have a balance of at least `amount`. */ function transfer(address recipient, uint256 amount) public virtual override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } /** * @dev See {IERC20-allowance}. */ function allowance(address owner, address spender) public view virtual override returns (uint256) { return _allowances[owner][spender]; } /** * @dev See {IERC20-approve}. * * Requirements: * * - `spender` cannot be the zero address. */ function approve(address spender, uint256 amount) public virtual override returns (bool) { _approve(_msgSender(), spender, amount); return true; } /** * @dev See {IERC20-transferFrom}. * * Emits an {Approval} event indicating the updated allowance. This is not * required by the EIP. See the note at the beginning of {ERC20}. * * Requirements: * * - `sender` and `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. * - the caller must have allowance for ``sender``'s tokens of at least * `amount`. */ function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } /** * @dev Moves tokens `amount` from `sender` to `recipient`. * * This is internal function is equivalent to {transfer}, and can be used to * e.g. implement automatic token fees, slashing mechanisms, etc. * * Emits a {Transfer} event. * * Requirements: * * - `sender` cannot be the zero address. * - `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. * Via cVault Finance */ function _transfer( address sender, address recipient, uint256 amount ) internal virtual { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); require(paused == false || cantBePaused(msg.sender), "Paused transfers for launch"); _beforeTokenTransfer(sender, recipient, amount); _balances[sender] = _balances[sender].sub(amount); IDEE hodlers = IDEE(shareHolders); (uint256 transferToAmount, uint256 transferFee) = hodlers.calculateAmountsAfterFee(msg.sender, amount); // Addressing a broken checker contract require(transferToAmount.add(transferFee) == amount, "Math broke, does gravity still work?"); _balances[recipient] = _balances[recipient].add(transferToAmount); emit Transfer(sender, recipient, transferToAmount); if(transferFee > 0 && shareHolders != address(0)){ _balances[shareHolders] = _balances[shareHolders].add(transferFee); emit Transfer(sender, shareHolders, transferFee); if(shareHolders != address(0)){ hodlers.addPendingTokenRewards(transferFee, address(this)); } } } /** @dev Creates `amount` tokens and assigns them to `account`, increasing * the total supply. * * Emits a {Transfer} event with `from` set to the zero address. * * Requirements: * * - `to` cannot be the zero address. */ function _mint(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: mint to the zero address"); _beforeTokenTransfer(address(0), account, amount); _totalSupply = _totalSupply.add(amount); _balances[account] = _balances[account].add(amount); emit Transfer(address(0), account, amount); } /** * @dev Destroys `amount` tokens from `account`, reducing the * total supply. * * Emits a {Transfer} event with `to` set to the zero address. * * Requirements: * * - `account` cannot be the zero address. * - `account` must have at least `amount` tokens. */ function _burn(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: burn from the zero address"); _beforeTokenTransfer(account, address(0), amount); _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance"); _totalSupply = _totalSupply.sub(amount); emit Transfer(account, address(0), amount); } /** * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens. * * This internal function is equivalent to `approve`, and can be used to * e.g. set automatic allowances for certain subsystems, etc. * * Emits an {Approval} event. * * Requirements: * * - `owner` cannot be the zero address. * - `spender` cannot be the zero address. */ function _approve(address owner, address spender, uint256 amount) internal virtual { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } /** * @dev Sets {decimals} to a value other than the default one of 18. * * WARNING: This function should only be called from the constructor. Most * applications that interact with token contracts will not expect * {decimals} to ever change, and may work incorrectly if it does. */ function _setupDecimals(uint8 decimals_) internal { _decimals = decimals_; } /** * @dev Hook that is called before any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * will be to transferred to `to`. * - when `from` is zero, `amount` tokens will be minted for `to`. * - when `to` is zero, `amount` of ``from``'s tokens will be burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { } function cantBePaused(address _addr) internal view returns (bool) { for(uint i; i < cantBePausedList.length ; i++) { if(cantBePausedList[i] == _addr) return true; } return false; } modifier onlyMinters { bool found = false; for(uint i = 0; i < minters.length; i++) { if(minters[i] == msg.sender) { found = true; break; } } require(found, 'ONLY MINTERS CAN MINT'); _; } function mint(address account, uint256 amount) external onlyMinters { _mint(account, amount); } function burn(address account, uint256 amount) external onlyMinters { _burn(account, amount); } }
pragma solidity >=0.6.2; interface IDEE { function addPendingETHRewards() external payable; function addPendingTokenRewards(uint256 _transferFee, address _token) external; function calculateAmountsAfterFee(address _sender, uint _amount) external view returns(uint256, uint256); }
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; }
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; }
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); }
pragma solidity >=0.6.2; import './IUniswapV2Router01.sol'; 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; }
// SPDX-License-Identifier: MIT pragma solidity ^0.6.0; /* * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with GSN meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address payable) { return msg.sender; } function _msgData() internal view virtual returns (bytes memory) { this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691 return msg.data; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.6.0; import "../GSN/Context.sol"; /** * @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. */ 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 () internal { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } /** * @dev Returns the address of the current owner. */ function owner() public view returns (address) { return _owner; } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { 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 { emit OwnershipTransferred(_owner, address(0)); _owner = 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"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.6.0; /** * @dev Standard math utilities missing in the Solidity language. */ library Math { /** * @dev Returns the largest of two numbers. */ function max(uint256 a, uint256 b) internal pure returns (uint256) { return a >= b ? a : b; } /** * @dev Returns the smallest of two numbers. */ function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } /** * @dev Returns the average of two numbers. The result is rounded towards * zero. */ function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow, so we distribute return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.6.0; /** * @dev Wrappers over Solidity's arithmetic operations with added overflow * checks. * * Arithmetic operations in Solidity wrap on overflow. This can easily result * in bugs, because programmers usually assume that an overflow raises an * error, which is the standard behavior in high level programming languages. * `SafeMath` restores this intuition by reverting the transaction when an * operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. */ library SafeMath { /** * @dev Returns the addition of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `+` operator. * * Requirements: * * - Addition cannot overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } /** * @dev Returns the subtraction of two unsigned integers, reverting on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } /** * @dev Returns the multiplication of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `*` operator. * * Requirements: * * - Multiplication cannot overflow. */ function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } /** * @dev Returns the integer division of two unsigned integers. Reverts on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } /** * @dev Returns the integer division of two unsigned integers. Reverts with custom message on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * Reverts when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * Reverts with custom message when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.6.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `recipient`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address recipient, uint256 amount) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool); /** * @dev Moves `amount` tokens from `sender` to `recipient` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); }
// SPDX-License-Identifier: MIT pragma solidity ^0.6.0; import "./IERC20.sol"; import "../../math/SafeMath.sol"; import "../../utils/Address.sol"; /** * @title SafeERC20 * @dev Wrappers around ERC20 operations that throw on failure (when the token * contract returns false). Tokens that return no value (and instead revert or * throw on failure) are also supported, non-reverting calls are assumed to be * successful. * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract, * which allows you to call the safe operations as `token.safeTransfer(...)`, etc. */ library SafeERC20 { using SafeMath for uint256; using Address for address; function safeTransfer(IERC20 token, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } /** * @dev Deprecated. This function has issues similar to the ones found in * {IERC20-approve}, and its usage is discouraged. * * Whenever possible, use {safeIncreaseAllowance} and * {safeDecreaseAllowance} instead. */ function safeApprove(IERC20 token, address spender, uint256 value) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' // solhint-disable-next-line max-line-length require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance" ); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).add(value); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero"); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } /** * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement * on the return value: the return value is optional (but if data is returned, it must not be false). * @param token The token targeted by the call. * @param data The call data (encoded using abi.encode or one of its variants). */ function _callOptionalReturn(IERC20 token, bytes memory data) private { // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional // solhint-disable-next-line max-line-length require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } }
// SPDX-License-Identifier: MIT pragma solidity ^0.6.2; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== */ function isContract(address account) internal view returns (bool) { // This method relies in extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success, ) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain`call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return _functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); return _functionCallWithValue(target, data, value, errorMessage); } function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) { require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: weiValue }(data); if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } }
// SPDX-License-Identifier: MIT pragma solidity ^0.6.0; /** * @dev Contract module that helps prevent reentrant calls to a function. * * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier * available, which can be applied to functions to make sure there are no nested * (reentrant) calls to them. * * Note that because there is a single `nonReentrant` guard, functions marked as * `nonReentrant` may not call one another. This can be worked around by making * those functions `private`, and then adding `external` `nonReentrant` entry * points to them. * * TIP: If you would like to learn more about reentrancy and alternative ways * to protect against it, check out our blog post * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul]. */ contract ReentrancyGuard { // Booleans are more expensive than uint256 or any type that takes up a full // word because each write operation emits an extra SLOAD to first read the // slot's contents, replace the bits taken up by the boolean, and then write // back. This is the compiler's defense against contract upgrades and // pointer aliasing, and it cannot be disabled. // The values being non-zero value makes deployment a bit more expensive, // but in exchange the refund on every call to nonReentrant will be lower in // amount. Since refunds are capped to a percentage of the total // transaction's gas, it is best to keep them low in cases like this one, to // increase the likelihood of the full refund coming into effect. uint256 private constant _NOT_ENTERED = 1; uint256 private constant _ENTERED = 2; uint256 private _status; constructor () internal { _status = _NOT_ENTERED; } /** * @dev Prevents a contract from calling itself, directly or indirectly. * Calling a `nonReentrant` function from another `nonReentrant` * function is not supported. It is possible to prevent this from happening * by making the `nonReentrant` function external, and make it call a * `private` function that does the actual work. */ modifier nonReentrant() { // On the first call to nonReentrant, _notEntered will be true require(_status != _ENTERED, "ReentrancyGuard: reentrant call"); // Any calls to nonReentrant after this point will fail _status = _ENTERED; _; // By storing the original value once again, a refund is triggered (see // https://eips.ethereum.org/EIPS/eip-2200) _status = _NOT_ENTERED; } }
{ "remappings": [], "optimizer": { "enabled": false, "runs": 200 }, "evmVersion": "istanbul", "libraries": { "": {} }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "abi" ] } } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"_routerAddress","type":"address"},{"internalType":"address[]","name":"_whitelists","type":"address[]"},{"internalType":"address payable","name":"_shareHolders","type":"address"},{"internalType":"address","name":"_fluid","type":"address"},{"internalType":"uint256","name":"_rewardAllocation","type":"uint256"},{"internalType":"uint256","name":"_tokensPerFUN","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Claimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Halving","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":"address","name":"from","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Received","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"uint256","name":"amountETH","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountLP","type":"uint256"}],"name":"Staked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amountETH","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountLP","type":"uint256"}],"name":"Withdrawn","type":"event"},{"inputs":[],"name":"HALVING_DURATION","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WHITELIST_DURATION","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WHITELIST_STAKE_LIMIT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WITHDRAW_LIMIT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"accountInfos","outputs":[{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"peakBalance","type":"uint256"},{"internalType":"uint256","name":"withdrawTimestamp","type":"uint256"},{"internalType":"uint256","name":"reward","type":"uint256"},{"internalType":"uint256","name":"rewardPerTokenPaid","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"burnedTokenAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claimTaxDenominator","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"factory","outputs":[{"internalType":"contract IUniswapV2Factory","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"farmingStartTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"farmingStarted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"fluid","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"halvingTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastRewardTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastUpdateTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pairAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rewardAllocation","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"rewardEarned","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardPerToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardPerTokenStored","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"router","outputs":[{"internalType":"contract IUniswapV2Router02","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"setMintable","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"shareHolders","outputs":[{"internalType":"address payable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"stake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"contract Fountain","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokensPerFUN","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"treasury","outputs":[{"internalType":"address payable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"whitelistBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"whitelistEndTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"whitelists","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]
Contract Creation Code
60806040526000600a556000600c556000600d556000600e556000600f55635fa35ca06010556000601160006101000a81548160ff02191690831515021790555060006014553480156200005257600080fd5b506040516200370d3803806200370d833981810160405260c08110156200007857600080fd5b810190808051906020019092919080516040519392919084640100000000821115620000a357600080fd5b83820191506020820185811115620000ba57600080fd5b8251866020820283011164010000000082111715620000d857600080fd5b8083526020830192505050908051906020019060200280838360005b8381101562000111578082015181840152602081019050620000f4565b505050509050016040526020018051906020019092919080519060200190929190805190602001909291908051906020019092919050505060016000819055506000620001636200048060201b60201c565b905080600160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508073ffffffffffffffffffffffffffffffffffffffff16600073ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35085600460006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550600460009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663c45a01556040518163ffffffff1660e01b815260040160206040518083038186803b158015620002ac57600080fd5b505afa158015620002c1573d6000803e3d6000fd5b505050506040513d6020811015620002d857600080fd5b8101908080519060200190929190505050600360006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555033600660006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555082600560006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550620003cd670de0b6b3a7640000836200048860201b6200293a1790919060201c565b600b819055508060158190555083600760006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055506200043a62093a80600b546200051360201b620029c01790919060201c565b600e8190555062000451856200056560201b60201c565b6200046e603c601054620005f060201b62002a0a1790919060201c565b60148190555050505050505062000744565b600033905090565b6000808314156200049d57600090506200050d565b6000828402905082848281620004af57fe5b041462000508576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401808060200182810382526021815260200180620036ec6021913960400191505060405180910390fd5b809150505b92915050565b60006200055d83836040518060400160405280601a81526020017f536166654d6174683a206469766973696f6e206279207a65726f0000000000008152506200067960201b60201c565b905092915050565b60005b8151811015620005ec576001601260008484815181106200058557fe5b602002602001015173ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006101000a81548160ff021916908315150217905550808060010191505062000568565b5050565b6000808284019050838110156200066f576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252601b8152602001807f536166654d6174683a206164646974696f6e206f766572666c6f77000000000081525060200191505060405180910390fd5b8091505092915050565b6000808311829062000729576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825283818151815260200191508051906020019080838360005b83811015620006ed578082015181840152602081019050620006d0565b50505050905090810190601f1680156200071b5780820380516001836020036101000a031916815260200191505b509250505060405180910390fd5b5060008385816200073657fe5b049050809150509392505050565b612f9880620007546000396000f3fe60806040526004361061021e5760003560e01c80637ff9b59611610123578063a8b08982116100ab578063df136d651161006f578063df136d65146109ac578063f2fde38b146109d7578063f8077fae14610a28578063f887ea4014610a53578063fc0c546a14610a9457610273565b8063a8b0898214610893578063b415a2d6146108d4578063c36cc02c146108ff578063c45a015514610940578063cd3daf9d1461098157610273565b806394c2c612116100f257806394c2c612146107aa57806395a2a043146107d55780639ca6fbb4146108005780639d06c5631461082d578063a694fc3a1461085857610273565b80637ff9b5961461066c57806387cad0bf146106975780638da5cb5b146107185780638ea859791461075957610273565b80634e71d92d116101a6578063677393871161017557806367739387146105595780636bb755841461058457806370a08231146105c5578063715018a61461062a5780637b0a47ee1461064157610273565b80634e71d92d146104ab578063571b1f8a146104c25780635a4ee600146104ed57806361d027b31461051857610273565b80631e7be210116101ed5780631e7be2101461035e57806325798e61146103c55780632f60f525146103f0578063341908251461041b578063368e18611461044657610273565b80630c2cd50c1461027857806314bcec9f146102a357806316ba6bf3146102ce57806318160ddd1461033357610273565b36610273573373ffffffffffffffffffffffffffffffffffffffff167f88a5966d370b9919b20f3e2c13ff65706f196a4e32cc2c12bf57088f88525874346040518082815260200191505060405180910390a2005b600080fd5b34801561028457600080fd5b5061028d610ad5565b6040518082815260200191505060405180910390f35b3480156102af57600080fd5b506102b8610adb565b6040518082815260200191505060405180910390f35b3480156102da57600080fd5b5061031d600480360360208110156102f157600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff169060200190929190505050610ae1565b6040518082815260200191505060405180910390f35b34801561033f57600080fd5b50610348610c08565b6040518082815260200191505060405180910390f35b34801561036a57600080fd5b506103ad6004803603602081101561038157600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff169060200190929190505050610c12565b60405180821515815260200191505060405180910390f35b3480156103d157600080fd5b506103da610c32565b6040518082815260200191505060405180910390f35b3480156103fc57600080fd5b50610405610c39565b6040518082815260200191505060405180910390f35b34801561042757600080fd5b50610430610c3f565b6040518082815260200191505060405180910390f35b34801561045257600080fd5b506104956004803603602081101561046957600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff169060200190929190505050610c45565b6040518082815260200191505060405180910390f35b3480156104b757600080fd5b506104c0610c5d565b005b3480156104ce57600080fd5b506104d76110fa565b6040518082815260200191505060405180910390f35b3480156104f957600080fd5b506105026110ff565b6040518082815260200191505060405180910390f35b34801561052457600080fd5b5061052d611169565b604051808273ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b34801561056557600080fd5b5061056e61118f565b6040518082815260200191505060405180910390f35b34801561059057600080fd5b50610599611195565b604051808273ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b3480156105d157600080fd5b50610614600480360360208110156105e857600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff1690602001909291905050506111bb565b6040518082815260200191505060405180910390f35b34801561063657600080fd5b5061063f611207565b005b34801561064d57600080fd5b50610656611392565b6040518082815260200191505060405180910390f35b34801561067857600080fd5b50610681611398565b6040518082815260200191505060405180910390f35b3480156106a357600080fd5b506106e6600480360360208110156106ba57600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff1690602001909291905050506115cb565b604051808681526020018581526020018481526020018381526020018281526020019550505050505060405180910390f35b34801561072457600080fd5b5061072d611601565b604051808273ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b34801561076557600080fd5b506107a86004803603602081101561077c57600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff16906020019092919050505061162b565b005b3480156107b657600080fd5b506107bf611943565b6040518082815260200191505060405180910390f35b3480156107e157600080fd5b506107ea611948565b6040518082815260200191505060405180910390f35b34801561080c57600080fd5b50610815611a15565b60405180821515815260200191505060405180910390f35b34801561083957600080fd5b50610842611a28565b6040518082815260200191505060405180910390f35b34801561086457600080fd5b506108916004803603602081101561087b57600080fd5b8101908080359060200190929190505050611a2e565b005b34801561089f57600080fd5b506108a86125b9565b604051808273ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b3480156108e057600080fd5b506108e96125df565b6040518082815260200191505060405180910390f35b34801561090b57600080fd5b506109146125eb565b604051808273ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b34801561094c57600080fd5b50610955612611565b604051808273ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b34801561098d57600080fd5b50610996612637565b6040518082815260200191505060405180910390f35b3480156109b857600080fd5b506109c16126c5565b6040518082815260200191505060405180910390f35b3480156109e357600080fd5b50610a26600480360360208110156109fa57600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff1690602001909291905050506126cb565b005b348015610a3457600080fd5b50610a3d6128db565b6040518082815260200191505060405180910390f35b348015610a5f57600080fd5b50610a686128ee565b604051808273ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b348015610aa057600080fd5b50610aa9612914565b604051808273ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b60145481565b600d5481565b6000610c01600960008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060030154610bf3670de0b6b3a7640000610be5610b94600960008973ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060040154610b86612637565b612a9290919063ffffffff16565b600960008973ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206000015461293a90919063ffffffff16565b6129c090919063ffffffff16565b612a0a90919063ffffffff16565b9050919050565b6000600a54905090565b60126020528060005260406000206000915054906101000a900460ff1681565b62093a8081565b600c5481565b60155481565b60136020528060005260406000206000915090505481565b60026000541415610cd6576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252601f8152602001807f5265656e7472616e637947756172643a207265656e7472616e742063616c6c0081525060200191505060405180910390fd5b6002600081905550610ce6612adc565b610cef33612b8c565b610cf7612c78565b6000600960003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060030154905060008111610db4576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252601b8152602001807f5468657265206973206e6f2072657761726420746f20636c61696d000000000081525060200191505060405180910390fd5b60008111156110ef576000600960003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020600301819055506000610e0f6110ff565b90506000808211610e21576000610e35565b610e3482846129c090919063ffffffff16565b5b90506000610e4c8285612a9290919063ffffffff16565b9050600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166340c10f1933836040518363ffffffff1660e01b8152600401808373ffffffffffffffffffffffffffffffffffffffff16815260200182815260200192505050600060405180830381600087803b158015610ee157600080fd5b505af1158015610ef5573d6000803e3d6000fd5b50505050600082111561109d57600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166340c10f19600760009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16846040518363ffffffff1660e01b8152600401808373ffffffffffffffffffffffffffffffffffffffff16815260200182815260200192505050600060405180830381600087803b158015610fb757600080fd5b505af1158015610fcb573d6000803e3d6000fd5b50505050600760009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16632f3e6f7c83600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff166040518363ffffffff1660e01b8152600401808381526020018273ffffffffffffffffffffffffffffffffffffffff16815260200192505050600060405180830381600087803b15801561108457600080fd5b505af1158015611098573d6000803e3d6000fd5b505050505b3373ffffffffffffffffffffffffffffffffffffffff167fd8138f8a3f377c5259ca548e70e4c2de94f129f5a11036a15b69513cba2b426a856040518082815260200191505060405180910390a25050505b506001600081905550565b603c81565b600062015180601054014210156111195760049050611166565b6202a300601054014210156111315760059050611166565b6203f4806010540142101561114957600a9050611166565b62054600601054014210156111615760149050611166565b600090505b90565b600660009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b600b5481565b600760009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6000600960008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020600001549050919050565b61120f612d1e565b73ffffffffffffffffffffffffffffffffffffffff16600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16146112d1576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260208152602001807f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657281525060200191505060405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff16600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a36000600160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550565b600e5481565b600080600560009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166370a08231600860009054906101000a900473ffffffffffffffffffffffffffffffffffffffff166040518263ffffffff1660e01b8152600401808273ffffffffffffffffffffffffffffffffffffffff16815260200191505060206040518083038186803b15801561144657600080fd5b505afa15801561145a573d6000803e3d6000fd5b505050506040513d602081101561147057600080fd5b810190808051906020019092919050505090506000600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166370a08231600860009054906101000a900473ffffffffffffffffffffffffffffffffffffffff166040518263ffffffff1660e01b8152600401808273ffffffffffffffffffffffffffffffffffffffff16815260200191505060206040518083038186803b15801561153057600080fd5b505afa158015611544573d6000803e3d6000fd5b505050506040513d602081101561155a57600080fd5b8101908080519060200190929190505050905060008111611596576115916002670de0b6b3a76400006129c090919063ffffffff16565b6115c4565b6115c3816115b5670de0b6b3a76400008561293a90919063ffffffff16565b6129c090919063ffffffff16565b5b9250505090565b60096020528060005260406000206000915090508060000154908060010154908060020154908060030154908060040154905085565b6000600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b611633612d1e565b73ffffffffffffffffffffffffffffffffffffffff16600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16146116f5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260208152602001807f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657281525060200191505060405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff16600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16146117b9576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260098152602001807f4f6e6c79204f6e6365000000000000000000000000000000000000000000000081525060200191505060405180910390fd5b80600260006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550600360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663c9c6539682600560009054906101000a900473ffffffffffffffffffffffffffffffffffffffff166040518363ffffffff1660e01b8152600401808373ffffffffffffffffffffffffffffffffffffffff1681526020018273ffffffffffffffffffffffffffffffffffffffff16815260200192505050602060405180830381600087803b1580156118c557600080fd5b505af11580156118d9573d6000803e3d6000fd5b505050506040513d60208110156118ef57600080fd5b8101908080519060200190929190505050600860006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b600a81565b6000600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166370a0823161dead6040518263ffffffff1660e01b8152600401808273ffffffffffffffffffffffffffffffffffffffff16815260200191505060206040518083038186803b1580156119d557600080fd5b505afa1580156119e9573d6000803e3d6000fd5b505050506040513d60208110156119ff57600080fd5b8101908080519060200190929190505050905090565b601160009054906101000a900460ff1681565b60105481565b60026000541415611aa7576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252601f8152602001807f5265656e7472616e637947756172643a207265656e7472616e742063616c6c0081525060200191505060405180910390fd5b6002600081905550611ab7612adc565b611ac033612b8c565b611ac8612c78565b60008111611b3e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252600e8152602001807f43616e6e6f74207374616b65203000000000000000000000000000000000000081525060200191505060405180910390fd5b611b5d3373ffffffffffffffffffffffffffffffffffffffff16612d26565b15611bb3576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401808060200182810382526022815260200180612eff6022913960400191505060405180910390fd5b60008190506000600560009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166370a08231600860009054906101000a900473ffffffffffffffffffffffffffffffffffffffff166040518263ffffffff1660e01b8152600401808273ffffffffffffffffffffffffffffffffffffffff16815260200191505060206040518083038186803b158015611c6557600080fd5b505afa158015611c79573d6000803e3d6000fd5b505050506040513d6020811015611c8f57600080fd5b810190808051906020019092919050505090506000600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166370a08231600860009054906101000a900473ffffffffffffffffffffffffffffffffffffffff166040518263ffffffff1660e01b8152600401808273ffffffffffffffffffffffffffffffffffffffff16815260200191505060206040518083038186803b158015611d4f57600080fd5b505afa158015611d63573d6000803e3d6000fd5b505050506040513d6020811015611d7957600080fd5b81019080805190602001909291905050509050600560009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166323b872dd3330866040518463ffffffff1660e01b8152600401808473ffffffffffffffffffffffffffffffffffffffff1681526020018373ffffffffffffffffffffffffffffffffffffffff1681526020018281526020019350505050602060405180830381600087803b158015611e3d57600080fd5b505af1158015611e51573d6000803e3d6000fd5b505050506040513d6020811015611e6757600080fd5b8101908080519060200190929190505050506000808314611eac57611ea783611e99848761293a90919063ffffffff16565b6129c090919063ffffffff16565b611ec2565b611ec1601554856129c090919063ffffffff16565b5b9050600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166340c10f1930836040518363ffffffff1660e01b8152600401808373ffffffffffffffffffffffffffffffffffffffff16815260200182815260200192505050600060405180830381600087803b158015611f5757600080fd5b505af1158015611f6b573d6000803e3d6000fd5b505050506000849050600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663095ea7b3600460009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16846040518363ffffffff1660e01b8152600401808373ffffffffffffffffffffffffffffffffffffffff16815260200182815260200192505050602060405180830381600087803b15801561202957600080fd5b505af115801561203d573d6000803e3d6000fd5b505050506040513d602081101561205357600080fd5b810190808051906020019092919050505050600560009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663095ea7b3600460009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16836040518363ffffffff1660e01b8152600401808373ffffffffffffffffffffffffffffffffffffffff16815260200182815260200192505050602060405180830381600087803b15801561211a57600080fd5b505af115801561212e573d6000803e3d6000fd5b505050506040513d602081101561214457600080fd5b8101908080519060200190929190505050506000600460009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663e8e33700600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16600560009054906101000a900473ffffffffffffffffffffffffffffffffffffffff168686600180306121f761070842612a0a90919063ffffffff16565b6040518963ffffffff1660e01b8152600401808973ffffffffffffffffffffffffffffffffffffffff1681526020018873ffffffffffffffffffffffffffffffffffffffff1681526020018781526020018681526020018581526020018481526020018373ffffffffffffffffffffffffffffffffffffffff16815260200182815260200198505050505050505050606060405180830381600087803b1580156122a057600080fd5b505af11580156122b4573d6000803e3d6000fd5b505050506040513d60608110156122ca57600080fd5b810190808051906020019092919080519060200190929190805190602001909291905050509250505061230881600a54612a0a90919063ffffffff16565b600a8190555061236381600960003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060000154612a0a90919063ffffffff16565b600960003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060000181905550600960003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060010154600960003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206000015411156124bf57600960003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060000154600960003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020600101819055505b6000600960003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000206002015414156125525742600960003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020600201819055505b3373ffffffffffffffffffffffffffffffffffffffff167f1449c6dd7851abc30abf37f57715f492010519147cc2652fbc38202c18a6ee908783604051808381526020018281526020019250505060405180910390a2505050505050600160008190555050565b600860009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6729a2241af62c000081565b600560009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b600360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b600080600a54141561264d57600f5490506126c2565b6126bf6126ae600a546126a0670de0b6b3a7640000612692600e54612684600d546126766128db565b612a9290919063ffffffff16565b61293a90919063ffffffff16565b61293a90919063ffffffff16565b6129c090919063ffffffff16565b600f54612a0a90919063ffffffff16565b90505b90565b600f5481565b6126d3612d1e565b73ffffffffffffffffffffffffffffffffffffffff16600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1614612795576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260208152602001807f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657281525060200191505060405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16141561281b576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401808060200182810382526026815260200180612ed96026913960400191505060405180910390fd5b8073ffffffffffffffffffffffffffffffffffffffff16600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a380600160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b60006128e942600c54612d39565b905090565b600460009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b60008083141561294d57600090506129ba565b600082840290508284828161295e57fe5b04146129b5576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401808060200182810382526021815260200180612f426021913960400191505060405180910390fd5b809150505b92915050565b6000612a0283836040518060400160405280601a81526020017f536166654d6174683a206469766973696f6e206279207a65726f000000000000815250612d52565b905092915050565b600080828401905083811015612a88576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252601b8152602001807f536166654d6174683a206164646974696f6e206f766572666c6f77000000000081525060200191505060405180910390fd5b8091505092915050565b6000612ad483836040518060400160405280601e81526020017f536166654d6174683a207375627472616374696f6e206f766572666c6f770000815250612e18565b905092915050565b426010541115612b37576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401808060200182810382526021815260200180612f216021913960400191505060405180910390fd5b601160009054906101000a900460ff16612b8a576001601160006101000a81548160ff021916908315150217905550612b7c62093a8042612a0a90919063ffffffff16565b600c8190555042600d819055505b565b612b94612637565b600f81905550612ba26128db565b600d81905550600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1614612c7557612be581610ae1565b600960008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060030181905550600f54600960008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020600401819055505b50565b600c544210612d1c57612c976002600b546129c090919063ffffffff16565b600b81905550612cb562093a80600b546129c090919063ffffffff16565b600e81905550612cd362093a80600c54612a0a90919063ffffffff16565b600c81905550612ce233612b8c565b7ffafb0ec84dbe5a6bf08f4fec2f970b66d402032cdfea2008b11e11eb5c3990f0600b546040518082815260200191505060405180910390a15b565b600033905090565b600080823b905060008111915050919050565b6000818310612d485781612d4a565b825b905092915050565b60008083118290612dfe576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825283818151815260200191508051906020019080838360005b83811015612dc3578082015181840152602081019050612da8565b50505050905090810190601f168015612df05780820380516001836020036101000a031916815260200191505b509250505060405180910390fd5b506000838581612e0a57fe5b049050809150509392505050565b6000838311158290612ec5576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825283818151815260200191508051906020019080838360005b83811015612e8a578082015181840152602081019050612e6f565b50505050905090810190601f168015612eb75780820380516001836020036101000a031916815260200191505b509250505060405180910390fd5b506000838503905080915050939250505056fe4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061646472657373506c656173652075736520796f757220696e646976696475616c206163636f756e74506c65617365207761697420756e74696c206661726d696e672073746172746564536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f77a264697066735822122066274e95dd3f43682c4a737ee58d70325d67f50d6d2c01a79d7882d917af963e64736f6c634300060c0033536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f770000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d00000000000000000000000000000000000000000000000000000000000000c0000000000000000000000000656ad4c1f06cd333271784fb042bb4d49df941110000000000000000000000003642a41e430cd75663cd4e951b45514ab43e590a00000000000000000000000000000000000000000000000000000000000003e8000000000000000000000000000000000000000000000000000000000000002f0000000000000000000000000000000000000000000000000000000000000002000000000000000000000000aa0722789113b63321638cecd21fccede780d16a000000000000000000000000dca8246f28d9d8cef0d219e6b07cd36801a85f7a
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d00000000000000000000000000000000000000000000000000000000000000c0000000000000000000000000656ad4c1f06cd333271784fb042bb4d49df941110000000000000000000000003642a41e430cd75663cd4e951b45514ab43e590a00000000000000000000000000000000000000000000000000000000000003e8000000000000000000000000000000000000000000000000000000000000002f0000000000000000000000000000000000000000000000000000000000000002000000000000000000000000aa0722789113b63321638cecd21fccede780d16a000000000000000000000000dca8246f28d9d8cef0d219e6b07cd36801a85f7a
-----Decoded View---------------
Arg [0] : _routerAddress (address): 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D
Arg [1] : _whitelists (address[]): 0xAA0722789113b63321638CECd21fCCeDe780D16A,0xDCA8246F28d9d8ceF0D219e6b07cD36801A85f7a
Arg [2] : _shareHolders (address): 0x656ad4c1f06cD333271784fB042BB4d49df94111
Arg [3] : _fluid (address): 0x3642A41e430Cd75663cD4E951b45514Ab43e590A
Arg [4] : _rewardAllocation (uint256): 1000
Arg [5] : _tokensPerFUN (uint256): 47
-----Encoded View---------------
9 Constructor Arguments found :
Arg [0] : 0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [2] : 000000000000000000000000656ad4c1f06cd333271784fb042bb4d49df94111
Arg [3] : 0000000000000000000000003642a41e430cd75663cd4e951b45514ab43e590a
Arg [4] : 00000000000000000000000000000000000000000000000000000000000003e8
Arg [5] : 000000000000000000000000000000000000000000000000000000000000002f
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000002
Arg [7] : 000000000000000000000000aa0722789113b63321638cecd21fccede780d16a
Arg [8] : 000000000000000000000000dca8246f28d9d8cef0d219e6b07cd36801a85f7a
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 27 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.