0

Hi guys I am struggling to launch this crowdsale code in Remix. I deploy the ABCD token without an issue but when I go to launch the crowdsale code with the "TokenAddress", "startTime", "endTime" I get an always failing transaction error. Can anyone see what the transaction might be? These are the three codes I am using as well as the standard SafeMath.

 pragma solidity ^0.4.20;

    /**
     * @title Moderated
     * @dev restricts execution of 'onlyModerator' modified functions to the contract moderator
     * @dev restricts execution of 'ifUnrestricted' modified functions to when unrestricted
     *      boolean state is true
     * @dev allows for the extraction of ether or other ERC20 tokens mistakenly sent to this address
     */
    contract Moderated {

        address public moderator;

        bool public unrestricted;

        modifier onlyModerator {
            require(msg.sender == moderator);
            _;
        }

        modifier ifUnrestricted {
            require(unrestricted);
            _;
        }

        modifier onlyPayloadSize(uint numWords) {
            assert(msg.data.length >= numWords * 32 + 4);
            _;
        }

        function Moderated() public {
            moderator = msg.sender;
            unrestricted = true;
        }

        function reassignModerator(address newModerator) public onlyModerator {
            moderator = newModerator;
        }

        function restrict() public onlyModerator {
            unrestricted = false;
        }

        function unrestrict() public onlyModerator {
            unrestricted = true;
        }

        /// This method can be used to extract tokens mistakenly sent to this contract.
        /// @param _token The address of the token contract that you want to recover
        function extract(address _token) public returns (bool) {
            require(_token != address(0x0));
            Token token = Token(_token);
            uint256 balance = token.balanceOf(this);
            return token.transfer(moderator, balance);
        }

        function isContract(address _addr) internal view returns (bool) {
            uint256 size;
            assembly { size := extcodesize(_addr) }
            return (size > 0);
        }
    }

    /**
     * @title ERC20 interface
     * @dev see https://github.com/ethereum/EIPs/issues/20
     */
    contract Token {

        function totalSupply() public view returns (uint256);
        function balanceOf(address who) public view returns (uint256);
        function transfer(address to, uint256 value) public returns (bool);
        function transferFrom(address from, address to, uint256 value) public returns (bool);
        function approve(address spender, uint256 value) public returns (bool);
        function allowance(address owner, address spender) public view returns (uint256);
        event Transfer(address indexed from, address indexed to, uint256 value);
        event Approval(address indexed owner, address indexed spender, uint256 value);

 }

    pragma solidity ^0.4.20;
        // @dev Assign moderation of contract to CrowdSale

        contract ABCD is Moderated {
            using SafeMath for uint256;

                string public name = "ABCD22";
                string public symbol = "ABCD Eon Exchange Tokens22";
                uint8 public decimals = 18;

                uint256 public maximumTokenIssue = 30000000 * 10**18;

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

                uint256 internal totalSupply_;

                event Approval(address indexed owner, address indexed spender, uint256 value);
                event Transfer(address indexed from, address indexed to, uint256 value);

                /**
                * @dev total number of tokens in existence
                */
                function totalSupply() public view returns (uint256) {
                    return totalSupply_;
                }

                /**
                * @dev transfer token for a specified address
                * @param _to The address to transfer to.
                * @param _value The amount to be transferred.
                */
                function transfer(address _to, uint256 _value) public ifUnrestricted onlyPayloadSize(2) returns (bool) {
                    return _transfer(msg.sender, _to, _value);
                }

                /**
                * @dev Transfer tokens from one address to another
                * @param _from address The address which you want to send tokens from
                * @param _to address The address which you want to transfer to
                * @param _value uint256 the amount of tokens to be transferred
                */
                function transferFrom(address _from, address _to, uint256 _value) public ifUnrestricted onlyPayloadSize(3) returns (bool) {
                    require(_value <= allowed[_from][msg.sender]);
                    allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
                    return _transfer(_from, _to, _value);
                }

                function _transfer(address _from, address _to, uint256 _value) internal returns (bool) {
                    // Do not allow transfers to 0x0 or to this contract
                    require(_to != address(0x0) && _to != address(this));
                    // Do not allow transfer of value greater than sender's current balance
                    require(_value <= balances[_from]);
                    // Update balance of sending address
                    balances[_from] = balances[_from].sub(_value);
                    // Update balance of receiving address
                    balances[_to] = balances[_to].add(_value);
                    // An event to make the transfer easy to find on the blockchain
                    Transfer(_from, _to, _value);
                    return true;
                }

                /**
                * @dev Gets the balance of the specified address.
                * @param _owner The address to query the the balance of.
                * @return An uint256 representing the amount owned by the passed address.
                */
                function balanceOf(address _owner) public view returns (uint256) {
                    return balances[_owner];
                }

                /**
                * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
                *
                * Beware that changing an allowance with this method brings the risk that someone may use both the old
                * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
                * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
                * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
                * @param _spender The address which will spend the funds.
                * @param _value The amount of tokens to be spent.
                */
                function approve(address _spender, uint256 _value) public ifUnrestricted onlyPayloadSize(2) returns (bool sucess) {
                    // Can only approve when value has not already been set or is zero
                    require(allowed[msg.sender][_spender] == 0 || _value == 0);
                    allowed[msg.sender][_spender] = _value;
                    Approval(msg.sender, _spender, _value);
                    return true;
                }

                /**
                * @dev Function to check the amount of tokens that an owner allowed to a spender.
                * @param _owner address The address which owns the funds.
                * @param _spender address The address which will spend the funds.
                * @return A uint256 specifying the amount of tokens still available for the spender.
                */
                function allowance(address _owner, address _spender) public view returns (uint256) {
                    return allowed[_owner][_spender];
                }

                /**
                * @dev Increase the amount of tokens that an owner allowed to a spender.
                *
                * approve should be called when allowed[_spender] == 0. To increment
                * allowed value is better to use this function to avoid 2 calls (and wait until
                * the first transaction is mined)
                * From MonolithDAO Token.sol
                * @param _spender The address which will spend the funds.
                * @param _addedValue The amount of tokens to increase the allowance by.
                */
                function increaseApproval(address _spender, uint256 _addedValue) public ifUnrestricted onlyPayloadSize(2) returns (bool) {
                    require(_addedValue > 0);
                    allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
                    Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
                    return true;
                }

                /**
                * @dev Decrease the amount of tokens that an owner allowed to a spender.
                *
                * approve should be called when allowed[_spender] == 0. To decrement
                * allowed value is better to use this function to avoid 2 calls (and wait until
                * the first transaction is mined)
                * From MonolithDAO Token.sol
                * @param _spender The address which will spend the funds.
                * @param _subtractedValue The amount of tokens to decrease the allowance by.
                */
                function decreaseApproval(address _spender, uint256 _subtractedValue) public ifUnrestricted onlyPayloadSize(2) returns (bool) {
                    uint256 oldValue = allowed[msg.sender][_spender];
                    require(_subtractedValue > 0);
                    if (_subtractedValue > oldValue) {
                        allowed[msg.sender][_spender] = 0;
                    } else {
                        allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
                    }
                    Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
                    return true;
                }

                /**
                * @dev Function to mint tokens
                * @param _to The address that will receive the minted tokens.
                * @param _amount The amount of tokens to mint.
                * @return A boolean that indicates if the operation was successful.
                */
                function generateTokens(address _to, uint _amount) internal returns (bool) {
                    totalSupply_ = totalSupply_.add(_amount);
                    balances[_to] = balances[_to].add(_amount);
                    Transfer(address(0x0), _to, _amount);
                    return true;
                }
                /**
                * @dev fallback function - reverts transaction
                */
                function () external payable {
                    revert();
                }

                function ABCD() public {
                    generateTokens(msg.sender, maximumTokenIssue);
                }

  }

