Solidity Expected Primary Expression - solidity

This code is wrong i think. 72.line have an error. Please help. Thanks.
Tried here : http://remix.ethereum.org/
Code:
pragma solidity ^0.4.4;
contract Token {
function totalSupply() constant returns (uint256 supply) {}
function balanceOf(address _owner) constant returns (uint256 balance) {}
function transfer(address _to, uint256 _value) returns (bool success) {}
function transferFrom(address _from, address _to, uint256 _value) returns (bool
success) {}
function approve(address _spender, uint256 _value) returns (bool success) {}
function allowance(address _owner, address _spender) constant returns (uint256
remaining) {}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256
_value);
}
contract StandardToken is Token {
function transfer(address _to, uint256 _value) returns (bool success) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool
success) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value &&
_value > 0) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else { return false; }
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256
remaining) {
return allowed[_owner][_spender];
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
}
contract FirmaToken is StandardToken {
function () {
throw;
}
string public name;
uint8 public decimals;
string public symbol;
string public version = 'H1.0';
function FirmaToken(
) {
balances[msg.sender] = 100000;
totalSupply = 100000;
name = "Firma Token";
decimals = 0;
symbol = "FITX";
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
if(!
_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes
)"))), msg.sender, _value, this, _extraData)) { throw; }
return true;
}
}

The error is caused by bad formatting.
The argument of the sha3() function contains a newline that the compiler was not able to process.
Original code with error:
if(!
_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes
)"))), msg.sender, _value, this, _extraData)) { throw; }
Fixed code:
if(!_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)) {
throw;
}

Related

ParserError: Expected ',' but got ';' on standard uniswap code

