Address Details
contract
0x549b5cb2D324F901aEd6938a3838fB9b10898441
- Contract Name
- WannaFarm
- Creator
- 0x94a53e–900d50 at 0x4c9fdd–337805
- 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
- 7 Transactions
- Transfers
- 13 Transfers
- Gas Used
- 714,793
- Last Balance Update
- 9173214
Transactions
Token Transfers
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-05T11:38:44.737768Z
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; } 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 })); } 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); } 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.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; 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) private _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"}],"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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