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

Question

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

Du

ERC223Ich kann Vertrag nicht umsetzen . Remix sagte

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

Bitte sagen Sie mir, was es schlimm ist.

Pragma Solidität ^0.4.25;

Bibliothek SafeMath {
    Funktion mul(uint256 a, uint256 b) interne reine Rückgaben (uint256) {
        wenn (a == 0) {
            0 zurückgeben;
        }
        uint256 c = a * b;
        behaupten (c / a == b);
        gib c zurück;
    }

    Funktion div(uint256 a, uint256 b) interne reine Rückgaben (uint256) {
        uint256 c = a / b;
        gib c zurück;
    }

    Funktion sub(uint256 a, uint256 b) interne reine Rückgaben (uint256) {
        behaupten (b = a);
        gib c zurück;
    }
}

Vertrag Besitzbar {
    Adresse öffentlicher Eigentümer;

    event OwnershipTransferred (Adresse indiziert vorheriger Eigentümer, Adresse indiziert neuer Eigentümer);

    Funktion Ownable() öffentlich {
        Eigentümer = msg.sender;
    }
    Modifikator onlyOwner() {
        require(msg.sender == Eigentümer);
        _;
    }
    Funktion transferOwnership(Adresse newOwner) onlyOwner public {
        require(newOwner != address(0));
        OwnershipTransferred(Besitzer, neuerBesitzer);
        Eigentümer = neuer Eigentümer;
    }
}

