This is my code:

pragma solidity ^0.4.23;

import "./SafeMath.sol";
import "./MintableToken.sol";
import "./Ownable.sol";
import "./BurnableToken.sol";

 * @title Crowdsale
 * @dev Crowdsale is a base contract for managing a token crowdsale,
 * allowing investors to purchase tokens with ether. This contract implements
 * such functionality in its most fundamental form and can be extended to provide additional
 * functionality and/or custom behavior.
 * The external interface represents the basic interface for purchasing tokens, and conform
 * the base architecture for crowdsales. They are *not* intended to be modified / overriden.
 * The internal interface conforms the extensible and modifiable surface of crowdsales. Override
 * the methods to add functionality. Consider using 'super' where appropiate to concatenate
 * behavior.
contract Crowdsale is Ownable {
  using SafeMath for uint256;

 // The token being sold
    MintableToken public token;

    // start and end timestamps where investments are allowed (both inclusive)
    uint256 public ICOStartTime;
    uint256 public ICOEndTime;

    // wallet address where funds will be saved
    address internal wallet;

    // amount of raised money in wei
    uint256 public weiRaised; // internal

    // Public Supply
    uint256 public publicSupply;

     * event for token purchase logging
     * @param purchaser who paid for the tokens
     * @param beneficiary who got the tokens
     * @param value weis paid for purchase
     * @param amount amount of tokens purchased
    event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);

    // BitNautic Crowdsale constructor
    constructor(MintableToken _token, uint256 _publicSupply, uint256 _startTime, uint256 _endTime, address _wallet) public {
        require(_endTime >= _startTime);
        require(_wallet != 0x0);

        // BitNautic token creation
        token = _token;

        // total supply of token for the crowdsale
        publicSupply = _publicSupply;

        // Pre-ICO start Time
        ICOStartTime = _startTime;

        // ICO end Time
        ICOEndTime = _endTime;

        // wallet where funds will be saved
        wallet = _wallet;


    // fallback function can be used to buy tokens
    function() public payable {

    // High level token purchase function
    function buyTokens(address beneficiary) public payable {
        require(beneficiary != 0x0);

        // minimum investment should be 0.05 ETH
        uint256 lowerPurchaseLimit = 0.05 ether;
        require(msg.value >= lowerPurchaseLimit);

        assert(_tokenPurchased(msg.sender, beneficiary, msg.value));

        // update state
        weiRaised = weiRaised.add(msg.value);


    function _tokenPurchased(address /* buyer */, address /* beneficiary */, uint256 /* weiAmount */) internal returns (bool) {
        return true;

    // send ether to the fund collection wallet
    // override to create custom fund forwarding mechanisms
    function forwardFunds() internal {

    // @return true if the transaction can buy tokens
    function validPurchase() internal constant returns (bool) {
        bool withinPeriod = ICOStartTime <= now && now <= ICOEndTime;
        bool nonZeroPurchase = msg.value != 0;

        return withinPeriod && nonZeroPurchase;

    // @return true if crowdsale event has ended
    function hasEnded() public constant returns (bool) {
        return now > ICOEndTime;
bool public checkBurnTokens = false;

    function burnTokens() onlyOwner public returns (bool) {

        token.mint(0x0, publicSupply);
        publicSupply = 0;
        checkBurnTokens = true;

        return true;

    function getTokenAddress() onlyOwner public view returns (address) {
        return address(token);

The Remix compiler gives me the following error:

TypeError: Member "burnTokens" not found or not visible after argument-dependent lookup in contract MintableToken token.burnTokens(publicSupply);

closed as unclear what you're asking by Achala Dissanayake, mirg, Richard Horrocks, eth May 27 '18 at 1:54

Please clarify your specific problem or add additional details to highlight exactly what you need. As it's currently written, it’s hard to tell exactly what you're asking. See the How to Ask page for help clarifying this question. If this question can be reworded to fit the rules in the help center, please edit the question.

  • I thought that the problem with inheritance, but how to solve, I do not know! – Sergey May 24 '18 at 13:44
  • You are calling token.burnTokens(publicSupply) but that token is declared as MintableToken which doesn't have a burnTokens() function, either you need to cast to BurnableToken or declare token with that contract. – Ismael May 26 '18 at 19:48

It looks like you're calling burnToken() on a variable token:


From the code, I can see that token is of type MintableToken defined on line 26:

MintableToken public token;

Now if you're using the openZeppelin mintableToken contract, there is no function called burntoken() in that contract.

To add the burnToken() function one option is to have a new contract inherit from mintableToken:

contract [contractName] is mintableToken {
 ---> add the function here;

and now your token would be of the new type contractName.

  • Yes, I use the OpenZeppelin code as the base and sample. Tell me how to add the burntoken () function? – Sergey May 24 '18 at 13:57
  • see the updated answer – Mheni May 24 '18 at 14:03

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