pragma solidity ^0.4.20;

import "./Moderated.sol";
import "./SafeMath.sol";
import "./ABCD.sol";

contract CrowdSale is Moderated {
    using SafeMath for uint256;

    // ABCD ERC20 smart contract
    ABCD public tokenContract;

    uint256 public startDate;

    uint256 public endDate;

    // crowdsale aims to sell 8 000 000 ABCD
    uint256 public constant crowdsaleTarget = 2705 ether;
    // running total of tokens sold
    uint256 public etherRaised;

    // address to receive accumulated ether given a successful crowdsale
    address public etherVault;

    // minimum of 0.005 ether to participate in crowdsale
    uint256 constant purchaseThreshold = 5 finney;

    // boolean to indicate crowdsale finalized state
    bool public isFinalized = false;

    bool public active = false;

    // finalization event
    event Finalized();

    // purchase event
    event Purchased(address indexed purchaser, uint256 indexed tokens);

    // checks that crowd sale is live
    modifier onlyWhileActive {
        require(now >= startDate && now <= endDate && active);
        _;
    }

    function CrowdSale( address _tokenAddr,
                        uint256 start,
                        uint256 end) public {
        require(_tokenAddr != address(0x0));
        require(now < start && start < end);
        // the ABCD token contract
        tokenContract = ABCD(_tokenAddr);

        etherVault = msg.sender;

        startDate = start;
        endDate = end;
    }

    // fallback function invokes buyTokens method
    function () external payable {
        buyTokens(msg.sender);
    }

    function buyTokens(address _purchaser) public payable ifUnrestricted onlyWhileActive returns (bool) {
        require(!targetReached());
        require(msg.value > purchaseThreshold);
        etherVault.transfer(msg.value);

        uint256 _tokens = calculate(msg.value);
        // approve CrowdSale to spend 8 000 000 tokens on behalf of moderator
        require(tokenContract.transferFrom(moderator,_purchaser,_tokens));
        //require(tokenContract.generateTokens(_purchaser, _tokens));
        Purchased(_purchaser, _tokens);
        return true;
    }

    function calculate(uint256 weiAmount) internal returns(uint256) {
        uint256 excess;
        uint256 numTokens;
        uint256 excessTokens;
        if(etherRaised < 5 ether) {
            etherRaised = etherRaised.add(weiAmount);
            if(etherRaised > 5 ether) {
                excess = etherRaised.sub(5 ether);
                numTokens = weiAmount.sub(excess).mul(100000);
                etherRaised = etherRaised.sub(excess);
                excessTokens = calculate(excess);
                return numTokens + excessTokens;
            } else {
                return weiAmount.mul(100000);
            }
        } else if(etherRaised < 55 ether) {
            etherRaised = etherRaised.add(weiAmount);
            if(etherRaised > 55 ether) {
                excess = etherRaised.sub(55 ether);
                numTokens = weiAmount.sub(excess).mul(10000);
                etherRaised = etherRaised.sub(excess);
                excessTokens = calculate(excess);
                return numTokens + excessTokens;
            } else {
                return weiAmount.mul(10000);
            }
        } else if(etherRaised < 155 ether) {
            etherRaised = etherRaised.add(weiAmount);
            if(etherRaised > 155 ether) {
                excess = etherRaised.sub(155 ether);
                numTokens = weiAmount.sub(excess).mul(5000);
                etherRaised = etherRaised.sub(excess);
                excessTokens = calculate(excess);
                return numTokens + excessTokens;
            } else {
                return weiAmount.mul(5000);
            }
        } else if(etherRaised < 905 ether) {
            etherRaised = etherRaised.add(weiAmount);
            if(etherRaised > 905 ether) {
                excess = etherRaised.sub(905 ether);
                numTokens = weiAmount.sub(excess).mul(3333);
                etherRaised = etherRaised.sub(excess);
                excessTokens = calculate(excess);
                return numTokens + excessTokens;
            } else {
                return weiAmount.mul(3333);
            }
        } else if(etherRaised < 1705 ether) {
            etherRaised = etherRaised.add(weiAmount);
            if(etherRaised > 1705) {
                excess = etherRaised.sub(1705 ether);
                numTokens = weiAmount.sub(excess).mul(2500);
                etherRaised = etherRaised.sub(excess);
                excessTokens = calculate(excess);
                return numTokens + excessTokens;
            } else {
                return weiAmount.mul(2500);
            }
        } else {
            etherRaised = etherRaised.add(weiAmount);
            return weiAmount.mul(2000);
        }
    }

    function changeEtherVault(address newEtherVault) public onlyModerator {
        require(newEtherVault != address(0x0));
        etherVault = newEtherVault;
    }

    function initialize() public onlyModerator {
        // assign ABCD moderator to this contract address
        // assign moderator of this contract to crowdsale manager address
        require(tokenContract.allowance(moderator, address(this)) == 8000000000000000000000000);
        active = true;
        // send approve from moderator account allowing for 8 million tokens
        // spendable by this contract
    }

    // activates end of crowdsale state
    function finalize() public onlyModerator {
        // cannot have been invoked before
        require(!isFinalized);
        // can only be invoked after end date or if target has been reached
        require(hasEnded() || targetReached());

        active = false;

        // emit Finalized event
        Finalized();
        // set isFinalized boolean to true
        isFinalized = true;
    }

    // checks if end date of crowdsale is passed
    function hasEnded() internal view returns (bool) {
        return (now > endDate);
    }

    // checks if crowdsale target is reached
    function targetReached() internal view returns (bool) {
        return (etherRaised >= crowdsaleTarget);
    }
}