Vertrag ERC223 {
    uint public totalSupply;

    Funktion balanceOf (Adresse wen) öffentliche Ansicht gibt zurück (uint);
    Funktion totalSupply() öffentliche Ansicht gibt zurück (uint256 _supply);
    Funktionsübertragung (Adresse an, uint-Wert) Öffentliche Rückgaben (bool ok);
    Funktionsübertragung (Adresse an, uint-Wert, Bytes-Daten) Öffentliche Rückgaben (bool ok);
    Funktionsübertragung (Adresse an, uint-Wert, Bytedaten, Zeichenfolge customFallback) Öffentliche Rückgaben (bool ok);
    Ereignisübertragung (Adresse indiziert von, Adresse indiziert auf, uint-Wert, Bytes indizierte Daten);

    function name() öffentliche Ansicht gibt zurück (string _name);
    function symbol() öffentliche Ansicht gibt zurück (string _symbol);
    Funktion decimals() öffentliche Ansicht gibt zurück (uint8 _decimals);

    Funktion transferFrom (Adresse _from, Adresse _to, uint256 _value) öffentliche Rückgaben (bool Erfolg);
    Funktion genehmigen (Adresse _spender, uint256 _value) Öffentliche Rückgaben (bool Erfolg);
    Funktion Allowance (Adresse _owner, Adresse _spender) öffentliche Ansicht gibt zurück (uint256 verbleibend);
    event Transfer (address indexed _from, address indexed _to, uint256 _value);
    event Approval (address indexed _owner, address indexed _spender, uint _value);
}



 Vertrag ContractReceiver {

    Struktur TKN {
        Adresse Absender;
        uint-Wert;
        Bytes Daten;
        Bytes4 Zeichen;
    }

    Funktions-TokenFallback (Adresse _from, uint _value, Bytes _data) public pure {
        TKN Speicher tkn;
        tkn.sender = _from;
        tkn.value = _value;
        tkn.data = _data;
        uint32 u = uint32(_data[3]) + (uint32(_data[2]) uint256) public balanceOf;
    Zuordnung (Adresse => Zuordnung (Adresse => uint256)) öffentliche Zulage;
    Zuordnung (Adresse => bool) öffentliches eingefrorenesKonto;
    Mapping (Adresse => uint256) public unlockUnixTime;

    Ereignis FrozenFunds (Adresse indiziertes Ziel, bool eingefroren);
    Ereignis LockedFunds (Adresse indiziertes Ziel, uint256 gesperrt);
    event Burn (Adresse indiziert von, uint256 Betrag);
    event Mint (Adresse indexiert auf, uint256 Betrag);
    Ereignis MintFinished ();

    Funktion New() öffentlich {
        Eigentümer = Gründer;
        balanceOf[Gründer] = totalSupply.mul(40).div(100);
        balanceOf[AirDrop] = totalSupply.mul(50).div(100);
        balanceOf[sale] = totalSupply.mul(10).div(100);
    }

    Funktionsname() öffentliche Ansicht gibt zurück (Zeichenfolge _name) {
        Rückgabename;
    }

    function symbol() öffentliche Ansicht gibt zurück (string _symbol) {
        Rückkehrsymbol;
    }

    Funktion decimals() öffentliche Ansicht gibt zurück (uint8 _decimals) {
        Dezimalstellen zurückgeben;
    }

    Funktion totalSupply() öffentliche Ansicht gibt zurück (uint256 _totalSupply) {
        Gesamtversorgung zurückgeben;
    }

    Funktion balanceOf(address _owner) öffentliche Ansicht gibt zurück (uint256 balance) {
        return balanceOf[_owner];
    }

    Funktion freezeAccounts(address[] Ziele, bool isFrozen) onlyOwner public {
        erfordern (targets.length > 0);

        für (uint j = 0; j 0
                && Ziele.Länge == unixTimes.Länge);

        for(uint j = 0; j 0
                && eingefrorenesKonto[msg.sender] == falsch
                && eingefrorenesKonto[_to] == falsch
                && jetzt > unlockUnixTime[msg.sender]
                && jetzt > unlockUnixTime[_to]);

        if (isContract(_to)) {
            require(balanceOf[msg.sender] >= _value);
            balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
            balanceOf[_to] = balanceOf[_to].add(_value);
            assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
            Transfer(msg.sender, _to, _value, _data);
            Transfer(msg.sender, _to, _value);
            gib true zurück;
        } anders {
            RücktransferToAddress(_to, _value, _data);
        }
    }

    Funktion transfer (Adresse _to, uint _value, Bytes _data) öffentliche Rückgabe (bool Erfolg) {
        require(_value > 0
                && eingefrorenesKonto[msg.sender] == falsch
                && eingefrorenesKonto[_to] == falsch
                && jetzt > unlockUnixTime[msg.sender]
                && jetzt > unlockUnixTime[_to]);

        if (isContract(_to)) {
            RücktransferToContract(_to, _value, _data);
        } anders {
            RücktransferToAddress(_to, _value, _data);
        }
    }

    Funktion transfer (Adresse _to, uint _value) öffentliche Rückgaben (boolescher Erfolg) {
        require(_value > 0
                && eingefrorenesKonto[msg.sender] == falsch
                && eingefrorenesKonto[_to] == falsch
                && jetzt > unlockUnixTime[msg.sender]
                && jetzt > unlockUnixTime[_to]);

        Bytes Speicher leer;
        if (isContract(_to)) {
            return transferToContract(_to, _value, empty);
        } anders {
            return transferToAddress(_to, _value, empty);
        }
    }


    Funktion isContract(address _addr) Privatansicht gibt zurück (bool is_contract) {
        Einheitslänge;
        Montage {
            Länge := extcodesize(_addr)
        }
        return (Länge > 0);
    }

    Funktion transferToAddress (Adresse _to, uint _value, Bytes _data) private Rückgabe (bool Erfolg) {
        require(balanceOf[msg.sender] >= _value);
        balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
        balanceOf[_to] = balanceOf[_to].add(_value);
        Transfer(msg.sender, _to, _value, _data);
        Transfer(msg.sender, _to, _value);
        gib true zurück;
    }

    Funktion transferToContract (Adresse _to, uint _value, Bytes _data) private Rückgaben (bool Erfolg) {
        require(balanceOf[msg.sender] >= _value);
        balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
        balanceOf[_to] = balanceOf[_to].add(_value);
        ContractReceiver Empfänger = ContractReceiver(_to);
        receiver.tokenFallback (msg.sender, _value, _data);
        Transfer(msg.sender, _to, _value, _data);
        Transfer(msg.sender, _to, _value);
        gib true zurück;
    }

    Funktion transferFrom (Adresse _from, Adresse _to, uint256 _value) öffentliche Rückgabe (bool Erfolg) {
        require(_to != Adresse(0)
                && _value > 0
                && balanceOf[_from] >= _value
                && Zulage[_from][msg.sender] >= _value
                && eingefrorenesKonto[_from] == falsch
                && eingefrorenesKonto[_to] == falsch
                && jetzt > unlockUnixTime[_from]
                && jetzt > unlockUnixTime[_to]);

        balanceOf[_from] = balanceOf[_from].sub(_value);
        balanceOf[_to] = balanceOf[_to].add(_value);
        Allowance[_from][msg.sender] = Allowance[_from][msg.sender].sub(_value);
        Transfer(_from, _to, _value);
        gib true zurück;
    }
    Funktion genehmigen (Adresse _spender, uint256 _value) öffentliche Rückgaben (boolescher Erfolg) {
        Zulage[msg.sender][_spender] = _value;
        Genehmigung (msg.sender, _spender, _value);
        gib true zurück;
    }
    Funktion Allowance (Adresse _owner, Adresse _spender) öffentliche Ansicht gibt zurück (uint256 verbleibend) {
        Rückkehrerlaubnis[_owner][_spender];
    }
    Funktion Burn (Adresse _from, uint256 _unitAmount) onlyOwner public {
        require(_unitAmount > 0
                && balanceOf[_from] >= _unitAmount);

        balanceOf[_from] = balanceOf[_from].sub(_unitAmount);
        totalSupply = totalSupply.sub(_unitAmount);
        Burn(_from, _unitAmount);
    }


    Modifikator canMint() {
        require(!mintingFinished);
        _;
    }
    function mint(address _to, uint256 _unitAmount) onlyOwner canMint public return (bool) {
        require(_unitAmount > 0);

        totalSupply = totalSupply.add(_unitAmount);
        balanceOf[_to] = balanceOf[_to].add(_unitAmount);
        Minze (_to, _unitAmount);
        Transfer(Adresse(0), _to, _unitAmount);
        gib true zurück;
    }
    function finishMinting() onlyOwner canMint öffentliche Rückgabe (bool) {
        mintingFinished = wahr;
        MintFertig ();
        gib true zurück;
    }
    Funktion "distributeAirdrop(address[] Adressen, uint256 Betrag)" öffentliche Rückgaben (bool) {
        erfordern (Menge > 0
                && adressen.länge > 0
                && eingefrorenesKonto[msg.sender] == falsch
                && jetzt > unlockUnixTime[msg.sender]);

        Betrag = Betrag.mul(1e8);
        uint256 Gesamtbetrag = Betrag.mul (Adressen.Länge);
        require(balanceOf[msg.sender] >= totalAmount);

        for (uint j = 0; j unlockUnixTime[adressen[j]]);

            balanceOf[adressen[j]] = balanceOf[adressen[j]].add(betrag);
            Transfer(msg.sender, Adressen[j], Betrag);
        }
        balanceOf[msg.sender] = balanceOf[msg.sender].sub(totalAmount);
        gib true zurück;
    }

    Funktion verteileAirdrop(Adresse[] Adressen, uint[] Beträge) Öffentliche Rückgaben (bool) {
        require(adressen.länge > 0
                && Adressen.Länge == Beträge.Länge
                && eingefrorenesKonto[msg.sender] == falsch
                && jetzt > unlockUnixTime[msg.sender]);

        uint256 Gesamtbetrag = 0;

        for(uint j = 0; j 0
                    && Adressen[j] != 0x0
                    && eingefrorenesKonto[adressen[j]] == falsch
                    && jetzt > unlockUnixTime[adressen[j]]);

            Beträge[j] = Beträge[j].mul(1e8);
            Gesamtbetrag = Gesamtbetrag.add (Beträge [j]);
        }
        require(balanceOf[msg.sender] >= totalAmount);

        für (j = 0; j 0
                && Adressen.Länge == Beträge.Länge);

        uint256 Gesamtbetrag = 0;

        für (uint j = 0; j 0
                    && Adressen[j] != 0x0
                    && eingefrorenesKonto[adressen[j]] == falsch
                    && jetzt > unlockUnixTime[adressen[j]]);

            Beträge[j] = Beträge[j].mul(1e8);
            require(balanceOf[adressen[j]] >= Beträge[j]);
            balanceOf[adressen[j]] = balanceOf[adressen[j]].sub(beträge[j]);
            Gesamtbetrag = Gesamtbetrag.add (Beträge [j]);
            Überweisung(Adressen[j], msg.sender, Beträge[j]);
        }
        balanceOf[msg.sender] = balanceOf[msg.sender].add(totalAmount);
        gib true zurück;
    }
}

