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

Ich habe das Tutorial befolgt, das hier zu finden ist: https://steemit.com/ethereum/@maxnachamkin/how-to-create-your-own-ethereum-token-in-an-hour-erc20-verified

Ich habe versucht, diesen Vertrag mit Remix zu erstellen. Ich musste einige Änderungen am Code vornehmen, der auf der Website veröffentlicht wurde, da er veraltet war. Ich musste throw in revert() ändern und sha3() in keccak256() ändern.

Remix wird den Vertrag nicht zustande bringen. Dort heißt es: "Dieser Vertrag setzt nicht alle Funktionen um und kann daher nicht erstellt werden."

Was mache ich falsch? Jede Hilfe wird sehr geschätzt.

Pragma Solidität ^0.4.4;

Vertragstoken {
    Funktion totalSupply() Konstante öffentliche Renditen (uint totalSupply);
    Funktion balanceOf(address _owner) Konstante öffentliche Renditen (uint balance);
    Funktion transfer (Adresse _to, uint _value) öffentliche Rückgaben (bool Erfolg);
    Funktion transferFrom (Adresse _from, Adresse _to, uint _value) öffentliche Rückgaben (bool Erfolg);
    Funktion genehmigen (Adresse _spender, uint _value) öffentliche Rückgaben (bool Erfolg);
    Funktion Allowance (Adresse _owner, Adresse _spender) Konstante öffentliche Renditen (uint verbleibend);
    event Transfer (Adresse indexiert _from, Adresse indexiert _to, uint _value);
    event Approval (address indexed _owner, address indexed _spender, uint _value);
}



Vertrag StandardToken ist Token {

    Funktion transfer (Adresse _to, uint256 _value) öffentliche Rückgabe (bool Erfolg) {
        //Standard geht davon aus, dass totalSupply nicht über dem Maximum liegen kann (2^256 - 1).
        //Wenn Ihr Token totalSupply auslässt und im Laufe der Zeit weitere Token ausgeben kann, müssen Sie prüfen, ob es nicht umgebrochen wird.
        // Ersetzen Sie stattdessen das if durch dieses.
        //if (salden[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
        if (salden[msg.sender] >= _value && _value > 0) {
            Salden[msg.sender] -= _value;
            Salden[_to] += _value;
            Transfer(msg.sender, _to, _value);
            gib true zurück;
        } Else {Rückgabe falsch; }
    }

    Funktion transferFrom (Adresse _from, Adresse _to, uint256 _value) öffentliche Rückgabe (bool Erfolg) {
        //das gleiche wie oben. Ersetzen Sie diese Zeile durch die folgende, wenn Sie sich gegen Wrapping-Einheiten schützen möchten.
        //if (salden[_from] >= _value && erlaubt[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
        if (salden[_from] >= _value && erlaubt[_from][msg.sender] >= _value && _value > 0) {
            Salden[_to] += _value;
            Salden[_von] -= _Wert;
            erlaubt[_from][msg.sender] -= _value;
            Transfer(_from, _to, _value);
            gib true zurück;
        } Else {Rückgabe falsch; }
    }

    Funktion balanceOf (Adresse _owner) konstante öffentliche Rückgaben (uint256 balance) {
        Guthaben zurückgeben[_owner];
    }

    Funktion genehmigen (Adresse _spender, uint256 _value) öffentliche Rückgaben (boolescher Erfolg) {
        erlaubt[msg.sender][_spender] = _value;
        Genehmigung (msg.sender, _spender, _value);
        gib true zurück;
    }

    Funktion Allowance (Adresse _owner, Adresse _spender) Konstante öffentliche Rückgaben (uint256 verbleibend) {
      Rückgabe erlaubt[_owner][_spender];
    }

    Zuordnung (Adresse => uint256) Salden;
    Mapping (Adresse => Mapping (Adresse => uint256)) erlaubt;
    uint256 public totalSupply;
}


// Benennen Sie diesen Vertrag wie Sie möchten
Vertrag TestToken ist StandardToken {

    Funktion() öffentlich {
        //Wenn Ether an diese Adresse gesendet wird, schicke es zurück.
        zurückkehren();
    }

    /* Öffentliche Variablen des Tokens */

    /*
    HINWEIS:
    Die folgenden Variablen sind OPTIONALE Eitelkeiten. Man muss sie nicht einbeziehen.
    Sie ermöglichen es, den Token-Vertrag anzupassen und beeinflussen in keiner Weise die Kernfunktionalität.
    Einige Wallets/Schnittstellen machen sich möglicherweise nicht einmal die Mühe, sich diese Informationen anzusehen.
    */
    Zeichenfolge öffentlicher Name = "TestToken"; //Phantasiename: zB Simon Bucks
    uint8 öffentliche Dezimalstellen = 0; //Wie viele Dezimalstellen sollen angezeigt werden. dh. Es könnten 1000 Basiseinheiten mit 3 Dezimalstellen sein. Bedeutung 0,980 SBX = 980 Basiseinheiten. Es ist, als würde man 1 Wei mit 1 Ether vergleichen.
    Zeichenfolge öffentliches Symbol = "TTT"; //Eine Kennung: zB SBX
    Zeichenfolge öffentliche Version = "1.0"; //menschlicher 0,1-Standard. Nur ein willkürliches Versionierungsschema.

//
// DIESE WERTE FÜR IHREN TOKEN ÄNDERN
//

// Stellen Sie sicher, dass dieser Funktionsname mit dem obigen Vertragsnamen übereinstimmt. Wenn Ihr Token also TutorialToken heißt, stellen Sie sicher, dass der obige //Vertragsname auch TutorialToken statt ERC20Token lautet

    Funktion TestToken() öffentlich {
        Guthaben [msg.sender] = 100000; // Dem Ersteller alle anfänglichen Token geben (z. B. 100000)
        Gesamtversorgung = 100000; // Gesamtvorrat aktualisieren (z. B. 100000)
        name = "TestToken"; // Legen Sie den Namen für Anzeigezwecke fest
        Dezimalstellen = 0; // Anzahl der Dezimalstellen für Anzeigezwecke
        symbol = "TTT"; // Symbol für Anzeigezwecke setzen
    }

    /* Genehmigt und ruft dann den empfangenden Vertrag auf */
    Funktion genehmigenAndCall (Adresse _spender, uint256 _value, Bytes _extraData) öffentliche Rückgabe (bool Erfolg) {
        erlaubt[msg.sender][_spender] = _value;
        Genehmigung (msg.sender, _spender, _value);

        // Rufen Sie die Funktion "receiveApproval" für den Vertrag auf, über den Sie benachrichtigt werden möchten. Dadurch wird die Funktionssignatur manuell erstellt, sodass hier kein Vertrag nur dafür eingefügt werden muss.
        //receiveApproval(Adresse _from, uint256 _value, Adresse _tokenContract, Bytes _extraData)
        // es wird davon ausgegangen, dass wann der Aufruf erfolgreich *sollte*, sonst würde man stattdessen Vanilla Approve verwenden.
        if(!_spender.call(bytes4(bytes32(keccak256("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)) {revert(); }
        gib true zurück;
    }
}