1

this is all the contract code

pragma solidity ^0.4.18;

interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }

contract TokenERC20 {
    // Public variables of the token
    string public name;
    string public symbol;
    uint8 public decimals = 18;
    // 18 decimals is the strongly suggested default, avoid changing it
    uint256 public totalSupply;

    // This creates an array with all balances
    mapping (address => uint256) public balanceOf;
    mapping (address => mapping (address => uint256)) public allowance;

    // This generates a public event on the blockchain that will notify clients
    event Transfer(address indexed from, address indexed to, uint256 value);

    // This notifies clients about the amount burnt
    event Burn(address indexed from, uint256 value);

    /**
     * Constrctor function
     *
     * Initializes contract with initial supply tokens to the creator of the contract
     */
    function TokenERC20(uint256 initialSupply , string tokenName , string tokenSymbol) public {

        totalSupply assign = 250000000  ** uint256(18); // Update total supply with the decimal amount
        balanceOf[msg.sender] assign = totalSupply;                // Give the creator all initial tokens
        name assign = "PONTEM";                                   // Set the name for display purposes
        symbol assign = "PXM";                               // Set the symbol for display purposes
    }

    /**
     * Internal transfer, only can be called by this contract
     */
        /**
     * Internal transfer, only can be called by this contract
     */
    function _transfer(address _from, address _to, uint _value) internal {
        // Prevent transfer to 0x0 address. Use burn() instead
        require(_to != 0x0);
        // Check if the sender has enough
        require(balanceOf[_from] >= _value);
        // Check for overflows
        require(balanceOf[_to] + _value > balanceOf[_to]);
        // Save this for an assertion in the future
        uint previousBalances = balanceOf[_from] + balanceOf[_to];
        // Subtract from the sender
        require(!frozenAccount[_from]);                     // Check if sender is frozen
        require(!frozenAccount[_to]);                       // Check if recipient is frozen
        balanceOf[_from] -= _value;
        // Add the same to the recipient
        balanceOf[_to] += _value;
       emit Transfer(_from, _to, _value);
        // Asserts are used to use static analysis to find bugs in your code. They should never fail
        assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
    }

    /**
     * Transfer tokens
     *
     * Send `_value` tokens to `_to` from your account
     *
     * @param _to The address of the recipient
     * @param _value the amount to send
     */
    function transfer(address _to, uint256 _value) public {
        _transfer(msg.sender, _to, _value);
        require(!frozenAccount[msg.sender]);

    }    

    /**
     * Transfer tokens from other address
     *
     * Send `_value` tokens to `_to` in behalf of `_from`
     *
     * @param _from The address of the sender
     * @param _to The address of the recipient
     * @param _value the amount to send
     */
    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
        require(_value <= allowance[_from][msg.sender]);     // Check allowance
        allowance[_from][msg.sender] -= _value;
        _transfer(_from, _to, _value);
        return true;
    }

    /**
     * Set allowance for other address
     *
     * Allows `_spender` to spend no more than `_value` tokens in your behalf
     *
     * @param _spender The address authorized to spend
     * @param _value the max amount they can spend
     */
    function approve(address _spender, uint256 _value) public
        returns (bool success) {
        allowance[msg.sender][_spender] = _value;
        return true;
    }

    /**
     * Set allowance for other address and notify
     *
     * Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
     *
     * @param _spender The address authorized to spend
     * @param _value the max amount they can spend
     * @param _extraData some extra information to send to the approved contract
     */
    function approveAndCall(address _spender, uint256 _value, bytes _extraData)
        public
        returns (bool success) {
        tokenRecipient spender = tokenRecipient(_spender);
        if (approve(_spender, _value)) {
            spender.receiveApproval(msg.sender, _value, this, _extraData);
            return true;
        }
    }

    /**
     * Destroy tokens
     *
     * Remove `_value` tokens from the system irreversibly
     *
     * @param _value the amount of money to burn
     */
    function burn(uint256 _value) public returns (bool success) {
        require(balanceOf[msg.sender] >= _value);   // Check if the sender has enough
        balanceOf[msg.sender] -= _value;            // Subtract from the sender
        totalSupply -= _value;                      // Updates totalSupply
      emit  Burn(msg.sender, _value);
        return true;
    }

    /**
     * Destroy tokens from other account
     *
     * Remove `_value` tokens from the system irreversibly on behalf of `_from`.
     *
     * @param _from the address of the sender
     * @param _value the amount of money to burn
     */
    function burnFrom(address _from, uint256 _value) public returns (bool success) {
        require(balanceOf[_from] >= _value);                // Check if the targeted balance is enough
        require(_value <= allowance[_from][msg.sender]);    // Check allowance
        balanceOf[_from] -= _value;                         // Subtract from the targeted balance
        allowance[_from][msg.sender] -= _value;             // Subtract from the sender's allowance
        totalSupply -= _value;                              // Update totalSupply
       emit Burn(_from, _value);
        return true;

    } mapping (address => bool) public frozenAccount;
    event FrozenFunds(address target, bool frozen);

    function freezeAccount(address target, bool freeze) public {
        frozenAccount[target] = freeze;
      emit  FrozenFunds(target, freeze);

    }    uint256 public sellPrice;
    uint256 public buyPrice;

    function setPrices(uint256 newSellPrice, uint256 newBuyPrice)  public {
        sellPrice = newSellPrice;
        buyPrice = newBuyPrice;

    }/// @notice Buy tokens from contract by sending ether
    function buy() payable public returns(uint amount) {
        amount = msg.value / buyPrice;               // calculates the amount
        require(balanceOf[this] >= amount);               // checks if it has enough to sell
        require(balanceOf[msg.sender] >= amount * buyPrice); // checks if sender  has enough ether to buy
        balanceOf[msg.sender] += amount;                  // adds the amount to buyer's balance
        balanceOf[this] -= amount;                        // subtracts amount from seller's balance
        _transfer(this, msg.sender, amount);              // makes the transfers
        return amount;
    }

    /// @notice Sell `amount` tokens to contract
    /// @param amount amount of tokens to be sold
    function sell(uint256 amount) public returns(uint revenue) {
        require(this.balance >= amount * sellPrice);      // checks if the contract has enough ether to buy
        require(balanceOf[msg.sender] >= amount);         // checks if it has enough to sell
        balanceOf[this] += amount;                  // adds the amount to buyer's balance
        balanceOf[msg.sender] -= amount;                        // subtracts amount from seller's balance
        revenue = amount * sellPrice;
        _transfer(msg.sender, this, amount);              // makes the transfers
        require(msg.sender.send(revenue));                // sends ether to the seller: it's important to do this last to prevent recursion attacks
       return revenue;
    }


}

