# Gas Estimation Error when I try to burn token

``````pragma solidity ^0.4.18;

/**
* @title SafeMath
* @dev Math operations with safety checks that throw on error
*/
library SafeMath {

/**
* @dev Multiplies two numbers, throws on overflow.
*/
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;
}

/**
* @dev Integer division of two numbers, truncating the quotient.
*/
function div(uint256 a, uint256 b) internal pure 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 a / b;
}

/**
* @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}

/**
* @dev Adds two numbers, throws on overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
}
}

contract ForeignToken {
function balanceOf(address _owner) constant public returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
}

contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) public constant returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
}

contract ERC20 is ERC20Basic {
function approve(address spender, uint256 value) public returns (bool);
}

contract MatoxToken is ERC20 {

using SafeMath for uint256;

string public constant name = "Matox";
string public constant symbol = "MAT";
uint public constant decimals = 8;

uint256 public totalSupply = 10000000000e8;
uint256 public totalDistributed = 0;
uint256 public constant MIN_CONTRIBUTION = 1 ether /100; // 0.01 Ether
uint256 public tokensPerEth = 50000e8;

event Distr(address indexed to, uint256 amount);
event DistrFinished();

event Airdrop(address indexed _owner, uint _amount, uint _balance);

event TokensPerEthUpdated(uint _tokensPerEth);

event Burn(address indexed burner, uint256 value);

bool public distributionFinished = false;

modifier canDistr() {
require(!distributionFinished);
_;
}

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

function MatoxToken () public {
owner = msg.sender;
distr(owner, totalDistributed);
}

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

function finishDistribution() onlyOwner canDistr public returns (bool) {
distributionFinished = true;
emit DistrFinished();
return true;
}

function distr(address _to, uint256 _amount) canDistr private returns (bool) {
emit Distr(_to, _amount);

return true;
}

function doAirdrop(address _participant, uint _amount) internal {

require( _amount > 0 );

require( totalDistributed < totalSupply );

if (totalDistributed >= totalSupply) {
distributionFinished = true;
}

// log
emit Airdrop(_participant, _amount, balances[_participant]);
}

doAirdrop(_participant, _amount);
}

}

function updateTokensPerEth(uint _tokensPerEth) public onlyOwner {
tokensPerEth = _tokensPerEth;
emit TokensPerEthUpdated(_tokensPerEth);
}

function () external payable {
getTokens();
}

function getTokens() payable canDistr  public {
uint256 tokens = 0;

// minimum contribution
require( msg.value >= MIN_CONTRIBUTION );

require( msg.value > 0 );

// get baseline number of tokens
tokens = tokensPerEth.mul(msg.value) / 0.01 ether;

if (tokens > 0) {
distr(investor, tokens);
}

if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
}

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

// mitigates the ERC20 short address attack
assert(msg.data.length >= size + 4);
_;
}

function transfer(address _to, uint256 _amount) onlyPayloadSize(2 * 32) public returns (bool success) {

require(_amount <= balances[msg.sender]);

balances[msg.sender] = balances[msg.sender].sub(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}

require(_amount <= balances[_from]);
require(_amount <= allowed[_from][msg.sender]);

balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
emit Transfer(_from, _to, _amount);
return true;
}

function approve(address _spender, uint256 _value) public returns (bool success) {
// mitigates the ERC20 spend/approval race condition
if (_value != 0 && allowed[msg.sender][_spender] != 0) { return false; }
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}

return allowed[_owner][_spender];
}

uint bal = t.balanceOf(who);
return bal;
}

function withdraw() onlyOwner public {
owner.transfer(etherBalance);
}

function burn(uint256 _value) onlyOwner public {
require(_value <= balances[msg.sender]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure

balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
totalDistributed = totalDistributed.sub(_value);
emit Burn(burner, _value);
}

function withdrawForeignTokens(address _tokenContract) onlyOwner public returns (bool) {
ForeignToken token = ForeignToken(_tokenContract);
}
}
``````

• I see, but what is your question? Commented Aug 23, 2018 at 17:10
• What do I do, When I try to burn 1 Billion of my token it shows ,Gas Estimation Errored, How do I fix it ?. How Do I burn My token Commented Aug 23, 2018 at 17:18
• You just increase the limit. Remember that `geth` doesn't correctly estimate gas for contracts that release storage. Check this answer: ethereum.stackexchange.com/questions/56287/… Commented Aug 23, 2018 at 17:33
• I increased the limit to 500,000 but still get the same error Commented Aug 23, 2018 at 17:41
• some contracts spend more than block's gas limit, so 500,000 is not really too much Commented Aug 23, 2018 at 17:50

Moreover, in your constructer, you distribute the `totalDistributed` amount to the owner, which is 0 by default.