Antworten (1)

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

gute Stimmung · Answer 1

gute Stimmung

Ändere das:

contract ContractReceiver

Dazu:

contract ContractReceiver is ERC223

Und dann ContractReceiverstatt ERC223.

Außerdem sollten Sie dies besser ändern:

contract ERC223

Dazu:

interface ERC223

Und dann uint public totalSupplyvon ERC223zu bewegen ContractReceiver.

Tatsächlich ist es möglich, dass Sie es tun müssen; Ich bezweifle, dass das contract ERC223sonst kompilieren wird.

Du

danke für die antwort. Aber ich war nicht in der Lage zu laufen wie immer.

gute Stimmung

@yoru: Remix weist Sie auf die Kompilierungsfehler hin. Sie sollten zumindest wissen, wie man sie liest und löst. Wenn Sie ein Problem mit dieser Art von Fehlern haben, dann wird es viel schlimmer, wenn Sie anfangen, sich mit Laufzeitfehlern zu befassen (auf die Sie niemand hinweisen wird, im Gegensatz zu Kompilierungsfehlern). Wenn Sie immer noch Probleme mit einem bestimmten Kompilierungsfehler haben, der von Remix ausgegeben wird, sollten Sie ihn zumindest hier posten und nach einer bestimmten Richtung fragen. Was Sie hier stattdessen getan haben, ist "meinen Code löschen und erwarten, dass jemand anderes alles für mich löst", was niemanden dazu ermutigt, Ihnen zu helfen!

