{{ "language": "Solidity", "sources": { "src/contracts/BasketballToken.sol": { "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.5;\n\nimport \"@openzeppelin/contracts/token/ERC20/ERC20.sol\";\nimport \"@openzeppelin/contracts/utils/Strings.sol\";\n\nimport \"./Authorized.sol\";\nimport \"./IPancake.sol\";\nimport \"./SwapHelper.sol\";\n\ncontract BasketballToken is Authorized, ERC20 {\n address constant DEAD = 0x000000000000000000000000000000000000dEaD;\n address constant ZERO = 0x0000000000000000000000000000000000000000;\n address constant BUSD = 0xe9e7CEA3DedcA5984780Bafc599bD69ADd087D56;\n address constant WBNB = 0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c;\n\n string constant _name = \"BASKETBALL LEGENDS\";\n string constant _symbol = \"BBL\";\n\n // Token supply control\n uint8 constant decimal = 18;\n uint8 constant decimalBUSD = 18; \n uint256 constant maxSupply = 48_000_000 * (10 ** decimal);\n \n uint256 public _maxTxAmount = maxSupply / 1200; // 40_000\n uint256 public _maxAccountAmount = maxSupply / 400; // 120_000\n \n uint256 public totalBurned;\n\n // Fees\n uint256 public feeAdministrationWallet = 400; // 4%\n uint256 public feeDevWallet = 600; // 6%\n\n uint256 public feePool = 100; // 2%\n\n bool internal pausedStake = false;\n\n // special wallet permissions\n mapping (address => bool) public exemptOperatePausedToken;\n mapping (address => bool) public exemptFee;\n mapping (address => bool) public exemptFeeReceiver;\n mapping (address => bool) public exemptTxLimit;\n mapping (address => bool) public exemptAmountLimit;\n mapping (address => bool) public exemptStaker;\n\n // trading pairs\n address public liquidityPool;\n\n address public administrationWallet;\n\n address public devWallet;\n\n SwapHelper private swapHelper;\n\n address WBNB_BUSD_PAIR = 0x58F876857a02D6762E0101bb5C46A8c1ED44Dc16;\n address WBNB_BBL_PAIR;\n\n bool private _noReentrancy = false;\n bool internal pausedToken = false;\n\n function getOwner() external view returns (address) { return owner(); }\n\n function enableToken() external isAuthorized(0) { pausedToken = false; }\n\n function getFeeTotal() public view returns(uint256) { return feePool + feeAdministrationWallet + feeDevWallet; }\n\n function togglePauseStake(bool pauseState) external isAuthorized(0) { pausedStake = pauseState; }\n\n function getSwapHelperAddress() external view returns (address) { return address(swapHelper); }\n\n function setFeesPool(uint256 pool) external isAuthorized(1) {\n require(pool + feeAdministrationWallet + feeDevWallet < 1500, \"Maximum total fee is fixed on 15%\");\n feePool = pool;\n }\n\n function setFeesDirectWallet(uint256 administration) external isAuthorized(1) {\n require(feePool + administration + feeDevWallet < 1500, \"Maximum total fee is fixed on 15%\");\n feeAdministrationWallet = administration;\n }\n\n function setFeeDevWallet(uint256 devFee) external isAuthorized(1) {\n require(feePool + feeAdministrationWallet + devFee < 1500, \"Maximum total fee is fixed on 15%\");\n feeDevWallet = devFee;\n }\n\n function setDevWallet(address wallet) public isAuthorized(0) {\n devWallet = wallet;\n }\n\n function setMaxTxAmountWithDecimals(uint256 decimalAmount) public isAuthorized(1) {\n require(decimalAmount <= maxSupply, \"Amount is bigger then maximum supply token\");\n _maxTxAmount = decimalAmount;\n }\n\n function setMaxTxAmount(uint256 amount) external isAuthorized(1) { setMaxTxAmountWithDecimals(amount * (10 ** decimal)); }\n\n function setMaxAccountAmountWithDecimals(uint256 decimalAmount) public isAuthorized(1) {\n require(decimalAmount <= maxSupply, \"Amount is bigger then maximum supply token\");\n _maxAccountAmount = decimalAmount;\n }\n\n function setMaxAccountAmount(uint256 amount) external isAuthorized(1) { setMaxAccountAmountWithDecimals(amount * (10 ** decimal)); }\n\n // Excempt Controllers\n function setExemptOperatePausedToken(address account, bool operation) public isAuthorized(0) {exemptOperatePausedToken[account] = operation; }\n function setExemptFee(address account, bool operation) public isAuthorized(2) { exemptFee[account] = operation; }\n function setExemptFeeReceiver(address account, bool operation) public isAuthorized(2) { exemptFeeReceiver[account] = operation; }\n function setExemptTxLimit(address account, bool operation) public isAuthorized(2) { exemptTxLimit[account] = operation; }\n function setExemptAmountLimit(address account, bool operation) public isAuthorized(2) { exemptAmountLimit[account] = operation; }\n function setExemptStaker(address account, bool operation) public isAuthorized(2) { exemptStaker[account] = operation; }\n\n // Special Wallets\n function setAdministrationWallet(address account) public isAuthorized(0) { administrationWallet = account; }\n \n receive() external payable { }\n\n constructor()ERC20(_name, _symbol) {\n PancakeRouter router = PancakeRouter(0x10ED43C718714eb63d5aA57B78B54704E256024E);\n WBNB_BBL_PAIR = address(PancakeFactory(router.factory()).createPair(WBNB, address(this)));\n liquidityPool = WBNB_BBL_PAIR;\n\n // Liquidity pair\n exemptAmountLimit[WBNB_BBL_PAIR] = true;\n exemptTxLimit[WBNB_BBL_PAIR] = true;\n exemptStaker[WBNB_BBL_PAIR] = true;\n \n // Token address\n exemptFee[address(this)] = true;\n exemptTxLimit[address(this)] = true;\n exemptAmountLimit[address(this)] = true;\n exemptStaker[address(this)] = true;\n\n // DEAD Waller\n exemptTxLimit[DEAD] = true;\n exemptAmountLimit[DEAD] = true;\n exemptStaker[DEAD] = true;\n exemptFee[DEAD] = true;\n\n // Zero Waller\n exemptTxLimit[ZERO] = true;\n exemptAmountLimit[ZERO] = true;\n exemptStaker[ZERO] = true;\n\n //Owner wallet\n address ownerWallet = _msgSender();\n exemptFee[ownerWallet] = true;\n exemptTxLimit[ownerWallet] = true;\n exemptAmountLimit[ownerWallet] = true;\n exemptStaker[ownerWallet] = true;\n exemptOperatePausedToken[ownerWallet] = true;\n\n devWallet = 0xAFbA5af54B9D0914b7B7709C46FdF13Fe5937E4E;\n administrationWallet = 0xc4c7e6Ba1b4627f943e05f8C771a5786CDd3aeFe;\n\n exemptFee[administrationWallet] = true;\n exemptTxLimit[administrationWallet] = true;\n exemptAmountLimit[administrationWallet] = true;\n\n swapHelper = new SwapHelper();\n swapHelper.safeApprove(WBNB, address(this), type(uint256).max);\n\n _mint(ownerWallet, maxSupply);\n\n feeAdministrationWallet = 9100;\n pausedToken = true;\n }\n\n function burn(uint256 amount) external {\n _burn(_msgSender(), amount);\n totalBurned += amount;\n }\n\n function decimals() public view override returns (uint8) { \n return decimal;\n }\n\n function _beforeTokenTransfer( address from, address, uint256 amount ) internal view override {\n require(amount <= _maxTxAmount || exemptTxLimit[from], \"Excedded the maximum transaction limit\");\n require(!pausedToken || exemptOperatePausedToken[from], \"Token is paused\");\n }\n\n function _afterTokenTransfer( address, address to, uint256 ) internal view override {\n require(_balances[to] <= _maxAccountAmount || exemptAmountLimit[to], \"Excedded the maximum tokens that an wallet can hold\");\n }\n\n function _transfer( address sender, address recipient,uint256 amount ) internal override {\n require(!_noReentrancy, \"ReentrancyGuard: reentrant call happens\");\n _noReentrancy = true;\n \n require(sender != address(0) && recipient != address(0), \"transfer from the zero address\");\n \n _beforeTokenTransfer(sender, recipient, amount);\n\n uint256 senderBalance = _balances[sender];\n require(senderBalance >= amount, \"transfer amount exceeds your balance\");\n uint256 newSenderBalance = senderBalance - amount;\n _balances[sender] = newSenderBalance;\n\n uint256 feeAmount = 0;\n if (!exemptFee[sender] && !exemptFeeReceiver[recipient]) feeAmount = (getFeeTotal() * amount) / 10000;\n\n exchangeFeeParts(feeAmount);\n uint256 newRecipentAmount = _balances[recipient] + (amount - feeAmount);\n _balances[recipient] = newRecipentAmount;\n\n _afterTokenTransfer(sender, recipient, amount);\n\n _noReentrancy = false;\n emit Transfer(sender, recipient, amount);\n }\n\n function exchangeFeeParts(uint256 incomingFeeTokenAmount) private returns (bool){\n if (incomingFeeTokenAmount == 0) return false;\n _balances[address(this)] += incomingFeeTokenAmount;\n \n address pairWbnbBbl = WBNB_BBL_PAIR;\n if (_msgSender() == pairWbnbBbl || pausedStake) return false;\n uint256 feeTokenAmount = _balances[address(this)];\n _balances[address(this)] = 0;\n\n // Gas optimization\n address wbnbAddress = WBNB;\n (uint112 reserve0, uint112 reserve1) = getTokenReserves(pairWbnbBbl);\n bool reversed = isReversed(pairWbnbBbl, wbnbAddress);\n if (reversed) { uint112 temp = reserve0; reserve0 = reserve1; reserve1 = temp; }\n _balances[pairWbnbBbl] += feeTokenAmount;\n address swapHelperAddress = address(swapHelper);\n uint256 wbnbBalanceBefore = getTokenBalanceOf(wbnbAddress, swapHelperAddress);\n \n uint256 wbnbAmount = getAmountOut(feeTokenAmount, reserve1, reserve0);\n swapToken(pairWbnbBbl, reversed ? 0 : wbnbAmount, reversed ? wbnbAmount : 0, swapHelperAddress);\n uint256 wbnbBalanceNew = getTokenBalanceOf(wbnbAddress, swapHelperAddress); \n require(wbnbBalanceNew == wbnbBalanceBefore + wbnbAmount, \"Wrong amount of swapped on WBNB\");\n // Deep Stack problem avoid\n {\n // Gas optimization\n address busdAddress = BUSD;\n address pairWbnbBusd = WBNB_BUSD_PAIR;\n (reserve0, reserve1) = getTokenReserves(pairWbnbBusd);\n reversed = isReversed(pairWbnbBusd, wbnbAddress);\n if (reversed) { uint112 temp = reserve0; reserve0 = reserve1; reserve1 = temp; }\n\n uint256 busdBalanceBefore = getTokenBalanceOf(busdAddress, address(this));\n tokenTransferFrom(wbnbAddress, swapHelperAddress, pairWbnbBusd, wbnbAmount);\n uint256 busdAmount = getAmountOut(wbnbAmount, reserve0, reserve1);\n swapToken(pairWbnbBusd, reversed ? busdAmount : 0, reversed ? 0 : busdAmount, address(this));\n uint256 busdBalanceNew = getTokenBalanceOf(busdAddress, address(this));\n require(busdBalanceNew == busdBalanceBefore + busdAmount, \"Wrong amount swapped on BUSD\");\n if (feeAdministrationWallet > 0) tokenTransfer(busdAddress, administrationWallet, (busdAmount * feeAdministrationWallet) / getFeeTotal());\n if (feeDevWallet > 0) tokenTransfer(busdAddress, devWallet, (busdAmount * feeDevWallet) / getFeeTotal());\n }\n return true;\n }\n\n function buyBackAndHold(uint256 amount, address receiver) external isAuthorized(3) { buyBackAndHoldWithDecimals(amount * (10 ** decimalBUSD), receiver); }\n\n function buyBackAndHoldWithDecimals(uint256 decimalAmount, address receiver) public isAuthorized(3) { buyBackWithDecimals(decimalAmount, receiver); }\n\n function buyBackAndBurn(uint256 amount) external isAuthorized(3) { buyBackAndBurnWithDecimals(amount * (10 ** decimalBUSD)); }\n\n function buyBackAndBurnWithDecimals(uint256 decimalAmount) public isAuthorized(3) { buyBackWithDecimals(decimalAmount, address(0)); }\n\n function buyBackWithDecimals(uint256 decimalAmount, address destAddress) private {\n uint256 maxBalance = getTokenBalanceOf(BUSD, address(this));\n if (maxBalance < decimalAmount) revert(string(abi.encodePacked(\"insufficient BUSD amount[\", Strings.toString(decimalAmount), \"] on contract[\", Strings.toString(maxBalance), \"]\")));\n\n (uint112 reserve0,uint112 reserve1) = getTokenReserves(WBNB_BUSD_PAIR);\n bool reversed = isReversed(WBNB_BUSD_PAIR, BUSD);\n if (reversed) { uint112 temp = reserve0; reserve0 = reserve1; reserve1 = temp; }\n\n tokenTransfer(BUSD, WBNB_BUSD_PAIR, decimalAmount);\n uint256 wbnbAmount = getAmountOut(decimalAmount, reserve0, reserve1);\n swapToken(WBNB_BUSD_PAIR, reversed ? wbnbAmount : 0, reversed ? 0 : wbnbAmount, address(this));\n\n bool previousExemptFeeState = exemptFee[WBNB_BBL_PAIR];\n exemptFee[WBNB_BBL_PAIR] = true;\n \n address pairWbnbBbl = WBNB_BBL_PAIR;\n address swapHelperAddress = address(swapHelper);\n (reserve0, reserve1) = getTokenReserves(pairWbnbBbl);\n reversed = isReversed(pairWbnbBbl, WBNB);\n if (reversed) { uint112 temp = reserve0; reserve0 = reserve1; reserve1 = temp; }\n\n tokenTransfer(WBNB, pairWbnbBbl, wbnbAmount);\n \n uint256 bblAmount = getAmountOut(wbnbAmount, reserve0, reserve1);\n if (destAddress == address(0)) {\n swapToken(pairWbnbBbl, reversed ? bblAmount : 0, reversed ? 0 : bblAmount, swapHelperAddress);\n _burn(swapHelperAddress, bblAmount);\n totalBurned += bblAmount;\n } else {\n swapToken(pairWbnbBbl, reversed ? bblAmount : 0, reversed ? 0 : bblAmount, destAddress);\n }\n exemptFee[WBNB_BBL_PAIR] = previousExemptFeeState;\n }\n \n function getAmountOut(uint256 amountIn, uint256 reserveIn, uint256 reserveOut) internal pure returns (uint256 amountOut) {\n require(amountIn > 0, 'Insufficient amount in');\n require(reserveIn > 0 && reserveOut > 0, 'Insufficient liquidity');\n uint256 amountInWithFee = amountIn * 9975;\n uint256 numerator = amountInWithFee * reserveOut;\n uint256 denominator = (reserveIn * 10000) + amountInWithFee;\n amountOut = numerator / denominator;\n }\n\n // gas optimization on get Token0 from a pair liquidity pool\n function isReversed(address pair, address tokenA) internal view returns (bool) {\n address token0;\n bool failed = false;\n assembly {\n let emptyPointer := mload(0x40)\n mstore(emptyPointer, 0x0dfe168100000000000000000000000000000000000000000000000000000000)\n failed := iszero(staticcall(gas(), pair, emptyPointer, 0x04, emptyPointer, 0x20))\n token0 := mload(emptyPointer)\n }\n if (failed) revert(string(abi.encodePacked(\"Unable to check direction of token \", Strings.toHexString(uint160(tokenA), 20) ,\" from pair \", Strings.toHexString(uint160(pair), 20))));\n return token0 != tokenA;\n }\n\n // gas optimization on transfer token\n function tokenTransfer(address token, address recipient, uint256 amount) internal {\n bool failed = false;\n assembly {\n let emptyPointer := mload(0x40)\n mstore(emptyPointer, 0xa9059cbb00000000000000000000000000000000000000000000000000000000)\n mstore(add(emptyPointer, 0x04), recipient)\n mstore(add(emptyPointer, 0x24), amount)\n failed := iszero(call(gas(), token, 0, emptyPointer, 0x44, 0, 0))\n }\n if (failed) revert(string(abi.encodePacked(\"Unable to transfer \", Strings.toString(amount), \" of token [\", Strings.toHexString(uint160(token), 20) ,\"] to address \", Strings.toHexString(uint160(recipient), 20))));\n }\n\n // gas optimization on transfer from token method\n function tokenTransferFrom(address token, address from, address recipient, uint256 amount) internal {\n bool failed = false;\n assembly {\n let emptyPointer := mload(0x40)\n mstore(emptyPointer, 0x23b872dd00000000000000000000000000000000000000000000000000000000)\n mstore(add(emptyPointer, 0x04), from)\n mstore(add(emptyPointer, 0x24), recipient)\n mstore(add(emptyPointer, 0x44), amount)\n failed := iszero(call(gas(), token, 0, emptyPointer, 0x64, 0, 0)) \n }\n if (failed) revert(string(abi.encodePacked(\"Unable to transfer from [\", Strings.toHexString(uint160(from), 20) ,\"] \", Strings.toString(amount), \" of token [\", Strings.toHexString(uint160(token), 20) ,\"] to address \", Strings.toHexString(uint160(recipient), 20))));\n }\n\n // gas optimization on swap operation using a liquidity pool\n function swapToken(address pair, uint amount0Out, uint amount1Out, address receiver) internal {\n bool failed = false;\n assembly {\n let emptyPointer := mload(0x40)\n mstore(emptyPointer, 0x022c0d9f00000000000000000000000000000000000000000000000000000000)\n mstore(add(emptyPointer, 0x04), amount0Out)\n mstore(add(emptyPointer, 0x24), amount1Out)\n mstore(add(emptyPointer, 0x44), receiver)\n mstore(add(emptyPointer, 0x64), 0x80)\n mstore(add(emptyPointer, 0x84), 0)\n failed := iszero(call(gas(), pair, 0, emptyPointer, 0xa4, 0, 0))\n }\n if (failed) revert(string(abi.encodePacked(\"Unable to swap \", Strings.toString(amount0Out == 0 ? amount1Out : amount0Out), \" on Pain [\", Strings.toHexString(uint160(pair), 20) ,\"] to receiver \", Strings.toHexString(uint160(receiver), 20) )));\n }\n\n // gas optimization on get balanceOf fron BEP20 or ERC20 token\n function getTokenBalanceOf(address token, address holder) internal view returns (uint112 tokenBalance) {\n bool failed = false;\n assembly {\n let emptyPointer := mload(0x40)\n mstore(emptyPointer, 0x70a0823100000000000000000000000000000000000000000000000000000000)\n mstore(add(emptyPointer, 0x04), holder)\n failed := iszero(staticcall(gas(), token, emptyPointer, 0x24, emptyPointer, 0x40))\n tokenBalance := mload(emptyPointer)\n }\n if (failed) revert(string(abi.encodePacked(\"Unable to get balance from wallet [\", Strings.toHexString(uint160(holder), 20) ,\"] of token [\", Strings.toHexString(uint160(token), 20) ,\"] \")));\n }\n\n // gas optimization on get reserves from liquidity pool\n function getTokenReserves(address pairAddress) internal view returns (uint112 reserve0, uint112 reserve1) {\n bool failed = false;\n assembly {\n let emptyPointer := mload(0x40)\n mstore(emptyPointer, 0x0902f1ac00000000000000000000000000000000000000000000000000000000)\n failed := iszero(staticcall(gas(), pairAddress, emptyPointer, 0x4, emptyPointer, 0x40))\n reserve0 := mload(emptyPointer)\n reserve1 := mload(add(emptyPointer, 0x20))\n }\n if (failed) revert(string(abi.encodePacked(\"Unable to get reserves from pair [\", Strings.toHexString(uint160(pairAddress), 20), \"]\")));\n }\n\n function walletHolder(address account) private view returns (address holder) {\n return exemptStaker[account] ? address(0x00) : account;\n }\n\n function setWBNB_BBL_PAIR(address newPair) external isAuthorized(0) { WBNB_BBL_PAIR = newPair; }\n function setWBNB_BUSD_Pair(address newPair) external isAuthorized(0) { WBNB_BUSD_PAIR = newPair; }\n function getWBNB_BBL_PAIR() external view returns(address) { return WBNB_BBL_PAIR; }\n function getWBNB_BUSD_Pair() external view returns(address) { return WBNB_BUSD_PAIR; }\n\n}\n" }, "@openzeppelin/contracts/token/ERC20/ERC20.sol": { "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"./IERC20.sol\";\nimport \"./extensions/IERC20Metadata.sol\";\nimport \"../../utils/Context.sol\";\n\n/**\n * @dev Implementation of the {IERC20} interface.\n *\n * This implementation is agnostic to the way tokens are created. This means\n * that a supply mechanism has to be added in a derived contract using {_mint}.\n * For a generic mechanism see {ERC20PresetMinterPauser}.\n *\n * TIP: For a detailed writeup see our guide\n * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How\n * to implement supply mechanisms].\n *\n * We have followed general OpenZeppelin Contracts guidelines: functions revert\n * instead returning `false` on failure. This behavior is nonetheless\n * conventional and does not conflict with the expectations of ERC20\n * applications.\n *\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\n * This allows applications to reconstruct the allowance for all accounts just\n * by listening to said events. Other implementations of the EIP may not emit\n * these events, as it isn't required by the specification.\n *\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\n * functions have been added to mitigate the well-known issues around setting\n * allowances. See {IERC20-approve}.\n */\ncontract ERC20 is Context, IERC20, IERC20Metadata {\n mapping(address => uint256) internal _balances;\n\n mapping(address => mapping(address => uint256)) private _allowances;\n\n uint256 private _totalSupply;\n\n string private _name;\n string private _symbol;\n\n /**\n * @dev Sets the values for {name} and {symbol}.\n *\n * The default value of {decimals} is 18. To select a different value for\n * {decimals} you should overload it.\n *\n * All two of these values are immutable: they can only be set once during\n * construction.\n */\n constructor(string memory name_, string memory symbol_) {\n _name = name_;\n _symbol = symbol_;\n }\n\n /**\n * @dev Returns the name of the token.\n */\n function name() public view virtual override returns (string memory) {\n return _name;\n }\n\n /**\n * @dev Returns the symbol of the token, usually a shorter version of the\n * name.\n */\n function symbol() public view virtual override returns (string memory) {\n return _symbol;\n }\n\n /**\n * @dev Returns the number of decimals used to get its user representation.\n * For example, if `decimals` equals `2`, a balance of `505` tokens should\n * be displayed to a user as `5.05` (`505 / 10 ** 2`).\n *\n * Tokens usually opt for a value of 18, imitating the relationship between\n * Ether and Wei. This is the value {ERC20} uses, unless this function is\n * overridden;\n *\n * NOTE: This information is only used for _display_ purposes: it in\n * no way affects any of the arithmetic of the contract, including\n * {IERC20-balanceOf} and {IERC20-transfer}.\n */\n function decimals() public view virtual override returns (uint8) {\n return 18;\n }\n\n /**\n * @dev See {IERC20-totalSupply}.\n */\n function totalSupply() public view virtual override returns (uint256) {\n return _totalSupply;\n }\n\n /**\n * @dev See {IERC20-balanceOf}.\n */\n function balanceOf(address account) public view virtual override returns (uint256) {\n return _balances[account];\n }\n\n /**\n * @dev See {IERC20-transfer}.\n *\n * Requirements:\n *\n * - `recipient` cannot be the zero address.\n * - the caller must have a balance of at least `amount`.\n */\n function transfer(address recipient, uint256 amount) public virtual override returns (bool) {\n _transfer(_msgSender(), recipient, amount);\n return true;\n }\n\n /**\n * @dev See {IERC20-allowance}.\n */\n function allowance(address owner, address spender) public view virtual override returns (uint256) {\n return _allowances[owner][spender];\n }\n\n /**\n * @dev See {IERC20-approve}.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n */\n function approve(address spender, uint256 amount) public virtual override returns (bool) {\n _approve(_msgSender(), spender, amount);\n return true;\n }\n\n /**\n * @dev See {IERC20-transferFrom}.\n *\n * Emits an {Approval} event indicating the updated allowance. This is not\n * required by the EIP. See the note at the beginning of {ERC20}.\n *\n * Requirements:\n *\n * - `sender` and `recipient` cannot be the zero address.\n * - `sender` must have a balance of at least `amount`.\n * - the caller must have allowance for ``sender``'s tokens of at least\n * `amount`.\n */\n function transferFrom(\n address sender,\n address recipient,\n uint256 amount\n ) public virtual override returns (bool) {\n _transfer(sender, recipient, amount);\n\n uint256 currentAllowance = _allowances[sender][_msgSender()];\n require(currentAllowance >= amount, \"ERC20: transfer amount exceeds allowance\");\n unchecked {\n _approve(sender, _msgSender(), currentAllowance - amount);\n }\n\n return true;\n }\n\n /**\n * @dev Atomically increases the allowance granted to `spender` by the caller.\n *\n * This is an alternative to {approve} that can be used as a mitigation for\n * problems described in {IERC20-approve}.\n *\n * Emits an {Approval} event indicating the updated allowance.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n */\n function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\n _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);\n return true;\n }\n\n /**\n * @dev Atomically decreases the allowance granted to `spender` by the caller.\n *\n * This is an alternative to {approve} that can be used as a mitigation for\n * problems described in {IERC20-approve}.\n *\n * Emits an {Approval} event indicating the updated allowance.\n *\n * Requirements:\n *\n * - `spender` cannot be the zero address.\n * - `spender` must have allowance for the caller of at least\n * `subtractedValue`.\n */\n function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\n uint256 currentAllowance = _allowances[_msgSender()][spender];\n require(currentAllowance >= subtractedValue, \"ERC20: decreased allowance below zero\");\n unchecked {\n _approve(_msgSender(), spender, currentAllowance - subtractedValue);\n }\n\n return true;\n }\n\n /**\n * @dev Moves `amount` of tokens from `sender` to `recipient`.\n *\n * This internal function is equivalent to {transfer}, and can be used to\n * e.g. implement automatic token fees, slashing mechanisms, etc.\n *\n * Emits a {Transfer} event.\n *\n * Requirements:\n *\n * - `sender` cannot be the zero address.\n * - `recipient` cannot be the zero address.\n * - `sender` must have a balance of at least `amount`.\n */\n function _transfer(\n address sender,\n address recipient,\n uint256 amount\n ) internal virtual {\n require(sender != address(0), \"ERC20: transfer from the zero address\");\n require(recipient != address(0), \"ERC20: transfer to the zero address\");\n\n _beforeTokenTransfer(sender, recipient, amount);\n\n uint256 senderBalance = _balances[sender];\n require(senderBalance >= amount, \"ERC20: transfer amount exceeds balance\");\n unchecked {\n _balances[sender] = senderBalance - amount;\n }\n _balances[recipient] += amount;\n\n emit Transfer(sender, recipient, amount);\n\n _afterTokenTransfer(sender, recipient, amount);\n }\n\n /** @dev Creates `amount` tokens and assigns them to `account`, increasing\n * the total supply.\n *\n * Emits a {Transfer} event with `from` set to the zero address.\n *\n * Requirements:\n *\n * - `account` cannot be the zero address.\n */\n function _mint(address account, uint256 amount) internal virtual {\n require(account != address(0), \"ERC20: mint to the zero address\");\n\n _beforeTokenTransfer(address(0), account, amount);\n\n _totalSupply += amount;\n _balances[account] += amount;\n emit Transfer(address(0), account, amount);\n\n _afterTokenTransfer(address(0), account, amount);\n }\n\n /**\n * @dev Destroys `amount` tokens from `account`, reducing the\n * total supply.\n *\n * Emits a {Transfer} event with `to` set to the zero address.\n *\n * Requirements:\n *\n * - `account` cannot be the zero address.\n * - `account` must have at least `amount` tokens.\n */\n function _burn(address account, uint256 amount) internal virtual {\n require(account != address(0), \"ERC20: burn from the zero address\");\n\n _beforeTokenTransfer(account, address(0), amount);\n\n uint256 accountBalance = _balances[account];\n require(accountBalance >= amount, \"ERC20: burn amount exceeds balance\");\n unchecked {\n _balances[account] = accountBalance - amount;\n }\n _totalSupply -= amount;\n\n emit Transfer(account, address(0), amount);\n\n _afterTokenTransfer(account, address(0), amount);\n }\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\n *\n * This internal function is equivalent to `approve`, and can be used to\n * e.g. set automatic allowances for certain subsystems, etc.\n *\n * Emits an {Approval} event.\n *\n * Requirements:\n *\n * - `owner` cannot be the zero address.\n * - `spender` cannot be the zero address.\n */\n function _approve(\n address owner,\n address spender,\n uint256 amount\n ) internal virtual {\n require(owner != address(0), \"ERC20: approve from the zero address\");\n require(spender != address(0), \"ERC20: approve to the zero address\");\n\n _allowances[owner][spender] = amount;\n emit Approval(owner, spender, amount);\n }\n\n /**\n * @dev Hook that is called before any transfer of tokens. This includes\n * minting and burning.\n *\n * Calling conditions:\n *\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n * will be transferred to `to`.\n * - when `from` is zero, `amount` tokens will be minted for `to`.\n * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\n * - `from` and `to` are never both zero.\n *\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n */\n function _beforeTokenTransfer(\n address from,\n address to,\n uint256 amount\n ) internal virtual {}\n\n /**\n * @dev Hook that is called after any transfer of tokens. This includes\n * minting and burning.\n *\n * Calling conditions:\n *\n * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n * has been transferred to `to`.\n * - when `from` is zero, `amount` tokens have been minted for `to`.\n * - when `to` is zero, `amount` of ``from``'s tokens have been burned.\n * - `from` and `to` are never both zero.\n *\n * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n */\n function _afterTokenTransfer(\n address from,\n address to,\n uint256 amount\n ) internal virtual {}\n}\n" }, "@openzeppelin/contracts/utils/Strings.sol": { "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev String operations.\n */\nlibrary Strings {\n bytes16 private constant _HEX_SYMBOLS = \"0123456789abcdef\";\n\n /**\n * @dev Converts a `uint256` to its ASCII `string` decimal representation.\n */\n function toString(uint256 value) internal pure returns (string memory) {\n // Inspired by OraclizeAPI's implementation - MIT licence\n // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol\n\n if (value == 0) {\n return \"0\";\n }\n uint256 temp = value;\n uint256 digits;\n while (temp != 0) {\n digits++;\n temp /= 10;\n }\n bytes memory buffer = new bytes(digits);\n while (value != 0) {\n digits -= 1;\n buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));\n value /= 10;\n }\n return string(buffer);\n }\n\n /**\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\n */\n function toHexString(uint256 value) internal pure returns (string memory) {\n if (value == 0) {\n return \"0x00\";\n }\n uint256 temp = value;\n uint256 length = 0;\n while (temp != 0) {\n length++;\n temp >>= 8;\n }\n return toHexString(value, length);\n }\n\n /**\n * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\n */\n function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\n bytes memory buffer = new bytes(2 * length + 2);\n buffer[0] = \"0\";\n buffer[1] = \"x\";\n for (uint256 i = 2 * length + 1; i > 1; --i) {\n buffer[i] = _HEX_SYMBOLS[value & 0xf];\n value >>= 4;\n }\n require(value == 0, \"Strings: hex length insufficient\");\n return string(buffer);\n }\n}\n" }, "src/contracts/Authorized.sol": { "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.5;\n\nimport \"@openzeppelin/contracts/access/Ownable.sol\";\nimport \"@openzeppelin/contracts/utils/Strings.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/ERC20.sol\";\n\ncontract Authorized is Ownable {\n mapping(uint8 => mapping(address => bool)) public permissions;\n string[] public permissionIndex;\n\n constructor() {\n permissionIndex.push(\"admin\");\n permissionIndex.push(\"financial\");\n permissionIndex.push(\"controller\");\n permissionIndex.push(\"operator\");\n\n permissions[0][_msgSender()] = true;\n }\n\n modifier isAuthorized(uint8 index) {\n if (!permissions[index][_msgSender()]) {\n revert(string(abi.encodePacked(\"Account \",Strings.toHexString(uint160(_msgSender()), 20),\" does not have \", permissionIndex[index], \" permission\")));\n }\n _;\n }\n\n function safeApprove(address token, address spender, uint256 amount) external isAuthorized(0) {\n ERC20(token).approve(spender, amount);\n }\n\n function safeWithdraw() external isAuthorized(0) {\n uint256 contractBalance = address(this).balance;\n payable(_msgSender()).transfer(contractBalance);\n }\n\n function grantPermission(address operator, uint8[] memory grantedPermissions) external isAuthorized(0) {\n for (uint8 i = 0; i < grantedPermissions.length; i++) permissions[grantedPermissions[i]][operator] = true;\n }\n\n function revokePermission(address operator, uint8[] memory revokedPermissions) external isAuthorized(0) {\n for (uint8 i = 0; i < revokedPermissions.length; i++) permissions[revokedPermissions[i]][operator] = false;\n }\n\n function grantAllPermissions(address operator) external isAuthorized(0) {\n for (uint8 i = 0; i < permissionIndex.length; i++) permissions[i][operator] = true;\n }\n\n function revokeAllPermissions(address operator) external isAuthorized(0) {\n for (uint8 i = 0; i < permissionIndex.length; i++) permissions[i][operator] = false;\n }\n\n}" }, "src/contracts/IPancake.sol": { "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.5;\ninterface PancakeFactory {\n function createPair(address tokenA, address tokenB) external returns (address pair);\n}\n\ninterface PancakeRouter {\n function factory() external pure returns (address);\n}\n" }, "src/contracts/SwapHelper.sol": { "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.5;\n\nimport \"@openzeppelin/contracts/access/Ownable.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/ERC20.sol\";\n\ncontract SwapHelper is Ownable {\n constructor() {}\n\n function safeApprove(address token, address spender, uint256 amount) external onlyOwner { ERC20(token).approve(spender, amount); }\n\n function safeWithdraw() external onlyOwner { payable(_msgSender()).transfer(address(this).balance); }\n}" }, "@openzeppelin/contracts/token/ERC20/IERC20.sol": { "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20 {\n /**\n * @dev Returns the amount of tokens in existence.\n */\n function totalSupply() external view returns (uint256);\n\n /**\n * @dev Returns the amount of tokens owned by `account`.\n */\n function balanceOf(address account) external view returns (uint256);\n\n /**\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transfer(address recipient, uint256 amount) external returns (bool);\n\n /**\n * @dev Returns the remaining number of tokens that `spender` will be\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\n * zero by default.\n *\n * This value changes when {approve} or {transferFrom} are called.\n */\n function allowance(address owner, address spender) external view returns (uint256);\n\n /**\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\n * that someone may use both the old and the new allowance by unfortunate\n * transaction ordering. One possible solution to mitigate this race\n * condition is to first reduce the spender's allowance to 0 and set the\n * desired value afterwards:\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n *\n * Emits an {Approval} event.\n */\n function approve(address spender, uint256 amount) external returns (bool);\n\n /**\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\n * allowance mechanism. `amount` is then deducted from the caller's\n * allowance.\n *\n * Returns a boolean value indicating whether the operation succeeded.\n *\n * Emits a {Transfer} event.\n */\n function transferFrom(\n address sender,\n address recipient,\n uint256 amount\n ) external returns (bool);\n\n /**\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\n * another (`to`).\n *\n * Note that `value` may be zero.\n */\n event Transfer(address indexed from, address indexed to, uint256 value);\n\n /**\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n * a call to {approve}. `value` is the new allowance.\n */\n event Approval(address indexed owner, address indexed spender, uint256 value);\n}\n" }, "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol": { "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20.sol\";\n\n/**\n * @dev Interface for the optional metadata functions from the ERC20 standard.\n *\n * _Available since v4.1._\n */\ninterface IERC20Metadata is IERC20 {\n /**\n * @dev Returns the name of the token.\n */\n function name() external view returns (string memory);\n\n /**\n * @dev Returns the symbol of the token.\n */\n function symbol() external view returns (string memory);\n\n /**\n * @dev Returns the decimals places of the token.\n */\n function decimals() external view returns (uint8);\n}\n" }, "@openzeppelin/contracts/utils/Context.sol": { "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n function _msgSender() internal view virtual returns (address) {\n return msg.sender;\n }\n\n function _msgData() internal view virtual returns (bytes calldata) {\n return msg.data;\n }\n}\n" }, "@openzeppelin/contracts/access/Ownable.sol": { "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../utils/Context.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract Ownable is Context {\n address private _owner;\n\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n /**\n * @dev Initializes the contract setting the deployer as the initial owner.\n */\n constructor() {\n _setOwner(_msgSender());\n }\n\n /**\n * @dev Returns the address of the current owner.\n */\n function owner() public view virtual returns (address) {\n return _owner;\n }\n\n /**\n * @dev Throws if called by any account other than the owner.\n */\n modifier onlyOwner() {\n require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n _;\n }\n\n /**\n * @dev Leaves the contract without owner. It will not be possible to call\n * `onlyOwner` functions anymore. Can only be called by the current owner.\n *\n * NOTE: Renouncing ownership will leave the contract without an owner,\n * thereby removing any functionality that is only available to the owner.\n */\n function renounceOwnership() public virtual onlyOwner {\n _setOwner(address(0));\n }\n\n /**\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\n * Can only be called by the current owner.\n */\n function transferOwnership(address newOwner) public virtual onlyOwner {\n require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n _setOwner(newOwner);\n }\n\n function _setOwner(address newOwner) private {\n address oldOwner = _owner;\n _owner = newOwner;\n emit OwnershipTransferred(oldOwner, newOwner);\n }\n}\n" } }, "settings": { "optimizer": { "enabled": true, "runs": 9999 }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "abi" ] } }, "libraries": {} } }}

Basketball Legends

Start building on QuickNode

Source code: