Продолжайте получать сообщение об ошибке CrowdSale: требуемый газ превышает норму или всегда завершается сбоем транзакции.

Привет, ребята, я изо всех сил пытаюсь запустить этот код краудсейла в Remix. Я развертываю токен ABCD без проблем, но когда я запускаю код краудсейла с «TokenAddress», «startTime», «endTime», я получаю постоянно сбойную ошибку транзакции. Может ли кто-нибудь увидеть, что может быть за транзакция? Это три кода, которые я использую, а также стандартный 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);
    }
}

РЕДАКТИРОВАТЬ вот сообщение об ошибке:

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)