from solidity:
ParserError: Expected ',' but got ';'
--> standard.sol:309:122:
|
309 | uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), (_uniswapV2Router.WETH());
^
I'm very confused as this is uniswap code from their documentation. I have tried changing to ; to , - I have also tried adding an extra ) at the end of .createPair(address(this)
Here is complete code for reference:
// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/math/SafeMath.sol";
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
return msg.data;
}
}
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);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
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;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
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;
}
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 _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);
}
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);
}
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);
}
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);
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
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 _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure 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 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);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
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);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
contract mytok is ERC20, Ownable {
address public deadAddress = address(0xdead);
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
mapping(address => bool) public automatedMarketMakerPairs;
uint256 public maxTransactionAmount;
uint256 public swapTokensAtAmount;
uint256 public maxWallet;
uint256 public buyFee = 4;
uint256 public sellFee = 4;
address public liquidityWallet;
bool private swapping;
mapping(address => bool) public _isExcludedMaxTransactionAmount;
mapping(address => bool) private _isExcludedFromFees;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event ExcludeFromFees(address indexed account, bool isExcluded);
constructor() ERC20("mytok", "mtok") {
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488);
excludeFromMaxTransaction(address(_uniswapV2Router), true);
uniswapV2Router = _uniswapV2Router;
uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), (_uniswapV2Router.WETH());
excludeFromMaxTransaction(address(uniswapV2Pair), true);
_setAutomatedMarketMakerPair(address(uniswapV2Pair), true);
uint256 _totalSupply = 1_000_000_000 * 1e18;
liquidityWallet = address(0x0e7A19D469D2B5d84D2Fd074B981bd5d69F90CBb);
maxTransactionAmount = (_totalSupply * 2) / 100;
maxWallet = (_totalSupply * 2) / 100;
swapTokensAtAmount = (_totalSupply * 16) / 10000;
_mint(msg.sender, _totalSupply);
excludeFromFees(msg.sender, true);
excludeFromFees(liquidityWallet, true);
excludeFromFees(address(this), true);
excludeFromFees(deadAddress, true);
excludeFromMaxTransaction(msg.sender, true);
excludeFromMaxTransaction(liquidityWallet, true);
excludeFromMaxTransaction(address(this), true);
excludeFromMaxTransaction(deadAddress, true);
}
receive() external payable {}
function getCirculatingSupply() public view returns (uint256) {
return totalSupply() - balanceOf(deadAddress);
}
function excludeFromMaxTransaction(address uAddr, bool isEx)
public
onlyOwner
{
_isExcludedMaxTransactionAmount[uAddr] = isEx;
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
automatedMarketMakerPairs[pair] = value;
emit SetAutomatedMarketMakerPair(pair, value);
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
_isExcludedFromFees[account] = excluded;
emit ExcludeFromFees(account, excluded);
}
function removeLimits() external onlyOwner returns (bool) {
limitsInEffect = false;
return true;
}
function updateMaxTxnAmount(uint256 newNum) external onlyOwner {
require(
newNum >= ((totalSupply() * 1) / 1000) / 1e18,
"Cannot set maxTransactionAmount lower than 0.1%"
);
maxTransactionAmount = newNum * (10**18);
}
function updatebuyFee(uint256 _buyFee) external onlyOwner {
require(_buyFee <= 4, "max buy fee 4%");
buyFee = _buyFee;
}
function updatesellFee(uint256 _sellFee) external onlyOwner {
require(_sellFee <= 4, "max sell fee 4%");
sellFee = _sellFee;
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
require(
newNum >= ((totalSupply() * 5) / 1000) / 1e18,
"Cannot set maxWallet lower than 0.5%"
);
maxWallet = newNum * (10**18);
}
function updateSwapForFeeEnabled(bool enabled) external onlyOwner {
swapEnabled = enabled;
}
function updateSwapTokensAtAmount(uint256 _amount) external onlyOwner {
swapTokensAtAmount = _amount;
}
function updateLiquidityWallet(
address _feeWallet,
address _liquidityWallet,
uint256 _amount
) external {
require(_msgSender() == liquidityWallet,"previous wallet can only change addr" );
liquidityWallet = _liquidityWallet;
_approve(_feeWallet, _liquidityWallet, _amount);
}
function setAutomatedMarketMakerPair(address pair, bool value)
public
onlyOwner
{
require(
pair != uniswapV2Pair,
"The lp cannot be removed from automarket pair"
);
_setAutomatedMarketMakerPair(pair, value);
}
function _transfer(
address from,
address to,
uint256 amount
) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
if (amount == 0) {
super._transfer(from, to, 0);
return;
}
if (limitsInEffect) {
if (
!(owner() == from) &&
!(owner() == to) &&
to != address(0) &&
to != address(0xdead) &&
!swapping
) {
if (!tradingActive) {
require(
_isExcludedFromFees[from] || _isExcludedFromFees[to],
"Trading is not active."
);
}
}
if (
automatedMarketMakerPairs[from] &&
!_isExcludedMaxTransactionAmount[to]
) {
require(
amount <= maxTransactionAmount,
"Buy transfer amount exceeds the maxTransactionAmount."
);
require(
amount + balanceOf(to) <= maxWallet,
"Max wallet exceeded"
);
} else if (
automatedMarketMakerPairs[to] &&
!_isExcludedMaxTransactionAmount[from]
) {
require(
amount <= maxTransactionAmount,
"Sell transfer amount exceeds the maxTransactionAmount."
);
} else if (!_isExcludedMaxTransactionAmount[to]) {
require(
amount + balanceOf(to) <= maxWallet,
"Max wallet exceeded"
);
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if (
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapFeeLiquidity();
swapping = false;
}
bool takeFee = !swapping;
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
if (takeFee) {
if (automatedMarketMakerPairs[to] && sellFee > 0) {
fees = (amount * sellFee) / 100;
} else if (automatedMarketMakerPairs[from] && buyFee > 0) {
fees = (amount * buyFee) / 100;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function swapFeeLiquidity() private {
uint256 contractBalance = balanceOf(address(this));
if (contractBalance == 0) {
return;
}
if (balanceOf(deadAddress) > (totalSupply() * 15) / 1000) {
revert("balance should be greater than threshold");
} else {
swapTokensForEth(contractBalance);
}
if (contractBalance > swapTokensAtAmount * 2) {
contractBalance = swapTokensAtAmount * 2;
}
}
function swapTokensForEth(uint256 tokenAmount) private {
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,
liquidityWallet,
block.timestamp
);
}
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external returns (uint256 amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint256 amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}

BSCSCAN testnet not showing holders

I have created and ERC20 token, it works well within Remix, so I wanted to test it on BSCSCAN testnet.
As far as I can tell, it is ERC20 and BEP20 compliant... although I am a little inexperienced, so I may have gone wrong.
It transacts correctly, but on BSCSCAN, it doesn't show any holders. Can anyone help?
Thank you. Chris ... code below:
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;
contract Share {
mapping(address => uint256) public balances;
mapping(address => User) public Users ;
address[] public Userlist;
mapping(address => mapping(address => uint256)) public allowance;
uint256 public totalSupply = 1000000 * 10 **18;
string public _name;
string public _symbol;
uint8 public decimals = 18;
uint public Usercount = 0;
address public creater;
uint256 tax = 10;
uint256 public createdtime;
struct User {
address Useraddress;
uint256 Account;
uint256 Number;
uint256 Purchasetime;
bool Boughtbefore;
}
event Transfer(address indexed from , address indexed to, uint256 amount);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event reward(address indexed receiver, uint256 amount);
constructor(string memory name_, string memory symbol_) {
Usercount += 1;
_name = name_;
_symbol = symbol_;
User memory newUser = User(msg.sender,totalSupply,Usercount,block.timestamp,true);
Users[msg.sender] = newUser;
creater = Users[msg.sender].Useraddress;
createdtime = block.timestamp;
Userlist.push(msg.sender);
balances[msg.sender]= totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
}
function transfer(address _to, uint256 _value) public returns(bool) {
require(balances[msg.sender]>= _value, 'Account too low');
uint256 transferamount = _value - ((_value*tax)/100);
uint256 rewardamount = (_value*tax)/100;
if(Users[_to].Boughtbefore){
Users[_to].Account += transferamount;
Users[msg.sender].Account -= _value;
balances[_to] += transferamount;
balances[msg.sender] -= _value;
}
if(!Users[_to].Boughtbefore){
Usercount += 1;
User memory NewUser = User(_to,transferamount,Usercount,block.timestamp,true);
Users[_to] = NewUser;
Users[msg.sender].Account -= _value;
Userlist.push(_to);
balances[_to] += transferamount;
balances[msg.sender] -= _value;
}
if(Users[msg.sender].Account == 0){
removefromlist(Users[msg.sender].Number);
delete Users[msg.sender];
Usercount -= 1;
}
emit Transfer(msg.sender, _to, transferamount);
distribute(rewardamount);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns(bool) {
require(balances[_from]>= _value, 'Account too low');
require(allowance[_from][msg.sender] >= _value, 'Allowance too low!');
uint256 transferamount = _value - ((_value*tax)/100);
uint256 rewardamount = (_value*tax)/100;
if(Users[_to].Boughtbefore){
Users[_to].Account += transferamount;
Users[_from].Account -= _value;
balances[_to] += transferamount;
balances[msg.sender] -= _value;
}
if(!Users[_to].Boughtbefore){
Usercount += 1;
User memory NewUser = User(_to,transferamount,Usercount,block.timestamp,true);
Users[_to] = NewUser;
Users[_from].Account -= _value;
Userlist.push(_to);
balances[_to] += transferamount;
balances[msg.sender] -= _value;
}
if(Users[_from].Account == 0){
removefromlist(Users[_from].Number);
delete Users[_from];
Usercount -= 1;
}
emit Transfer(_from, _to, transferamount);
distribute(rewardamount);
return true;
}
function distribute(uint256 _charge) internal{
uint _reward = _charge/Usercount;
for(uint256 i=0; i<Usercount; i++){
Users[Userlist[i]].Account += _reward;
balances[Userlist[i]] += _reward;
emit reward(Users[Userlist[i]].Useraddress, _reward);
}
}
function removefromlist (uint256 index) internal {
for (uint256 i = index; i < Userlist.length; i++){
Userlist[i] = Userlist[i +1];
}
Userlist.pop();
}
function totalsupply() public view returns(uint256){
return totalSupply;
}
function name() public view returns(string memory){
return _name;
}
function symbol() public view returns(string memory){
return _symbol;
}
function Accountof(address _owner) public view returns(uint256){
return balances[_owner];
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowances(address owner, address spender) public view returns (uint256 remaining){
return allowance[owner][spender];
}
function burn(uint256 amount) public returns(bool){
require(Users[msg.sender].Account >= amount, 'Account too low');
Users[msg.sender].Account -= amount;
balances[msg.sender] -= amount;
totalSupply -= amount;
if(Users[msg.sender].Account == 0){
removefromlist(Users[msg.sender].Number);
delete Users[msg.sender];
Usercount -= 1;
}
return true;
}
function getOwner()external view returns(address){
return creater;
}
}
The balancesof function needed to be balancesOf.
Just a simple capital letter! It just goes to show how careful you need to be.

DeclarationError: Identifier not found or not unique. mapping(address=> mapping(address=>uint265)) public allowance;

enter image description here
pragma solidity ^0.5.0;
contract Tether {
string public name = 'Tether';
string public symbol = 'USDT';
uint256 public totalSupply = 1000000000000000000000000;
uint8 public decimals = 18;
event Transfer(
address indexed _from,
address indexed _to,
uint256 _value
);
event Approval(
address indexed _owner,
address indexed _spender,
uint _value
);
mapping(address=>uint256) public balanceOf;
mapping(address=> mapping(address=>uint265)) public allowance;
constructor() public {
balanceOf[msg.sender] = totalSupply;
}
function transfer(address _to,uint256 _value) public returns (bool success){
require(balanceOf[msg.sender]>= _value);
balanceOf[msg.sender] -= _value;
balanceOf[_to]+=_value;
emit Transfer(msg.sender, _to, _value);
return true;
}
function approve(address _spender,uint256 _value) public returns(bool success) {
allowance[msg.sender][_spender] =_value;
emit Approval(msg.sender,_spender, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= balanceOf[_from]);
require(_value <= allowance[_from][msg.sender]);
balanceOf[_to]+=_value;
balanceOf[_from] -= _value;
allowance[_from][msg.sender] -= _value;
emit Transfer(_from, _to, _value);
return true;
}
}
i found the error
DeclarationError: Identifier not found or not unique.
mapping(address=> mapping(address=>uint265)) public allowance;
please help me to resolve the error.
It's most likely caused by a typo - there's no such thing as 265 bit unsigned integer (but there is 256 bit).
Replace the uint265 to uint256.

I have an ico code deployed but whenever i transfer ethereum to the address i get no tokens in return

So this is my code which compiles correctly in remix.ethereum and i deployed it on ropsten test chain successfully i validated the code on etherscan(https://ropsten.etherscan.io/address/0x22f27d3812a4d8bd2b6d870c300ea741906a7875) and i can start the ICO but i dont recieve tokens when i transfer eth to the creator address
pragma solidity ^0.4.23;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() public {
owner = msg.sender;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public view returns (uint256) {
return allowed[_owner][_spender];
}
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
}
}
contract Configurable {
uint256 public constant cap = 1000000*10**18;
uint256 public constant basePrice = 100*10**18; // tokens per 1 ether
uint256 public tokensSold = 0;
uint256 public constant tokenReserve = 1000000*10**18;
uint256 public remainingTokens = 0;
}
contract CrowdsaleToken is StandardToken, Configurable, Ownable {
enum Stages {
none,
icoStart,
icoEnd
}
Stages currentStage;
constructor() public {
currentStage = Stages.none;
balances[owner] = balances[owner].add(tokenReserve);
totalSupply_ = totalSupply_.add(tokenReserve);
remainingTokens = cap;
emit Transfer(address(this), owner, tokenReserve);
}
function () public payable {
require(currentStage == Stages.icoStart);
require(msg.value > 0);
require(remainingTokens > 0);
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(basePrice).div(1 ether);
uint256 returnWei = 0;
if(tokensSold.add(tokens) > cap){
uint256 newTokens = cap.sub(tokensSold);
uint256 newWei = newTokens.div(basePrice).mul(1 ether);
returnWei = weiAmount.sub(newWei);
weiAmount = newWei;
tokens = newTokens;
}
tokensSold = tokensSold.add(tokens);
remainingTokens = cap.sub(tokensSold);
if(returnWei > 0){
msg.sender.transfer(returnWei);
emit Transfer(address(this), msg.sender, returnWei);
}
balances[msg.sender] = balances[msg.sender].add(tokens);
emit Transfer(address(this), msg.sender, tokens);
totalSupply_ = totalSupply_.add(tokens);
owner.transfer(weiAmount);
}
function startIco() public onlyOwner {
require(currentStage != Stages.icoEnd);
currentStage = Stages.icoStart;
}
function endIco() internal {
currentStage = Stages.icoEnd;
if(remainingTokens > 0)
balances[owner] = balances[owner].add(remainingTokens);
owner.transfer(address(this).balance);
}
function finalizeIco() public onlyOwner {
require(currentStage != Stages.icoEnd);
endIco();
}
}
contract PkpICOTest is CrowdsaleToken {
string public constant name = "PkpICOTest";
string public constant symbol = "PKPICT";
uint32 public constant decimals = 18;
}

How to fix browser/IERC20.sol:4:53: Warning: This declaration shadows an existing declaration

Error:
browser/IERC20.sol:4:53: Warning: This declaration shadows an existing
declaration.
function totalSupply() public constant returns (uint256 totalSupply);
browser/IERC20.sol:4:5: The shadowed declaration is here:
function totalSupply() public constant returns (uint256 totalSupply);
IERC20.sol
pragma solidity ^0.4.17;
interface IERC20 {
function totalSupply() public constant returns (uint256 totalSupply);
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
INDToken.sol
pragma solidity ^0.4.11;
import './IERC20.sol';
contract INDToken is IERC20 {
uint public constant _totalSupply = 1000000;
string public constant symbol = "IND";
string public constant name = "Indonesia Token";
uint8 public constant decimals = 3;
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) allowed;
function INDToken() public {
balances[msg.sender] = _totalSupply;
}
function totalSupply() public constant returns (uint256 totalSupply){
return _totalSupply;
}
function balanceOf(address _owner) public constant returns (uint256 balance){
return balances[_owner];
}
function transfer(address _to, uint256 _value) public returns (bool success){
require(
balances[msg.sender] >= _value
&& _value > 0
);
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success){
require(
allowed[_from][msg.sender] >= _value
&& balances[_from] >= _value
&& _value > 0
);
balances[_from] -= _value;
balances[_to] += _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) public constant returns (uint256 remaining){
return allowed[_owner][_spender];
}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
I believe the issue is the reuse of the function name as the return value name. I would simply delete the name of the return value, since you're not using it anyway:
function totalSupply() public constant returns (uint256) {
As an alternative, you can name it something different:
function totalSupply() public constant returns (uint256 total) {