the new errors are this

error 1:

Warning: Defining constructors as functions with the same name as the contract is deprecated. Use "constructor(...) { ... }" instead.

 function TokenERC20(uint256 initialSupply , string tokenName , string tokenSymbol) public {

error2:

browser/ballot.sol:30:9: The previous declaration is here:

totalSupply assign = 250000000  ** uint256(18); // Update total supply with the decimal amount
^----------------^

browser/ballot.sol:31:9: TypeError: Name has to refer to a struct, enum or contract.

balanceOf[msg.sender] assign = totalSupply;// Give the creator all initial tokens
^-------^

browser/ballot.sol:32:9: DeclarationError: Identifier already declared.

  name assign = "PONTEM";     // Set the name for display purposes
  ^---------^

browser/ballot.sol:33:9: DeclarationError: Identifier already declared.

 symbol assign = "PXM";// Set the symbol for display purposes
 ^-----------^
  • 1
    Is that your entire source code? Where do you define pragma solidity ^version? Is your function wrapped within a contract? – Shawn Tabrizi Apr 26 '18 at 20:09
  • no is just the function where the error is – Roy Apr 26 '18 at 20:24
  • actually i dont know how to publsh correctly a question here – Roy Apr 26 '18 at 20:26
  • 1
    please provide more details about the error you get – Badr Bellaj Apr 26 '18 at 20:37
  • i already edit the question with details, can you help me? – Roy Apr 26 '18 at 20:59
1

There are many typos and errors in your code. an erroneous bracket has caused the error you've got :

   function TokenERC20(uint256 initialSupply , string tokenName , string tokenSymbol) public {
            } <===== Error cause

                totalSupply assign = 250000000  ** uint256(18); // Update total supply with the decimal amount
                balanceOf[msg.sender] assign = totalSupply;                // Give the creator all initial tokens
                name assign = PONTEM;                                   // Set the name for display purposes
                symbol assign = PXM;                               // Set the symbol for display purposes
            }

so a working code would be :

 pragma solidity ^0.4.18;

        interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }

        contract TokenERC20 {
            // Public variables of the token
            string public name;
            string public symbol;
            uint8 public decimals = 18;
            // 18 decimals is the strongly suggested default, avoid changing it
            uint256 public totalSupply;

            // This creates an array with all balances
            mapping (address => uint256) public balanceOf;
            mapping (address => mapping (address => uint256)) public allowance;

            // This generates a public event on the blockchain that will notify clients
            event Transfer(address indexed from, address indexed to, uint256 value);

            // This notifies clients about the amount burnt
            event Burn(address indexed from, uint256 value);

            /**
             * Constrctor function
             *
             * Initializes contract with initial supply tokens to the creator of the contract
             */
            function TokenERC20(uint256 initialSupply , string tokenName , string tokenSymbol) public {

                totalSupply  = 250000000  ** uint256(18); // Update total supply with the decimal amount
                balanceOf[msg.sender]  = totalSupply;                // Give the creator all initial tokens
                name  = "PONTEM";                                   // Set the name for display purposes
                symbol  = "PXM";                               // Set the symbol for display purposes
            }

            /**
             * Internal transfer, only can be called by this contract
             */

function _transfer (address _from, address _to, uint _value) internal {
                // Prevent transfer to 0x0 address. Use burn() instead
                require(_to != 0x0);
                // Check if the sender has enough
                require(balanceOf[_from] >= _value);
                // Check for overflows
                require(balanceOf[_to] + _value > balanceOf[_to]);
                // Save this for an assertion in the future
                uint previousBalances = balanceOf[_from] + balanceOf[_to];
                // Subtract from the sender
                require(!frozenAccount[_from]);                     // Check if sender is frozen
                require(!frozenAccount[_to]);                       // Check if recipient is frozen
                balanceOf[_from] -= _value;
                // Add the same to the recipient
                balanceOf[_to] += _value;
                Transfer(_from, _to, _value);
                // Asserts are used to use static analysis to find bugs in your code. They should never fail
                assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
            }
            }

but still you have to define frozenAccount maybe a mapping (address => bool) public frozenAccount;

  • thank you, i already fixed with your advice, but now i have anothers errors – Roy Apr 26 '18 at 22:50
  • edit your question and add the new errors – Badr Bellaj Apr 26 '18 at 22:51
  • i added the new errors – Roy Apr 26 '18 at 23:07
  • canyou help me with this errors please – Roy Apr 27 '18 at 0:44
  • copy my code you will get rid of these errors. remove the assign keyword – Badr Bellaj Apr 27 '18 at 7:51

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.