Remix: Dieser Vertrag implementiert nicht alle Funktionen und kann daher nicht erstellt werden

Ich bin neu hier und code mit openzeppelin framework 2.2.0. Beim Kompilieren mit Solidity 0.5.8 ist kein Fehler aufgetreten. Aber wenn ich den Vertrag bereitstellen werde, habe ich keinen Bytecode und kann nicht mit Vertrag interagieren "Dieser Vertrag implementiert nicht alle Funktionen und kann daher nicht erstellt werden."

contract SampleCrowdsale is ERC20Detailed, Ownable, FinalizableCrowdsale, TokenTimelock {
    constructor () public ERC20Detailed("SampleCrowdsale", "SCRT", 15) {

    }

    mapping (address => uint256) private balances;

    uint256 public totalSupply = 1000000000000000000000000; 
    uint256 public constant TOKENS_SALE_HARD_CAP = 650000000000000000000000;
    uint256 public constant BASE_RATE = 32500000;

    uint64 private constant dateHOTSale = 1517961600;
    uint64 private constant dateSaleA = 1557991800 - 7 hours;
    uint64 private constant dateSaleB = 1557993600 - 7 hours;
    uint64 private constant dateSaleC = 1557995400 - 7 hours;
    uint64 private constant dateSaleD = 1557999000 - 7 hours;
    uint64 private constant date17May2019 = 1557999180 - 7 hours;

    uint256[4] private roundCaps = [
        100000000000000000000000, 
        250000000000000000000000,
        450000000000000000000000, 
        650000000000000000000000 
    ];
    uint8[4] private roundDiscountPercentages = [50, 25, 12, 6];

    uint64 private constant dateTeamTokensLockedTill = 1557999360 - 7 hours;

    bool public _finalized = false;

    address public timelockContractAddress;

    modifier inProgress {
        require(totalSupply < TOKENS_SALE_HARD_CAP && !_finalized && now >= dateHOTSale);
        _;
    }

    modifier beforeEnd {
        require(!_finalized);
        _;
    }

    function sampleCrowdSale() public {
        }

    modifier tradingOpen {
        require(_finalized);
        _;
    }

    function () external payable {
        purchaseTokens(msg.sender);
    }

    function purchaseTokens(address _beneficiary) public payable inProgress {
        require(msg.value >= 0.05 ether);
        uint256 tokens = computeTokenAmount(msg.value);
        require(totalSupply.add(tokens) <= TOKENS_SALE_HARD_CAP);
        doIssueTokens(_beneficiary, tokens);
        address(0).transfer(address(this).balance);
    }

    function issueTokens(address _beneficiary, uint256 _tokens) public onlyOwner beforeEnd {
        doIssueTokens(_beneficiary, _tokens);
    }

    function doIssueTokens(address _beneficiary, uint256 _tokens) internal {
        require(_beneficiary != address(0));

        totalSupply = totalSupply.add(_tokens);
        balances[_beneficiary] = balances[_beneficiary].add(_tokens);

        emit Transfer(address(0), _beneficiary, _tokens);
    }

    function price() public view returns (uint256 tokens) {
        return computeTokenAmount(1 ether);
    }

    function computeTokenAmount(uint256 ethAmount) internal view returns (uint256 tokens) {
        uint256 tokenBase = (ethAmount.mul(BASE_RATE)/10000000000000)*10000000000;//18 decimals to 15 decimals, set precision to 5 decimals
        uint8 roundNum = currentRoundIndex();
        tokens = tokenBase.mul(100)/(100 - (roundDiscountPercentages[roundNum]));
        while(tokens.add(totalSupply) > roundCaps[roundNum] && roundNum < 4){
           roundNum++;
           tokens = tokenBase.mul(100)/(100 - (roundDiscountPercentages[roundNum]));
        }
    }

    function currentRoundIndex() internal view returns (uint8 roundNum) {
        roundNum = currentRoundIndexByDate();

        while(roundNum < 4 && totalSupply > roundCaps[roundNum]) {
            roundNum++;
        }
    }

    function currentRoundIndexByDate() internal view returns (uint8 roundNum) {
        require(now <= date17May2019);
        if(now > dateSaleD) return 4;
        if(now > dateSaleC) return 3;
        if(now > dateSaleB) return 2;
        if(now > dateSaleA) return 1;
        else return 0;
    }

    function finalize() public onlyOwner beforeEnd {
        uint256 lockedTokens = 230000000000000000000000;
        uint256 partnerTokens = 260000000000000000000000;

        issueLockedTokens(lockedTokens);
        issuePartnerTokens(partnerTokens);

        totalSupply = totalSupply.add(lockedTokens+partnerTokens);

        _finalized = true;

        address(0).transfer(address(this).balance);
    }

    function issueLockedTokens(uint lockedTokens) internal {
        TokenTimelock lockedTeamTokens = new TokenTimelock(this, address(0), dateTeamTokensLockedTill);
        timelockContractAddress = address(lockedTeamTokens);
        balances[timelockContractAddress] = balances[timelockContractAddress].add(lockedTokens);
        emit Transfer(address(0), timelockContractAddress, lockedTokens);
    }

    function issuePartnerTokens(uint partnerTokens) internal{
        balances[address(0)] = partnerTokens;
        emit Transfer(address(0), address(0), partnerTokens);
    }

    function transferFrom(address _from, address _to, uint256 _value) public tradingOpen returns (bool) {
        return transferFrom(_from, _to, _value);
    }

    function transfer(address _to, uint256 _value) public tradingOpen returns (bool) {
        return transfer(_to, _value);
    }
}

