1

I have used the Token Contract from https://www.ethereum.org/token#the-code . I have set the buy/sell price as 1000000000000000000 wei, but when i try to buy token from another account by sending 1 ether it return an error! enter image description here

i have used Remix Solidity Ide compiler version:0.4.22+commit.4cb486ee.Emscripten.clang Environment: Java Script VM

value:1 ether

 pragma solidity ^0.4.16;

contract owned {
address public owner;
constructor() public {
    owner = msg.sender;
}

modifier onlyOwner {
    require(msg.sender == owner);
    _;
}

function transferOwnership(address newOwner) onlyOwner public {
    owner = newOwner;
}
}

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

contract TokenERC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 0;
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 generates a public event on the blockchain that will notify clients
event Approval(address indexed _owner, address indexed _spender, 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
 */
constructor(
    uint256 initialSupply,
    string tokenName,
    string tokenSymbol
) public payable {
    totalSupply = initialSupply * 10 ** uint256(decimals);  // Update total 
supply with the decimal amount
    balanceOf[msg.sender] = totalSupply;                // Give the creator 
       all initial tokens
    name = tokenName;                                   // Set the name for 
     display purposes
    symbol = tokenSymbol;                               // 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
    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 returns (bool success) 
{
    _transfer(msg.sender, _to, _value);
    return true;
}

/**
 * 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;
    emit Approval(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;
}
}

 contract MyAdvancedToken is owned, TokenERC20 {

uint256 public sellPrice;
uint256 public buyPrice;

mapping (address => bool) public frozenAccount;

/* This generates a public event on the blockchain that will notify clients 
  */
            event FrozenFunds(address target, bool frozen);

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

/* Internal transfer, only can be called by this contract */
function _transfer(address _from, address _to, uint _value) internal {
    require (_to != 0x0);                               // Prevent transfer 
to 0x0 address. Use burn() instead
    require (balanceOf[_from] >= _value);               // Check if the 
sender has enough
    require (balanceOf[_to] + _value >= balanceOf[_to]); // Check for 
overflows
    require(!frozenAccount[_from]);                     // Check if sender is frozen
    require(!frozenAccount[_to]);                       // Check if recipient is frozen
    balanceOf[_from] -= _value;                         // Subtract from the sender
    balanceOf[_to] += _value;                           // Add the same to the recipient
    emit Transfer(_from, _to, _value);
}

/// @notice Create `mintedAmount` tokens and send it to `target`
/// @param target Address to receive the tokens
/// @param mintedAmount the amount of tokens it will receive
function mintToken(address target, uint256 mintedAmount) onlyOwner public {
    balanceOf[target] += mintedAmount;
    totalSupply += mintedAmount;
    emit Transfer(0, this, mintedAmount);
    emit Transfer(address(this), target, mintedAmount);
}

/// @notice `freeze? Prevent | Allow` `target` from sending & receiving tokens
/// @param target Address to be frozen
/// @param freeze either to freeze it or not
function freezeAccount(address target, bool freeze) onlyOwner public {
    frozenAccount[target] = freeze;
    emit FrozenFunds(target, freeze);
}

/// @notice Allow users to buy tokens for `newBuyPrice` eth and sell tokens for `newSellPrice` eth
/// @param newSellPrice Price the users can sell to the contract
/// @param newBuyPrice Price users can buy from the contract
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner public {
    sellPrice = newSellPrice;
    buyPrice = newBuyPrice;
}

/// @notice Buy tokens from contract by sending ether
function buy() payable public {
    uint amount = msg.value / buyPrice;               // calculates the amount
    _transfer(this, msg.sender, amount);              // makes the transfers
}

/// @notice Sell `amount` tokens to contract
/// @param amount amount of tokens to be sold
function sell(uint256 amount) public {
    address myAddress = this;
    require(myAddress.balance >= amount * sellPrice);      // checks if the contract has enough ether to buy
    _transfer(msg.sender, this, amount);              // makes the transfers
    msg.sender.transfer(amount * sellPrice);          // sends ether to the seller. It's important to do this last to avoid recursion attacks
}
}

seen several questions of this kind.. but no solution yet

0

Your code is working fine for me once I get it to compile by removing the extra line breaks. (The code in your post has line breaks that cause some comments to no longer be comments.)

Here's what I did in Remix:

  1. Deploy with the parameters 1, "test token", "TEST". This gives the deploying address possession of 1 token. (Verify with balanceOf.)
  2. Call transfer with the parameters <address of contract>, 1 to transfer the token to the contract. (Verify with balanceOf.)
  3. Call setPrices with the parameters 0, "1000000000000000000" to set the buyPrice to 1*10^18. (Verify with buyPrice.)
  4. Call buy and attach 1 ether.
  5. Call balanceOf with my address as a parameter to verify I now have 1 token.
  • do you used same address for deploying and buying??? @smarx – Akshay Dev Aug 16 '18 at 12:20
  • Why so many question marks??? Yes, I did, but it doesn't matter. (You need to use the same account to do steps 1-3, because only the deploying account has tokens initially, and only the deploying account is allowed to call setPrices(). After that, any account can call buy().) – smarx Aug 16 '18 at 12:25
  • i have tried with same parameters, but still the error continues – Akshay Dev Aug 16 '18 at 12:29
  • It's hard to know where things are going wrong without more details. What does buyPrice() return right before you buy? What does balanceOf(<contract address>) return? – smarx Aug 16 '18 at 12:31
  • its okay now :) @smarx – Akshay Dev Aug 16 '18 at 12:36

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.