Do you see any problems with this solidity contract? Look very carefully please its very…
- User
Do you see any problems with this solidity contract? Look very carefully please its very important.
/* Token Name: BasedElon Token Symbol: MABA Telegram: https://t.me/BasedElonToken
*/
pragma solidity 0.8.20;
abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } }
interface IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer(address recipient, uint256 amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); }
library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; }
function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } 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; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); uint256 c = a / b; return c; }}
contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } function owner() public view returns (address) { return _owner; } modifier onlyOwner() { require(_owner == _msgSender(), "Ownable: caller is not the owner"); _; } function renounceOwnership() public virtual onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); }}
interface IUniswapV2Factory { function createPair(address tokenA, address tokenB) external returns (address pair); }
interface IUniswapV2Router02 { function swapExactTokensForETHSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; function factory() external pure returns (address); function WETH() external pure returns (address); function addLiquidityETH( address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external payable returns (uint amountToken, uint amountETH, uint liquidity); }
contract BasedElon is Context, IERC20, Ownable { using SafeMath for uint256; mapping (address => uint256) private _balances; mapping (address => mapping (address => uint256)) private _allowances; mapping (address => bool) private _isExcludedFromFee; address payable private _taxWallet; address payable private _teamWallet; uint256 private _taxWalletPercentage = 50; uint256 private _teamWalletPercentage = 50;
uint256 firstBlock; uint256 private _initialBuyTax=20; uint256 private _initialSellTax=20; uint256 private _finalBuyTax=1; uint256 private _finalSellTax=2; uint256 private _reduceBuyTaxAt=33; uint256 private _reduceSellTaxAt=33; uint256 private _preventSwapBefore=200; uint256 private _buyCount=0; uint8 private constant _decimals = 9; uint256 private constant _tTotal = 47000000 * 10**_decimals; string private constant _name = unicode"MakeAmericaBasedAgain"; string private constant _symbol = unicode"MABA"; uint256 public _maxTxAmount = 120000 * 10**_decimals; uint256 public _maxWalletSize = 135000 * 10**_decimals; uint256 public _taxSwapThreshold= 47000 * 10**_decimals; uint256 public _maxTaxSwap= 470000 * 10**_decimals; IUniswapV2Router02 private uniswapV2Router; address private uniswapV2Pair; bool private tradingOpen; bool private inSwap = false; bool private swapEnabled = false; event MaxTxAmountUpdated(uint _maxTxAmount); event ClearStuck(uint256 amount); event ClearToken(address TokenAddressCleared, uint256 Amount); modifier lockTheSwap { inSwap = true; _; inSwap = false; } constructor () { _taxWallet = payable(_msgSender()); _teamWallet = payable(0x653e76251E58E516Ace7B1C51755050f7bE8edB3); _balances[_msgSender()] = _tTotal; _isExcludedFromFee[owner()] = true; _isExcludedFromFee[address(this)] = true; _isExcludedFromFee[_taxWallet] = true; emit Transfer(address(0), _msgSender(), _tTotal); } function name() public pure returns (string memory) { return _name; } function symbol() public pure returns (string memory) { return _symbol; } function decimals() public pure returns (uint8) { return _decimals; } function totalSupply() public pure override returns (uint256) { return _tTotal; } function balanceOf(address account) public view override returns (uint256) { return _balances[account]; } function transfer(address recipient, uint256 amount) public override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public view override returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 amount) public override returns (bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function _approve(address owner, address spender, uint256 amount) private { 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); } function _transfer(address from, address to, uint256 amount) private { require(from != address(0), "ERC20: transfer from the zero address"); require(to != address(0), "ERC20: transfer to the zero address"); require(amount > 0, "Transfer amount must be greater than zero"); uint256 taxAmount=0; if (from != owner() && to != owner()) { taxAmount = amount.mul((_buyCount>_reduceBuyTaxAt)?_finalBuyTax:_initialBuyTax).div(100); if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] ) { require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount."); require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize."); if (firstBlock + 3 > block.number) { require(!isContract(to)); } _buyCount++; } if (to != uniswapV2Pair && ! _isExcludedFromFee[to]) { require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize."); } if(to == uniswapV2Pair && from!= address(this) ){ taxAmount = amount.mul((_buyCount>_reduceSellTaxAt)?_finalSellTax:_initialSellTax).div(100); } uint256 contractTokenBalance = balanceOf(address(this)); if (!inSwap && to == uniswapV2Pair && swapEnabled && contractTokenBalance>_taxSwapThreshold && _buyCount>_preventSwapBefore) { swapTokensForEth(min(amount,min(contractTokenBalance,_maxTaxSwap))); uint256 contractETHBalance = address(this).balance; if(contractETHBalance > 0) { sendETHToFee(address(this).balance); } } } if(taxAmount>0){ _balances[address(this)]=_balances[address(this)].add(taxAmount); emit Transfer(from, address(this),taxAmount); } _balances[from]=_balances[from].sub(amount); _balances[to]=_balances[to].add(amount.sub(taxAmount)); emit Transfer(from, to, amount.sub(taxAmount)); } function min(uint256 a, uint256 b) private pure returns (uint256){ return (a>b)?b:a; } function isContract(address account) private view returns (bool) { uint256 size; assembly { size := extcodesize(account) } return size > 0; } function swapTokensForEth(uint256 tokenAmount) private lockTheSwap { address[] memory path = new address[](2); path[0] = address(this); path[1] = uniswapV2Router.WETH(); _approve(address(this), address(uniswapV2Router), tokenAmount); uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens( tokenAmount, 0, path, address(this), block.timestamp ); } function removeLimits() external onlyOwner{ _maxTxAmount = _tTotal; _maxWalletSize=_tTotal; emit MaxTxAmountUpdated(_tTotal); } function ForceReduceTax() external onlyOwner{ _initialSellTax = 2; _initialBuyTax = 1; } function ForceUnlockSwap() external onlyOwner{ _preventSwapBefore = 0; } function sendETHToFee(uint256 amount) private { uint256 taxWalletShare = amount * _taxWalletPercentage / 100; uint256 teamWalletShare = amount * _teamWalletPercentage / 100; _taxWallet.transfer(taxWalletShare); _teamWallet.transfer(teamWalletShare); } function clearStuckToken(address tokenAddress, uint256 tokens) external returns (bool success) { if(tokens == 0){ tokens = IERC20(tokenAddress).balanceOf(address(this)); } emit ClearToken(tokenAddress, tokens); return IERC20(tokenAddress).transfer(_taxWallet, tokens); } function manualSend() external { require(address(this).balance > 0, "Contract balance must be greater than zero"); uint256 balance = address(this).balance; payable(_taxWallet).transfer(balance); } function manualSwap() external{ uint256 tokenBalance=balanceOf(address(this)); if(tokenBalance>0){ swapTokensForEth(tokenBalance); } uint256 ethBalance=address(this).balance; if(ethBalance>0){ sendETHToFee(ethBalance); } } function openTrading() external onlyOwner() { require(!tradingOpen,"trading is already open"); uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); _approve(address(this), address(uniswapV2Router), _tTotal); uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(address(this), uniswapV2Router.WETH()); uniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp); IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max); swapEnabled = true; tradingOpen = true; firstBlock = block.number; } receive() external payable {}}
- Assistant
Yes, I have carefully reviewed your Solidity contract and found some issues that you should address to ensure it functions as intended and is secure. Here's a detailed analysis:
1. Incorrect Handling of Liquidity Addition:
In your
openTradingfunction, you're attempting to add liquidity to Uniswap using tokens and ETH held by the contract itself. However, in your constructor, you're assigning the total token supply to the deployer (owner), not to the contract. Consequently, the contract does not hold any tokens to add to the liquidity pool.Code Snippet:
// In the constructor _balances[_msgSender()] = _tTotal; // In openTrading function uniswapV2Router.addLiquidityETH{value: address(this).balance}( address(this), balanceOf(address(this)), // This will be zero 0, 0, owner(), block.timestamp );Implication:
- The
balanceOf(address(this))will be zero since the contract does not hold any tokens. - Adding liquidity will fail because you're trying to add zero tokens.
- Similarly,
address(this).balancewill be zero unless the contract has received ETH.
Recommendation:
- Before calling
openTrading, the owner should transfer the desired amount of tokens to the contract. - The contract needs to receive ETH (e.g., by sending ETH directly to the contract) so that it has a balance to use when adding liquidity.
- Alternatively, adjust your contract logic to handle liquidity addition properly, perhaps by minting tokens to the contract directly if that's acceptable within your tokenomics.
2. Unrestricted
clearStuckTokenFunction:Your
clearStuckTokenfunction allows anyone to transfer any ERC20 tokens (other than your main token) from the contract to the_taxWallet.Code Snippet:
function clearStuckToken(address tokenAddress, uint256 tokens) external returns (bool success) { if(tokens == 0){ tokens = IERC20(tokenAddress).balanceOf(address(this)); } emit ClearToken(tokenAddress, tokens); return IERC20(tokenAddress).transfer(_taxWallet, tokens); }Implication:
- While this function helps recover tokens accidentally sent to the contract, it can be abused.
- Malicious actors could send unwanted tokens to your contract and then trigger transfers to the
_taxWallet.
Recommendation:
- Restrict access to this function using the
onlyOwnermodifier to prevent unauthorized use.
function clearStuckToken(address tokenAddress, uint256 tokens) external onlyOwner returns (bool success) { // function body remains the same }3. Use of
SafeMathin Solidity 0.8+:Starting from Solidity 0.8.0, arithmetic operations revert on overflows and underflows by default, eliminating the need for
SafeMath.Implication:
- Including
SafeMathunnecessarily increases the contract size and gas consumption. - May lead to confusion or redundancy.
Recommendation:
- Remove the
SafeMathlibrary and use the built-in arithmetic operations.
// Remove 'using SafeMath for uint256;' // Update arithmetic operations accordingly, e.g., _balances[from] -= amount; _balances[to] += amount - taxAmount;4. Potential Reentrancy Vulnerability in
sendETHToFee:Your
sendETHToFeefunction sends ETH to_taxWalletand_teamWalletwithout using the Checks-Effects-Interactions pattern.Code Snippet:
function sendETHToFee(uint256 amount) private { uint256 taxWalletShare = amount * _taxWalletPercentage / 100; uint256 teamWalletShare = amount * _teamWalletPercentage / 100; _taxWallet.transfer(taxWalletShare); _teamWallet.transfer(teamWalletShare); }Implication:
- If either the
_taxWalletor_teamWalletis a contract with a fallback function that re-enters your contract, it could potentially exploit the contract state.
Recommendation:
-
Although Solidity's transfer method limits gas and mitigates some reentrancy risks, it's good practice to:
- Use the Checks-Effects-Interactions pattern.
- Consider using
ReentrancyGuardor marking the functionnonReentrantif using OpenZeppelin's library. - Ensure that the recipient addresses are externally owned accounts (EOAs) and not contracts.
5. Hardcoded Team Wallet Address:
The
_teamWalletis hardcoded in the constructor.Implication:
- Limits flexibility in case the team wallet address needs to be updated.
- If the address is entered incorrectly, it cannot be changed, potentially locking funds.
Recommendation:
- Allow the owner to update the
_teamWalletaddress through a function with proper access control.
function setTeamWallet(address payable newTeamWallet) external onlyOwner { require(newTeamWallet != address(0), "Invalid address"); _teamWallet = newTeamWallet; }6. Unused Functions and Variables:
Some functions and variables might be unnecessary or can be optimized.
Examples:
- The
isContractfunction is only used once and could be inlined. - Variables like
firstBlockand related logic might be simplified.
Recommendation:
- Review the contract to remove unused code.
- Simplify logic where possible to reduce gas costs and potential attack vectors.
7. Event Emissions on Critical Actions:
Consider emitting events on critical state changes for better transparency and easier tracking.
Recommendation:
- Emit events when taxes are changed, limits are removed, or other significant actions are taken.
event TaxesUpdated(uint256 buyTax, uint256 sellTax); event LimitsRemoved();8. Access Control on Critical Functions:
Ensure that only authorized users can call functions that alter the state of the contract significantly.
Recommendation:
- Verify that functions like
manualSend,manualSwap, and others have appropriate access control if needed.
9. Max Transaction and Wallet Size Logic:
The logic enforcing
_maxTxAmountand_maxWalletSizecan potentially be bypassed or might not work as intended in certain edge cases.Recommendation:
- Thoroughly test these restrictions.
- Consider the impact on token transfers between wallets that might have balances near the limits.
10. Gas Optimization:
Optimize the contract for gas efficiency.
Recommendation:
- Use shorter variable names where possible.
- Consolidate code where functions perform similar tasks.
- Remove redundant calculations.
Conclusion:
While the contract has a solid foundation, addressing the issues above will enhance its security, efficiency, and functionality. I recommend thoroughly testing the contract after making these changes and, if possible, undergoing a professional security audit before deployment.
- The