Address Details
contract
0x29395F52BC8cfEAB8d298e7C4E9E76C0acCD4Ccd
- Contract Name
- WannaFarm
- Creator
- 0x94a53e–900d50 at 0x3ba86e–ee7984
- Balance
- 0 CELO ( )
- Locked CELO Balance
- 0.00 CELO
- Voting CELO Balance
- 0.00 CELO
- Pending Unlocked Gold
- 0.00 CELO
- Tokens
-
Fetching tokens...
- Transactions
- Fetching transactions...
- Transfers
- Fetching transfers...
- Gas Used
- Fetching gas used...
- Last Balance Update
- 9183890
Transactions
Token Transfers
Tokens
Internal Transactions
Coin Balance History
Logs
Code
Read Contract
Write Contract
This contract has been verified via Sourcify.
View contract in Sourcify repository
- Contract name:
- WannaFarm
- Optimization enabled
- true
- Compiler version
- v0.6.12+commit.27d51765
- Optimization runs
- 200
- EVM Version
- istanbul
- Verified at
- 2021-10-05T16:02:19.301878Z
Contract source code
// SPDX-License-Identifier: MIT pragma experimental ABIEncoderV2; pragma solidity =0.6.12; import "@openzeppelin/contracts/token/ERC20/SafeERC20.sol"; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/math/SafeMath.sol"; import "@openzeppelin/contracts/access/Ownable.sol"; import "../interfaces/IWannaSwapTreasury.sol"; import "./WannaSwapToken.sol"; contract WannaFarm is Ownable { string public name = "WannaFarm"; using SafeMath for uint; using SafeERC20 for IERC20; using SafeERC20 for WannaSwapToken; struct UserInfo { uint amount; uint rewardDebt; } struct PoolInfo { IERC20 lpToken; uint allocPoint; uint lastRewardBlock; uint accWannaPerShare; uint totalLp; } WannaSwapToken public wanna; uint public startBlock; address public burnAddress = address(0x000000000000000000000000000000000000dEaD); uint public burnPercent; uint public totalWanna; uint public mintedWanna; uint public wannaPerBlock; PoolInfo[] public poolInfo; mapping (uint => mapping (address => UserInfo)) public userInfo; uint public totalAllocPoint = 0; event Deposit(address indexed user, uint indexed pid, uint amount); event Withdraw(address indexed user, uint indexed pid, uint amount); event EmergencyWithdraw(address indexed user, uint indexed pid, uint amount); constructor( WannaSwapToken _wanna, uint _totalWanna, uint _wannaPerBlock, uint _burnPercent ) public { wanna = _wanna; totalWanna = _totalWanna; mintedWanna = 0; wannaPerBlock = _wannaPerBlock; burnPercent = _burnPercent; startBlock = block.number; } // It's not a fool proof solution, but it prevents flash loans, so here it's ok to use tx.origin modifier onlyEOA() { // Try to make flash-loan exploit harder to do. require(msg.sender == tx.origin, "MUST USE EOA"); _; } function setEmissionRate(uint _wannaPerBlock) public onlyOwner { updateAllPools(); wannaPerBlock = _wannaPerBlock; } function setTotalWanna( uint _totalWanna) public onlyOwner { updateAllPools(); require(_totalWanna >= mintedWanna, "setTotalWanna: BAD TOTALWANNA"); totalWanna = _totalWanna; } function setPercent( uint _burnPercent) public onlyOwner { require(_burnPercent < 100, "setPercent: BAD PERCENT"); updateAllPools(); burnPercent = _burnPercent; } function poolLength() external view returns (uint) { return poolInfo.length; } function addPool(uint _allocPoint, IERC20 _lpToken, bool _withUpdate) public onlyOwner { if (_withUpdate) { updateAllPools(); } uint lastRewardBlock = block.number > startBlock ? block.number : startBlock; totalAllocPoint = totalAllocPoint.add(_allocPoint); poolInfo.push(PoolInfo({ lpToken: _lpToken, allocPoint: _allocPoint, lastRewardBlock: lastRewardBlock, accWannaPerShare: 0, totalLp: 0 })); } function setPool(uint _pid, uint _allocPoint, bool _withUpdate) public onlyOwner { require(_pid < poolInfo.length, "setPool: BAD POOL"); if (_withUpdate) { updateAllPools(); } totalAllocPoint = totalAllocPoint.add(_allocPoint).sub(poolInfo[_pid].allocPoint); poolInfo[_pid].allocPoint = _allocPoint; } function getBlockCount(uint _from, uint _to) public view returns (uint) { return _to.sub(_from); } function pendingWanna(uint _pid, address _user) public view returns (uint) { require(_pid < poolInfo.length, "pendingWanna: BAD POOL"); PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][_user]; uint accWannaPerShare = pool.accWannaPerShare; uint lpSupply = pool.lpToken.balanceOf(address(this)); if (block.number > pool.lastRewardBlock && lpSupply != 0) { uint blockCount = getBlockCount(pool.lastRewardBlock, block.number); uint wannaReward = blockCount.mul(wannaPerBlock).mul(pool.allocPoint).div(totalAllocPoint); ( , uint farmWanna) = calculate(wannaReward); accWannaPerShare = accWannaPerShare.add(farmWanna.mul(1e18).div(lpSupply)); } return user.amount.mul(accWannaPerShare).div(1e18).sub(user.rewardDebt); } function updateAllPools() public { uint length = poolInfo.length; for (uint pid = 0; pid < length; pid++) { updatePool(pid); } } function calculate(uint _reward) public view returns (uint burnWanna, uint farmWanna) { if (totalWanna <= mintedWanna.add(_reward)) { _reward = totalWanna.sub(mintedWanna); } burnWanna = _reward.mul(burnPercent).div(100); farmWanna = _reward.sub(burnWanna); } function updatePool(uint _pid) public { require(_pid < poolInfo.length, "updatePool: BAD POOL"); PoolInfo storage pool = poolInfo[_pid]; if (block.number <= pool.lastRewardBlock) { return; } uint lpSupply = pool.lpToken.balanceOf(address(this)); if (lpSupply == 0 || pool.allocPoint == 0) { pool.lastRewardBlock = block.number; return; } uint blockCount = getBlockCount(pool.lastRewardBlock, block.number); uint wannaReward = blockCount.mul(wannaPerBlock).mul(pool.allocPoint).div(totalAllocPoint); (uint burnWanna, uint farmWanna) = calculate(wannaReward); wanna.mint(address(this), burnWanna.add(farmWanna)); mintedWanna = mintedWanna.add(burnWanna).add(farmWanna); if (burnWanna > 0) { wanna.transfer(burnAddress, burnWanna); } pool.accWannaPerShare = pool.accWannaPerShare.add(farmWanna.mul(1e18).div(lpSupply)); pool.lastRewardBlock = block.number; } function harvest(uint _pid, address _user) internal { require(_pid < poolInfo.length, "harvest: BAD POOL"); PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][_user]; uint amount = user.amount; if (amount > 0) { uint pending = pendingWanna(_pid, _user); uint balance = wanna.balanceOf(address(this)); if (pending > balance) { pending = balance; } if(pending > 0) { wanna.transfer(_user, pending); } user.rewardDebt = user.amount.mul(pool.accWannaPerShare).div(1e18); } } function deposit(uint _pid, uint _amount) public onlyEOA { require(_pid < poolInfo.length, "deposit: BAD POOL"); PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; updatePool(_pid); harvest(_pid, msg.sender); if(_amount > 0) { pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount); user.amount = user.amount.add(_amount); pool.totalLp = pool.totalLp.add(_amount); } user.rewardDebt = user.amount.mul(pool.accWannaPerShare).div(1e18); emit Deposit(msg.sender, _pid, _amount); } function withdraw(uint _pid, uint _amount) public onlyEOA { require(_pid < poolInfo.length, "withdraw: BAD POOL"); PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; require(user.amount >= _amount, "withdraw: BAD AMOUNT"); updatePool(_pid); harvest(_pid, msg.sender); if(_amount > 0) { user.amount = user.amount.sub(_amount); pool.totalLp = pool.totalLp.sub(_amount); pool.lpToken.safeTransfer(address(msg.sender), _amount); } user.rewardDebt = user.amount.mul(pool.accWannaPerShare).div(1e18); emit Withdraw(msg.sender, _pid, _amount); } function emergencyWithdraw(uint _pid) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; uint amount = user.amount; user.amount = 0; pool.totalLp = pool.totalLp.sub(amount); user.rewardDebt = 0; pool.lpToken.safeTransfer(address(msg.sender), amount); emit EmergencyWithdraw(msg.sender, _pid, amount); } }
WannaSwapMintable.sol
// SPDX-License-Identifier: MIT pragma solidity =0.6.12; import "@openzeppelin/contracts/access/Ownable.sol"; import "@openzeppelin/contracts/GSN/Context.sol"; contract WannaSwapMintable is Context, Ownable { mapping(address => bool) public _minters; event SetMinter(address indexed user, bool isMinter); constructor () internal { address msgSender = _msgSender(); _minters[msgSender] = true; emit SetMinter(msgSender, true); } modifier onlyMinter() { require(_minters[_msgSender()], "WannaSwapMintable: MUST BE MINTER"); _; } function setMinter(address _user, bool _isMinter) public virtual onlyOwner { emit SetMinter(_user, _isMinter); _minters[_user] = _isMinter; } function addMinter(address _user) public virtual onlyOwner { setMinter(_user, true); } function removeMinter(address _user) public virtual onlyOwner { setMinter(_user, false); } }
WannaSwapToken.sol
// SPDX-License-Identifier: MIT pragma solidity =0.6.12; import "@openzeppelin/contracts/token/ERC20/ERC20.sol"; import "@openzeppelin/contracts/math/SafeMath.sol"; import "./WannaSwapMintable.sol"; contract WannaSwapToken is ERC20("WannaSwap", "WANNA"), WannaSwapMintable { uint256 private _maxSupply = 200000000e18; uint256 private _initialSupply = 46000000e18; /** * @dev Returns the max supply */ function maxSupply() public view returns (uint256) { return _maxSupply; } /** * @dev See {ERC20-_beforeTokenTransfer}. * * Requirements: * * - minted tokens must not cause the total supply to go over the max supply. */ function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override { super._beforeTokenTransfer(from, to, amount); if (from == address(0)) { // When minting tokens require(totalSupply().add(amount) <= _maxSupply, "ERC20Capped: Max supply exceeded"); } } /** * @dev Moves tokens `amount` from `sender` to `recipient`. * * This is internal function is equivalent to {transfer}, and can be used to * e.g. implement automatic token fees, slashing mechanisms, etc. * * Emits a {Transfer} event. * * Requirements: * * - `sender` cannot be the zero address. * - `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. */ function _transfer(address sender, address recipient, uint256 amount) internal virtual override { super._transfer(sender, recipient, amount); _moveDelegates(_delegates[sender], _delegates[recipient], amount); } /// @notice Creates `_amount` token to `_to`. Must only be called by the minters. function mint(address _to, uint256 _amount) public onlyMinter { _mint(_to, _amount); _moveDelegates(address(0), _delegates[_to], _amount); } function burn(uint256 _amount) public { super._burn(msg.sender, _amount); } // Copied and modified from YAM code: // https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernanceStorage.sol // https://github.com/yam-finance/yam-protocol/blob/master/contracts/token/YAMGovernance.sol // Which is copied and modified from COMPOUND: // https://github.com/compound-finance/compound-protocol/blob/master/contracts/Governance/Comp.sol /// @dev A record of each accounts delegate mapping (address => address) internal _delegates; /// @notice A checkpoint for marking number of votes from a given block struct Checkpoint { uint32 fromBlock; uint256 votes; } /// @notice A record of votes checkpoints for each account, by index mapping (address => mapping (uint32 => Checkpoint)) public checkpoints; /// @notice The number of checkpoints for each account mapping (address => uint32) public numCheckpoints; /// @notice The EIP-712 typehash for the contract's domain bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)"); /// @notice The EIP-712 typehash for the delegation struct used by the contract bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)"); /// @notice A record of states for signing / validating signatures mapping (address => uint) public nonces; /// @notice An event thats emitted when an account changes its delegate event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate); /// @notice An event thats emitted when a delegate account's vote balance changes event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance); /** * @notice Delegate votes from `msg.sender` to `delegatee` * @param delegator The address to get delegatee for */ function delegates(address delegator) external view returns (address) { return _delegates[delegator]; } /** * @notice Delegate votes from `msg.sender` to `delegatee` * @param delegatee The address to delegate votes to */ function delegate(address delegatee) external { return _delegate(msg.sender, delegatee); } /** * @notice Delegates votes from signatory to `delegatee` * @param delegatee The address to delegate votes to * @param nonce The contract state required to match the signature * @param expiry The time at which to expire the signature * @param v The recovery byte of the signature * @param r Half of the ECDSA signature pair * @param s Half of the ECDSA signature pair */ function delegateBySig( address delegatee, uint nonce, uint expiry, uint8 v, bytes32 r, bytes32 s ) external { bytes32 domainSeparator = keccak256( abi.encode( DOMAIN_TYPEHASH, keccak256(bytes(name())), getChainId(), address(this) ) ); bytes32 structHash = keccak256( abi.encode( DELEGATION_TYPEHASH, delegatee, nonce, expiry ) ); bytes32 digest = keccak256( abi.encodePacked( "\x19\x01", domainSeparator, structHash ) ); address signatory = ecrecover(digest, v, r, s); require(signatory != address(0), "delegateBySig: invalid signature"); require(nonce == nonces[signatory]++, "delegateBySig: invalid nonce"); require(now <= expiry, "delegateBySig: signature expired"); return _delegate(signatory, delegatee); } /** * @notice Gets the current votes balance for `account` * @param account The address to get votes balance * @return The number of current votes for `account` */ function getCurrentVotes(address account) external view returns (uint256) { uint32 nCheckpoints = numCheckpoints[account]; return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0; } /** * @notice Determine the prior number of votes for an account as of a block number * @dev Block number must be a finalized block or else this function will revert to prevent misinformation. * @param account The address of the account to check * @param blockNumber The block number to get the vote balance at * @return The number of votes the account had as of the given block */ function getPriorVotes(address account, uint blockNumber) external view returns (uint256) { require(blockNumber < block.number, "getPriorVotes: not yet determined"); uint32 nCheckpoints = numCheckpoints[account]; if (nCheckpoints == 0) { return 0; } // First check most recent balance if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) { return checkpoints[account][nCheckpoints - 1].votes; } // Next check implicit zero balance if (checkpoints[account][0].fromBlock > blockNumber) { return 0; } uint32 lower = 0; uint32 upper = nCheckpoints - 1; while (upper > lower) { uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow Checkpoint memory cp = checkpoints[account][center]; if (cp.fromBlock == blockNumber) { return cp.votes; } else if (cp.fromBlock < blockNumber) { lower = center; } else { upper = center - 1; } } return checkpoints[account][lower].votes; } function _delegate(address delegator, address delegatee) internal { address currentDelegate = _delegates[delegator]; uint256 delegatorBalance = balanceOf(delegator); _delegates[delegator] = delegatee; emit DelegateChanged(delegator, currentDelegate, delegatee); _moveDelegates(currentDelegate, delegatee, delegatorBalance); } function _moveDelegates(address srcRep, address dstRep, uint256 amount) internal { if (srcRep != dstRep && amount > 0) { if (srcRep != address(0)) { // decrease old representative uint32 srcRepNum = numCheckpoints[srcRep]; uint256 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0; uint256 srcRepNew = srcRepOld.sub(amount); _writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew); } if (dstRep != address(0)) { // increase new representative uint32 dstRepNum = numCheckpoints[dstRep]; uint256 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0; uint256 dstRepNew = dstRepOld.add(amount); _writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew); } } } function _writeCheckpoint( address delegatee, uint32 nCheckpoints, uint256 oldVotes, uint256 newVotes ) internal { uint32 blockNumber = safe32(block.number, "_writeCheckpoint: block number exceeds 32 bits"); if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) { checkpoints[delegatee][nCheckpoints - 1].votes = newVotes; } else { checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes); numCheckpoints[delegatee] = nCheckpoints + 1; } emit DelegateVotesChanged(delegatee, oldVotes, newVotes); } function safe32(uint n, string memory errorMessage) internal pure returns (uint32) { require(n < 2**32, errorMessage); return uint32(n); } function getChainId() internal pure returns (uint) { uint256 chainId; assembly { chainId := chainid() } return chainId; } constructor() public { _mint(msg.sender, _initialSupply); _moveDelegates(address(0), msg.sender, _initialSupply); } }
IWannaSwapTreasury.sol
// SPDX-License-Identifier: MIT pragma solidity =0.6.12; interface IWannaSwapTreasury { event AddVolume(address indexed account, uint value); event ClaimReward(uint indexed bid, address indexed user, uint value); function refFeeTo(address _user) external view returns (address); function setProfile(address _profileAddress) external; function setRouter(address _routerAddress) external; function setRewardPerRound(uint _rewardPerRound) external; function addVolume(address _account, uint _vol) external; function changeTeam(address _user, uint _tid) external; function claimReward() external; }
Context.sol
// SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; import "../utils/Context.sol";
Ownable.sol
// SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; import "../utils/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. */ 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 () internal { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } /** * @dev Returns the address of the current owner. */ function owner() public view virtual 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; } }
SafeMath.sol
// SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.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, with an overflow flag. * * _Available since v3.4._ */ function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) { uint256 c = a + b; if (c < a) return (false, 0); return (true, c); } /** * @dev Returns the substraction of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b > a) return (false, 0); return (true, a - b); } /** * @dev Returns the multiplication of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryMul(uint256 a, uint256 b) internal pure returns (bool, 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 (true, 0); uint256 c = a * b; if (c / a != b) return (false, 0); return (true, c); } /** * @dev Returns the division of two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b == 0) return (false, 0); return (true, a / b); } /** * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b == 0) return (false, 0); return (true, a % b); } /** * @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) { require(b <= a, "SafeMath: subtraction overflow"); return a - b; } /** * @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) { 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, reverting 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) { require(b > 0, "SafeMath: division by zero"); return a / b; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting 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) { require(b > 0, "SafeMath: modulo by zero"); return a % b; } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {trySub}. * * 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); return a - b; } /** * @dev Returns the integer division of two unsigned integers, reverting with custom message on * division by zero. The result is rounded towards zero. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryDiv}. * * 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); return a / b; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting with custom message when dividing by zero. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryMod}. * * 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; } }
ERC20.sol
// SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; import "../../utils/Context.sol"; import "./IERC20.sol"; import "../../math/SafeMath.sol"; /** * @dev Implementation of the {IERC20} interface. * * This implementation is agnostic to the way tokens are created. This means * that a supply mechanism has to be added in a derived contract using {_mint}. * For a generic mechanism see {ERC20PresetMinterPauser}. * * TIP: For a detailed writeup see our guide * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How * to implement supply mechanisms]. * * We have followed general OpenZeppelin guidelines: functions revert instead * of returning `false` on failure. This behavior is nonetheless conventional * and does not conflict with the expectations of ERC20 applications. * * Additionally, an {Approval} event is emitted on calls to {transferFrom}. * This allows applications to reconstruct the allowance for all accounts just * by listening to said events. Other implementations of the EIP may not emit * these events, as it isn't required by the specification. * * Finally, the non-standard {decreaseAllowance} and {increaseAllowance} * functions have been added to mitigate the well-known issues around setting * allowances. See {IERC20-approve}. */ contract ERC20 is Context, IERC20 { using SafeMath for uint256; mapping (address => uint256) private _balances; mapping (address => mapping (address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; uint8 private _decimals; /** * @dev Sets the values for {name} and {symbol}, initializes {decimals} with * a default value of 18. * * To select a different value for {decimals}, use {_setupDecimals}. * * All three of these values are immutable: they can only be set once during * construction. */ constructor (string memory name_, string memory symbol_) public { _name = name_; _symbol = symbol_; _decimals = 18; } /** * @dev Returns the name of the token. */ function name() public view virtual returns (string memory) { return _name; } /** * @dev Returns the symbol of the token, usually a shorter version of the * name. */ function symbol() public view virtual 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 virtual returns (uint8) { return _decimals; } /** * @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: * * - `recipient` cannot be the zero address. * - the caller must have a balance of at least `amount`. */ function transfer(address recipient, uint256 amount) public virtual override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } /** * @dev See {IERC20-allowance}. */ function allowance(address owner, address spender) public view virtual override returns (uint256) { return _allowances[owner][spender]; } /** * @dev See {IERC20-approve}. * * Requirements: * * - `spender` cannot be the zero address. */ function approve(address spender, uint256 amount) public virtual override returns (bool) { _approve(_msgSender(), spender, amount); return true; } /** * @dev See {IERC20-transferFrom}. * * Emits an {Approval} event indicating the updated allowance. This is not * required by the EIP. See the note at the beginning of {ERC20}. * * Requirements: * * - `sender` and `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. * - the caller must have allowance for ``sender``'s tokens of at least * `amount`. */ function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } /** * @dev Atomically increases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. */ function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } /** * @dev Atomically decreases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. * - `spender` must have allowance for the caller of at least * `subtractedValue`. */ function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } /** * @dev Moves tokens `amount` from `sender` to `recipient`. * * This is internal function is equivalent to {transfer}, and can be used to * e.g. implement automatic token fees, slashing mechanisms, etc. * * Emits a {Transfer} event. * * Requirements: * * - `sender` cannot be the zero address. * - `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. */ function _transfer(address sender, address recipient, uint256 amount) internal virtual { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _beforeTokenTransfer(sender, recipient, amount); _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance"); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, amount); } /** @dev Creates `amount` tokens and assigns them to `account`, increasing * the total supply. * * Emits a {Transfer} event with `from` set to the zero address. * * Requirements: * * - `to` cannot be the zero address. */ function _mint(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: mint to the zero address"); _beforeTokenTransfer(address(0), account, amount); _totalSupply = _totalSupply.add(amount); _balances[account] = _balances[account].add(amount); emit Transfer(address(0), account, amount); } /** * @dev Destroys `amount` tokens from `account`, reducing the * total supply. * * Emits a {Transfer} event with `to` set to the zero address. * * Requirements: * * - `account` cannot be the zero address. * - `account` must have at least `amount` tokens. */ function _burn(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: burn from the zero address"); _beforeTokenTransfer(account, address(0), amount); _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance"); _totalSupply = _totalSupply.sub(amount); emit Transfer(account, address(0), amount); } /** * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens. * * This internal function is equivalent to `approve`, and can be used to * e.g. set automatic allowances for certain subsystems, etc. * * Emits an {Approval} event. * * Requirements: * * - `owner` cannot be the zero address. * - `spender` cannot be the zero address. */ function _approve(address owner, address spender, uint256 amount) internal virtual { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } /** * @dev Sets {decimals} to a value other than the default one of 18. * * WARNING: This function should only be called from the constructor. Most * applications that interact with token contracts will not expect * {decimals} to ever change, and may work incorrectly if it does. */ function _setupDecimals(uint8 decimals_) internal virtual { _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 { } }
IERC20.sol
// SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.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); }
SafeERC20.sol
// SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.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"); } } }
Address.sol
// SPDX-License-Identifier: MIT pragma solidity >=0.6.2 <0.8.0; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success, ) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain`call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: value }(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) { 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); } } } }
Context.sol
// SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <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 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; } }
Contract ABI
[{"type":"constructor","stateMutability":"nonpayable","inputs":[{"type":"address","name":"_wanna","internalType":"contract WannaSwapToken"},{"type":"uint256","name":"_totalWanna","internalType":"uint256"},{"type":"uint256","name":"_wannaPerBlock","internalType":"uint256"},{"type":"uint256","name":"_burnPercent","internalType":"uint256"}]},{"type":"event","name":"Deposit","inputs":[{"type":"address","name":"user","internalType":"address","indexed":true},{"type":"uint256","name":"pid","internalType":"uint256","indexed":true},{"type":"uint256","name":"amount","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"EmergencyWithdraw","inputs":[{"type":"address","name":"user","internalType":"address","indexed":true},{"type":"uint256","name":"pid","internalType":"uint256","indexed":true},{"type":"uint256","name":"amount","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"OwnershipTransferred","inputs":[{"type":"address","name":"previousOwner","internalType":"address","indexed":true},{"type":"address","name":"newOwner","internalType":"address","indexed":true}],"anonymous":false},{"type":"event","name":"Withdraw","inputs":[{"type":"address","name":"user","internalType":"address","indexed":true},{"type":"uint256","name":"pid","internalType":"uint256","indexed":true},{"type":"uint256","name":"amount","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"addPool","inputs":[{"type":"uint256","name":"_allocPoint","internalType":"uint256"},{"type":"address","name":"_lpToken","internalType":"contract IERC20"},{"type":"bool","name":"_withUpdate","internalType":"bool"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"","internalType":"address"}],"name":"burnAddress","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"burnPercent","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"burnWanna","internalType":"uint256"},{"type":"uint256","name":"farmWanna","internalType":"uint256"}],"name":"calculate","inputs":[{"type":"uint256","name":"_reward","internalType":"uint256"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"deposit","inputs":[{"type":"uint256","name":"_pid","internalType":"uint256"},{"type":"uint256","name":"_amount","internalType":"uint256"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"emergencyWithdraw","inputs":[{"type":"uint256","name":"_pid","internalType":"uint256"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"getBlockCount","inputs":[{"type":"uint256","name":"_from","internalType":"uint256"},{"type":"uint256","name":"_to","internalType":"uint256"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"mintedWanna","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"string","name":"","internalType":"string"}],"name":"name","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"","internalType":"address"}],"name":"owner","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"pendingWanna","inputs":[{"type":"uint256","name":"_pid","internalType":"uint256"},{"type":"address","name":"_user","internalType":"address"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"lpToken","internalType":"contract IERC20"},{"type":"uint256","name":"allocPoint","internalType":"uint256"},{"type":"uint256","name":"lastRewardBlock","internalType":"uint256"},{"type":"uint256","name":"accWannaPerShare","internalType":"uint256"},{"type":"uint256","name":"totalLp","internalType":"uint256"}],"name":"poolInfo","inputs":[{"type":"uint256","name":"","internalType":"uint256"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"poolLength","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"renounceOwnership","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"setEmissionRate","inputs":[{"type":"uint256","name":"_wannaPerBlock","internalType":"uint256"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"setPercent","inputs":[{"type":"uint256","name":"_burnPercent","internalType":"uint256"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"setPool","inputs":[{"type":"uint256","name":"_pid","internalType":"uint256"},{"type":"uint256","name":"_allocPoint","internalType":"uint256"},{"type":"bool","name":"_withUpdate","internalType":"bool"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"setTotalWanna","inputs":[{"type":"uint256","name":"_totalWanna","internalType":"uint256"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"startBlock","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"totalAllocPoint","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"totalWanna","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"transferOwnership","inputs":[{"type":"address","name":"newOwner","internalType":"address"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"updateAllPools","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"updatePool","inputs":[{"type":"uint256","name":"_pid","internalType":"uint256"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"amount","internalType":"uint256"},{"type":"uint256","name":"rewardDebt","internalType":"uint256"}],"name":"userInfo","inputs":[{"type":"uint256","name":"","internalType":"uint256"},{"type":"address","name":"","internalType":"address"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"","internalType":"contract WannaSwapToken"}],"name":"wanna","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"wannaPerBlock","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"withdraw","inputs":[{"type":"uint256","name":"_pid","internalType":"uint256"},{"type":"uint256","name":"_amount","internalType":"uint256"}]}]
Contract Creation Code
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
Deployed ByteCode
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