My First crypto code

Hello Everyone, this is my first code and i searching for any kind of tip to make it better. If anyone want to make any suggestion i will be very grateful and one more thing, i have a little difficult to decide what is the best form to do a ICO. Someone have any experience on the matter?

address private _owner;
address private _previousOwner;
address payable public _charityWalletAddress;
address payable public _mktWalletAddress;
address payable public _devWalletAddress;

mapping (address => uint256) private _balances;
mapping (address => bool) private _isExcludedFromFee;
mapping (address => mapping(address => uint256)) private _allowances;

uint256 private _totalSupply = 1000000000*10**9;

//Marketing Fee = _mktFee/1000
//Charity Fee = _charityFee/1000
//Jujuba Team Development Fee = devFee/1000

uint256 public _mktFee = 0;
uint256 public _charityFee = 0;
uint256 public _devFee = 0;
uint256 private _totalFeeAmount;
uint256 private charityFeeAmount;
uint256 private mktFeeAmount;
uint256 private devFeeAmount;
uint256 public _tokenHavingsLimit;
uint256 private _possibleAmountTransfer;
uint256 public _totalBurnedLpTokens;

bool private _paused;

IPancakeswapV2Router02 public immutable PancakeswapV2Router;
address public immutable PancakeswapV2Pair;

constructor() ERC20(“Jujuba”, “JUJU”) {

_mint(_msgSender(), _totalSupply);

IPancakeswapV2Router02 _PancakeswapV2Router = IPancakeswapV2Router02(0xD99D1c33F9fC3444f8101754aBC46c52416550D1);
// Create a Pancakeswap pair for this new token
PancakeswapV2Pair = IPancakeswapV2Factory(_PancakeswapV2Router.factory())
.createPair(address(this), _PancakeswapV2Router.WETH());
// set the rest of the contract variables
PancakeswapV2Router = _PancakeswapV2Router;
//exclude owner and this contract from fee
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;

_paused = false;

_balances[_msgSender()] = _totalSupply;

// Exclude owner and this contract from fee
_isExcludedFromFee[_msgSender()] = true;
_isExcludedFromFee[address(this)] = true;

address msgSender = _msgSender();
_owner = msgSender; 

emit Transfer(address(0), address(this), _totalSupply);
emit OwnershipTransferred(address(0), msgSender);

}

modifier whenNotPaused() virtual override {
require(!paused(), "Pausable: paused");
_;

}

modifier whenPaused() virtual override {
require(paused(), “Pausable: not paused”);
_;
}

function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}

function _pause() public virtual override whenNotPaused onlyOwner {
_paused = true;
emit Paused(_msgSender());
}

function _unpause() public virtual override whenPaused onlyOwner {
_paused = false;
emit Unpaused(_msgSender());
}

function paused() public view virtual override returns (bool) {
return _paused;
}

function owner() public view override virtual returns (address) {
return _owner;
}

modifier onlyOwner() virtual override{
require(owner() == _msgSender(), “Ownable: caller is not the owner”);
_;
}

function renounceOwnership() public override virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}

function transferOwnership(address newOwner) public override virtual onlyOwner {
require(newOwner != address(0), “Ownable: new owner is the zero address”);
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}

function currentCharityFee() public view returns (uint256) {
return _charityFee;
}

function currentmktFee() public view returns (uint256) {
return _mktFee;
}

function currentdevFee() public view returns (uint256) {
return _devFee;
}

function balanceOf(address account) public view virtual override returns(uint256) {
return _balances[account];
}

function _transfer(address recipient, uint256 amount) public whenNotPaused returns (bool success) {
require(balanceOf(_msgSender()) >= amount, ‘balance is too low’);
require(_getPossibleAmountTransfer(_tokenHavingsLimit, recipient) >= amount, ‘amount makes balance surpass the limit’);
if(_isExcludedFromFee[_msgSender()] && _isExcludedFromFee[recipient]) {
_balances[recipient] += amount;
_balances[_msgSender()] -= amount;
emit Transfer(_msgSender(), recipient, amount);
return true;

  } else if(!_isExcludedFromFee[_msgSender()] || !_isExcludedFromFee[recipient]) {
    _totalFeeAmount = _getFeesAmount(amount, _charityFee, _mktFee, _devFee);
    uint256 amountToTransfer = amount.sub(_totalFeeAmount);
    _balances[recipient] += amountToTransfer;
    _balances[_msgSender()] -= amount;
    _transferToFeeWallet();
 emit Transfer(_msgSender(), recipient, amountToTransfer);
 return true;
 }

}

