BSCSCAN testnet not showing holders - solidity

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.

Related

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;
}

DeclarationError: Undeclared identifier. Did you mean "balanceOf" or "blances"?

I am trying to create my own token using Solidity on Remix Ethereum. I use MetaMask and logged in Binance Smart Chain Testnet . But when I use Solidity Compiler to compile, it keeps showing this error on lines 15, 19, 24, 25, 33, 34:
DeclarationError: Undeclared identifier. Did you mean "balanceOf" or "blances"?
Here the code:
pragma solidity ^0.8.2;
contract MyTestToken {
mapping(address => uint) public blances;
mapping(address => mapping(address => uint)) public allowance;
uint public totalSupply = 1000000000000 * 10 ** 18;
string public name = "MyToken Test";
string public symbol = "TKNT";
uint public decimals = 18;
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
constructor () {
balances[msg.sender] = totalSupply;
}
function balanceOf(address owner) public view returns(uint) {
return balances[owner];
}
function transfer(address to, uint value) public returns(bool) {
require(balanceOf(msg.sender) >= value, 'balance too low');
balances[to] += value;
balances[msg.sender] -= value;
emit Transfer(msg.sender, to, value);
return true;
}
function transferFrom(address from, address to, uint value) public returns(bool) {
require(balanceOf(from) >= value, 'balance too low');
require(allowance[from][msg.sender] >= value, 'allowance too low');
balances[to] += value;
balances[from] -= value;
emit Transfer(from, to, value);
return true;
}
function approve(address spender, uint value) public returns(bool) {
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
}
Thank you in advance.
It's caused by a typo in your code. Rename the mapping blances to balances.
mapping(address => uint) public blances; // original code
mapping(address => uint) public balances; // corrected

How would I implement a buy/sell transfer tax within solidity

I want to put a transfer tax into my code but not sure how to go about it. I would apply a 2.5% tax on buys and sells. Any help/advice would be greatly appreciated. This is what I have so far:
pragma solidity ^0.8.4;
contract Token {
mapping(address => uint) public balances;
mapping(address => mapping(address => uint)) public allowance;
uint public totalSupply = 100000000000 * 10 ** 18;
string public name = "*****";
string public symbol = "****";
uint public decimals = 18;
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
constructor(){
balances[msg.sender] = totalSupply;
}
function balanceOf(address owner) public view returns(uint){
return balances[owner];
}
function transfer(address to, uint value) public return(bool){
require(balanceOf(msg.sender) >= value, 'balance too low');
balances[to] += value;
balances[msg.sender] -= value;
emit Transfer(msg.sender, to, value);
return true;
}
function transferFrom(address from, address to, uint value) public returns(true){
require(balanceOf(from) >= value, 'balance too low');
require(allowance[from][msg.sender] >= value, 'allowance too low');
balances[to] +=value;
balances[from] -= value;
emit Transfer (from, to, value);
return true
}
function approve (address spender, uint value) public reutrns(bool) {
allowance[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
}

Solidity Expected Primary Expression

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;
}