Antworten (2)

Wenn Sie den Vertrag von Remix IDE bereitstellen, sollten Sie SampleCrowdsale auf der Registerkarte „Ausführen “ auswählen .

Remix-IDE

Entschuldigung, wenn ich Ihre Antwort mit einem Durcheinander antworte oder kommentiere, sehen Sie sich bitte meine Bilder an.

Die Nachricht bedeutet, was sie sagt.

Angesichts des Umfangs und der Komplexität des Codes, mit dem Sie arbeiten, ist dies kein gutes Projekt zum Lernen. Ich hoffe, dies dient nur der Übung und Sie erwägen nicht, andere dazu zu verleiten, ihre Gelder in die Hände eines Codes zu legen, den Sie nicht vollständig verstehen.

Es ist eine Menge Code zu erforschen, also werde ich erklären, wonach Sie suchen sollten.

Wenn ein Vertrag eine undefinierte Funktion von einem anderen Vertrag erbt, verpflichtet er sich, eine Funktionsimplementierung bereitzustellen. Ein Vertrag mit undefinierten Funktionen wird kompiliert, kann aber nicht bereitgestellt werden. Dies liegt daran, dass ein Vertrag mit einer Funktion, die nicht weiß, was zu tun ist, in der Kette keinen Sinn machen würde.

Studieren Sie dieses kleine Beispiel in Remix.

pragma solidity 0.5.1;

contract Interface {
    function something() public;
    function somethingElse() public;
}

// does not implement all functions
contract Undeployable is Interface {
    uint x;
    function something() public {
        // do something
        x=1;
    }
}

contract Deployable is Undeployable {
    uint y;
    function somethingElse() public {
        // do something
        y=1;
    }
}

Die Funktionsinhalte sind nur Stubs ohne Bedeutung. Der Vererbungsgraph beginnt mit einer Verpflichtung zur Implementierung zweier undefinierter Funktionen. Eine dieser Funktionen wird in definiert Undeployableund vom nächsten Vertrag übernommen Deployable, der die fehlende Funktion implementiert und erbt something(). Dies erfüllt die Verpflichtungen, die mit der Vererbung beginnen Interface. Deployableist Interface, falls das nicht klar ist.

Sie suchen also nach etwas, wahrscheinlich in der Schnittstelle, das nicht implementiert ist. Dies ist in jedem Fall ein Sicherheitssystem. Ihr Vertrag wird keine ERC20-kompatible Schnittstelle darstellen, bis alle in der Spezifikation definierten Funktionen implementiert sind. Dieser Sicherheitsstopp dient der Strukturierung des Codes mit einem Schnittstellenvertrag, der die notwendigen Funktionen beschreibt. Es kann etwas zeitaufwändig sein, die fehlende Funktion zu finden, aber das ist es, was Sie lokalisieren müssen.

Ich hoffe es hilft.

Remix: Dieser Vertrag implementiert nicht alle Funktionen und kann daher nicht erstellt werden
AntwortenHierDatenschutz-Bestimmungen1y, 0v