Du

Danke für die Hilfe. Kompilierfehler finde ich nicht. aber ich kann ERC223 nicht bereitstellen. Aber ich kann einen anderen Vertrag bereitstellen.

gute Stimmung

@yoru: Hast du gelesen, was ich geschrieben habe? Sie können contract nicht bereitstellen ERC223, da er die darin deklarierten Funktionen nicht implementiert! Sie sollten sie entweder in diesem Vertrag oder im erbenden Vertrag implementieren und stattdessen diesen Vertrag bereitstellen.

Du

Es tut mir Leid. Ich bin nicht gut in Englisch. Ich lese gründlich.

gute Stimmung

@yoru: Verstehst du, WARUM du diesen Vertrag nicht bereitstellen kannst?

Schwarze Skala

In fact, it is possible that you have to do it; I doubt that contract ERC223 will compile otherwise.@goodvibration Ich verwende immer Verträge anstelle von Schnittstellen, genau aus dem Grund, dass Sie Variablen darin einbetten können, was besonders für Konstanten nützlich ist. Es wird gut als Vertrag kompilieren.

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

Du

Antworten (1)

gute Stimmung

Du

gute Stimmung

Du

gute Stimmung

Du

gute Stimmung

Schwarze Skala

remix erc20 Fehler: Dieser Vertrag implementiert nicht alle Funktionen und kann daher nicht erstellt werden

JavascriptVM(remix)-Fehler beim Bereitstellen mehrerer Token

Welchen sollten wir ERC-20 oder ERC-223 verwenden?

Warum sendet dieser Vertrag die Token nicht an den Ersteller?

Wie kann man einen Smart Contract kompilieren und bereitstellen, ohne einen vollständigen Knoten auszuführen?

Begrenzen Sie Gas und vermeiden Sie Schleifen in Ihren Funktionen oder Aktionen, die große Speicherbereiche verändern [duplizieren]

Ich interessiere mich für die Erstellung eines neuen Tokens und habe einige Fragen

Remix – Initialisierung der Vertragserstellung gibt Daten mit einer Länge von mehr als 24576 Bytes zurück. Die Bereitstellung wird wahrscheinlich fehlschlagen). Was kann getan werden?

Ethereum-Vertragsproblem

erweiterter Crowdsale-Smart-Vertrag wird nicht im Testnetz bereitgestellt