function increaseAllowance(address sender, uint256 addedAmount) public override returns (bool) {
_approve(_msgSender(), sender, _allowances[_msgSender()][sender] + addedAmount);
return true;
}

function decreaseAllowance(address sender, uint256 subtractedAmount) public override returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][sender];
require(currentAllowance >= subtractedAmount, "Jujuba: decreased allowance below zero");
_approve(_msgSender(), sender, currentAllowance - subtractedAmount);

return true;
}

function transferFrom(address sender, address recipient, uint256 amount) public whenNotPaused override returns (bool succeess) {


uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "Jujuba: Transfer amount exceeds allowance");
require(balanceOf(sender) >= amount, 'balance is too low');
require(_getPossibleAmountTransfer(_tokenHavingsLimit, recipient) >= amount, 'amount makes balance surpass the limit');
if(_isExcludedFromFee[_msgSender()] && _isExcludedFromFee[recipient]) {
    _balances[recipient] += amount;
    _balances[sender] -= amount;
emit Transfer(sender, recipient, amount);
return true;

} else if(!_isExcludedFromFee[_msgSender()] || !_isExcludedFromFee[recipient]) {
    _totalFeeAmount = _getFeesAmount(amount, _charityFee, _mktFee, _devFee);
    uint256 amountToTransfer = amount.sub(_totalFeeAmount);
    _balances[recipient] += amountToTransfer;
    _balances[sender] -= amount;
    _transferToFeeWallet();
    _approve(sender, _msgSender(), currentAllowance - amount);
 emit Transfer(sender, recipient, amountToTransfer);
 return true;

    }
   }

function approve(address spender, uint256 amount) public override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
 }


function _approve(address sender, address spender, uint256 amount) internal virtual override {
require(sender != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");

_allowances[sender][spender] = amount;
emit Approval(sender, spender, amount);
}

function setExcludeFromFee(address account, bool) external onlyOwner() {
    _isExcludedFromFee[account] = true;
}

function isExcludedFromFee(address account) public view returns(bool) {
    return _isExcludedFromFee[account];
}

 function _setCharityFee(uint256 charityFee) external onlyOwner() {
require(charityFee >= 0 && charityFee <= 10, "CharityFee should be in 0 - 10 range");
    _charityFee = charityFee;
}

function _setCharityWallet(address payable charityWalletAddress) external onlyOwner() {
    _charityWalletAddress = charityWalletAddress;
}

function _setMktFee(uint256 mktFee) external onlyOwner() {
require(mktFee >= 0 && mktFee <= 10, "MktFee should be in 0 - 10 range");
    _mktFee = mktFee;
}

function _setMktWallet(address payable mktWalletAddress) external onlyOwner() {
    _mktWalletAddress = mktWalletAddress;
}

function _setDevFee(uint256 devFee) external onlyOwner() {
require(devFee >= 0 && devFee <= 10, "DevFee should be in 0 - 10 range");
    _devFee = devFee;
}

function _setDevWallet(address payable devWalletAddress) external onlyOwner() {
    _devWalletAddress = devWalletAddress;
}

function _setTokenHavingsLimit(uint256 tokenHavingsLimit) external onlyOwner() {
    _tokenHavingsLimit = tokenHavingsLimit;
}

function _getFeesAmount(uint256 amount, uint256 charityFee, uint256 mktFee, uint256 devFee) private returns(uint256) {
 charityFeeAmount = amount.mul(charityFee).div(1000);
mktFeeAmount = amount.mul(mktFee).div(1000);
devFeeAmount = amount.mul(devFee).div(1000);
_totalFeeAmount = _totalFeeAmount.add(charityFeeAmount).add(mktFeeAmount).add(devFeeAmount);
return (_totalFeeAmount);
 }

 function _getPossibleAmountTransfer(uint256 tokenHavingsLimit, address recipient) private returns(uint256) {
 _possibleAmountTransfer = tokenHavingsLimit.sub(_balances[recipient]);
return (_possibleAmountTransfer);
}

function _transferToFeeWallet() private returns (bool) {
_balances[_charityWalletAddress] += charityFeeAmount;
_balances[_mktWalletAddress] += mktFeeAmount;
_balances[_devWalletAddress] += devFeeAmount;
return true;
}

receive() external payable {}
 }

Hi @iMenozzi,

This appears to me as more of an ad-hoc support question and is hence off topic for this forum.

→ For urgent Solidity support questions, please use the Solidity Gitter/Matrix chat or consider checking out the Ethereum StackExchange.

Please check the welcome message before posting, it has all the relevant information. :slight_smile:

Closing this topic now.