Nombre total d'offres exprimées en tant que zéro pour le contrat Ether Token déployé

Question

J'ai essayé d'éditer ce contrat. J'ai fait des dizaines de fois avec la plate-forme de solidité d'Ethereum et il continue à lire comme zéro. Enfait ici sont les variables qu'il lit dans:

1. Nom Exemple de chaîne de jeton
2. totalSupply 0 uint256
3. décimaux 3 uint8
4. _totalSupply 10000000 uint256
5. TAUX 350 uint256
6. chaîne SAMP symbole

J'ai fait des retours constants de l'offre totale, et je sais il y a une erreur mais ne peut pas savoir où. J'ai besoin d'aide pour résoudre ce problème afin que l'approvisionnement total se lit dans la quantité réelle, et j'ai essayé 15 fois à la fois sur le réseau régulier et de test.

code:

pragma solidity ^0.4.11; 

interface IERC20 { 
    function totalSupply() constant returns (uint256 totalSupply); 
    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 SampleToken is IERC20 { 

    using SafeMath for uint256; 
    uint public _totalSupply = 10000000; 

    string public constant symbol ="SAMP"; 
    string public constant name = "Sample Token"; 
    uint8 public constant decimals = 3; 

    //1 ether = 350 SAMP 
    uint256 public constant RATE = 350; 

    address public owner; 



    mapping(address => uint256) balances; 
    mapping(address => mapping(address => uint256)) allowed; 

    function() payable { 
     createTokens(); 
    } 

    function SampleToken() { 
     owner = msg.sender; 
    } 

    function createTokens() payable { 
     require(msg.value > 0); 

     uint256 tokens = msg.value.mul(RATE); 
     balances[msg.sender] = balances[msg.sender].add(tokens); 
     _totalSupply = _totalSupply.add(tokens); 

     owner.transfer(msg.value); 
    } 

    function totalSupply() constant returns (uint256 _totalSupply) { 
     return _totalSupply; 

    } 

    function balanceOf(address _owner) constant returns (uint256 balance) { 
     return balances[_owner]; 
    } 

    function transfer(address _to, uint256 _value) returns (bool success) { 
     require(
      balances[msg.sender] >= _value 
      && _value > 0 
     ); 
     balances[msg.sender] -= balances[msg.sender].sub(_value); 
     balances[_to] = balances[_to].add(_value); 
     Transfer(msg.sender, _to, _value); 
     return true; 
    } 

    function transferFrom(address _from, address _to, uint256 _value) returns (bool success) { 
     require(
      allowed[_from][msg.sender] >= _value 
      && balances[_from] >= _value 
      && _value > 0 
     ); 
     balances[_from] = balances[_from].sub(_value); 
     balances[_to] = balances [_to].add(_value); 
     allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); 
     Transfer(_from, _to, _value); 
     return true; 
    } 

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

    event Transfer(address indexed _from, address indexed_to, uint256 _value); 
    event Approval(address indexed_owner, address indexed_spender, uint256 _value); 
    function mul(uint256 a, uint256 b) internal constant returns (uint256) { 
    uint256 c = a * b; 
    assert(a == 0 || c/a == b); 
    return c; 
    } 
    function bytes32ToString(bytes32 x) constant returns (string) { 
     bytes memory bytesString = new bytes(32); 
     uint charCount = 0; 
     for (uint j = 0; j < 32; j++) { 
      byte char = byte(bytes32(uint(x) * 2 ** (8 * j))); 
      if (char != 0) { 
       bytesString[charCount] = char; 
       charCount++; 
      } 
     } 
     bytes memory bytesStringTrimmed = new bytes(charCount); 
     for (j = 0; j < charCount; j++) { 
      bytesStringTrimmed[j] = bytesString[j]; 
     } 
     return string(bytesStringTrimmed); 
    } 

} 

library SafeMath { 
    function mul(uint256 a, uint256 b) internal constant returns (uint256) { 
    uint256 c = a * b; 
    assert(a == 0 || c/a == b); 
    return c; 
    } 

    function div(uint256 a, uint256 b) internal constant returns (uint256) { 
    // assert(b > 0); // Solidity automatically throws when dividing by 0 
    uint256 c = a/b; 
    // assert(a == b * c + a % b); // There is no case in which this doesn't hold 
    return c; 
    } 

    function sub(uint256 a, uint256 b) internal constant returns (uint256) { 
    assert(b <= a); 
    return a - b; 
    } 

    function add(uint256 a, uint256 b) internal constant returns (uint256) { 
    uint256 c = a + b; 
    assert(c >= a); 
    return c; 
    } 
} 

Answer 1

Vous avez un problème de cadrage en totalSupply.

function totalSupply() constant returns (uint256 _totalSupply) { 
     return _totalSupply; 
    } 

Fondamentalement, dans vos déclarations que vous avez défini _totalSupply comme une variable locale qui va avoir préséance sur la version d'instance de _totalSupply et la valeur locale est jamais mis il retournera toujours si 0

vous pouvez changer cela

function totalSupply() constant returns (uint256) { 
     return _totalSupply; 
    } 

ou

function totalSupply() constant returns (uint256 _totalSupply) { 
     _totalSupply = __totalSupply; 
    } 

et changer

uint public _totalSupply = 10000000; 

à

uint private __totalSupply = 10000000; 

Il est important de faire de toute façon que si vous définissez votre offre totale à toute personne publique peut changer sa valeur.