EDIT here is the error message:

creation of CrowdSale errored: Error: gas required exceeds allowance or always failing transaction
    at chrome-extension://nkbihfbeogaeaoehlefnkodbefgpgknn/scripts/background.js:1:1219603
    at chrome-extension://nkbihfbeogaeaoehlefnkodbefgpgknn/scripts/background.js:1:796531
    at chrome-extension://nkbihfbeogaeaoehlefnkodbefgpgknn/scripts/background.js:1:230353
    at o (chrome-extension://nkbihfbeogaeaoehlefnkodbefgpgknn/scripts/background.js:1:248584)
    at chrome-extension://nkbihfbeogaeaoehlefnkodbefgpgknn/scripts/background.js:1:233183
    at chrome-extension://nkbihfbeogaeaoehlefnkodbefgpgknn/scripts/background.js:1:230353
    at u (chrome-extension://nkbihfbeogaeaoehlefnkodbefgpgknn/scripts/background.js:1:233459)
    at chrome-extension://nkbihfbeogaeaoehlefnkodbefgpgknn/scripts/background.js:1:233497
    at Ht (chrome-extension://nkbihfbeogaeaoehlefnkodbefgpgknn/scripts/background.js:1:242866)
    at Object.<anonymous> (chrome-extension://nkbihfbeogaeaoehlefnkodbefgpgknn/scripts/background.js:1:233586)
    at e.value (chrome-extension://nkbihfbeogaeaoehlefnkodbefgpgknn/scripts/background.js:1:797446)
    at chrome-extension://nkbihfbeogaeaoehlefnkodbefgpgknn/scripts/background.js:1:797013
    at n (chrome-extension://nkbihfbeogaeaoehlefnkodbefgpgknn/scripts/background.js:1:248528)
    at o (chrome-extension://nkbihfbeogaeaoehlefnkodbefgpgknn/scripts/background.js:1:248606)
    at chrome-extension://nkbihfbeogaeaoehlefnkodbefgpgknn/scripts/background.js:1:233183
    at chrome-extension://nkbihfbeogaeaoehlefnkodbefgpgknn/scripts/background.js:1:796979
    at n (chrome-extension://nkbihfbeogaeaoehlefnkodbefgpgknn/scripts/background.js:1:248528)
    at o (chrome-extension://nkbihfbeogaeaoehlefnkodbefgpgknn/scripts/background.js:1:248606)
    at chrome-extension://nkbihfbeogaeaoehlefnkodbefgpgknn/scripts/background.js:1:233183
    at chrome-extension://nkbihfbeogaeaoehlefnkodbefgpgknn/scripts/background.js:1:797352
    at chrome-extension://nkbihfbeogaeaoehlefnkodbefgpgknn/scripts/background.js:1:233993
    at chrome-extension://nkbihfbeogaeaoehlefnkodbefgpgknn/scripts/background.js:1:230353
    at u (chrome-extension://nkbihfbeogaeaoehlefnkodbefgpgknn/scripts/background.js:1:233459)
    at s (chrome-extension://nkbihfbeogaeaoehlefnkodbefgpgknn/scripts/background.js:1:233381)
    at chrome-extension://nkbihfbeogaeaoehlefnkodbefgpgknn/scripts/background.js:1:233183
    at chrome-extension://nkbihfbeogaeaoehlefnkodbefgpgknn/scripts/background.js:1:233973
    at chrome-extension://nkbihfbeogaeaoehlefnkodbefgpgknn/scripts/background.js:1:797234
    at chrome-extension://nkbihfbeogaeaoehlefnkodbefgpgknn/scripts/background.js:1:645173
    at n (chrome-extension://nkbihfbeogaeaoehlefnkodbefgpgknn/scripts/background.js:1:132219)
  • How did you solve it? Are you running it in Remix IDE ? If you are like me then you need to choose Environment as - JavaScript VM and then try to run it. It will not show this error. – Bilbo Baggins Mar 9 '18 at 8:27
1

Hey guys sorry to post the answer to my own question but I uninstalled Metamask and Google Chrome and reinstalled and it started working. I am sorry I can't be more specific about why this happened. Thank you all for your comments though.

| improve this answer | |
  • 1
    Hi. I had the same error while trying to deploy ICO. Situation was the same - token deployment was successful, but ICO contract got error. Fix for me was just to reinstall MetaMask -> reload Chrome -> restore MetaMask form seed phrase. Very strange... – Vanja Dev May 21 '18 at 12:34
0

if the error message is gas limitation, you can try to increase gas limit. In remix, you can just increase this value in run panel.

| improve this answer | |
  • Sorry I should have stated I did try all sorts of values for the gas and it didn't work so I think it might be an always failing transaction – darknightsy Mar 7 '18 at 2:48
  • can you post the err msg? – Mavlarn Mar 7 '18 at 2:53
  • Yea mate I have added the error message – darknightsy Mar 7 '18 at 3:04
  • I can create the crowdSale contract in my remix IDE. I created a ABCD contract, got the address, and created the crowdSale with the params. Based on your error message, it seems like it's the problem of. your remix environment. If you use chrome extension, can you try to test in browser or remix IDE of Mist? – Mavlarn Mar 7 '18 at 5:23
  • I have tried in Brave browser and in Firefox from multiple pcs – darknightsy Mar 7 '18 at 10:21

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.