Bauen von Ethereum Dapps: Stimmen mit Sonderangebot

Kernpunkte

• Verwenden Sie benutzerdefinierte Token in DAO für die Abstimmung von Vorschlägen, einschließlich Löschen von Einträgen und Adressen der schwarzen Liste, wodurch die dezentrale Governance und operative Flexibilität verbessert werden.
• Umsetzen Sie einen leistungsstarken Stimmmechanismus, der die Überprüfung des Token -Eigentums und die Verriegelung von Token während der Abstimmung zur Verhinderung von Manipulationen und der Gewährleistung des Engagements erfordert.
• Entwurfsvorschlag und Abstimmungssysteme mit strukturierten Fristen und Implementierungsstandards, um ordnungsgemäße und effiziente DAO -Operationen aufrechtzuerhalten.
• Besprechen Sie potenzielle Sicherheitsprobleme, indem die Erstellung von Vorschlägen auf nur Mitgliedsmitglieder beschränkt und die von den DAO-Eigentümern kontrollierten Notfalllöschfunktionen ermöglicht.
• Erforschen Sie die technischen Herausforderungen und Lösungen für die Bereitstellung großer intelligenter Verträge auf Ethereum und unterstreichen die Bedeutung der Codeoptimierung für die Verwaltung von Gaskosten und die sichere Bereitstellung.

Der fünfte Teil dieser Tutorial -Serie führt vor, dass das Erstellen eines DAPP mithilfe von Ethereum das Hinzufügen von Inhalten zur Geschichte und zum Hinzufügen der Möglichkeiten zum Kauf von Token bei DAO und der Übermittlung von Inhalten an die Geschichte für die Teilnehmer. Jetzt ist die Zeit für die endgültige Form von DAO: Abstimmung, Einbeziehung/Absolution von Blacklists und Dividendenverteilung und Rückzug. Wir werden einige zusätzliche Helferfunktionen hinzufügen.

Wenn Sie durch diese verwirrt sind, finden Sie den vollständigen Quellcode in der Codebasis.

Stimmen und Vorschläge

Wir werden Vorschläge und Stimmen verwenden, um abzustimmen. Wir brauchen zwei neue Strukturen:

<code>struct Proposal {
    string description;
    bool executed;
    int256 currentResult;
    uint8 typeFlag; // 1 = delete
    bytes32 target; // 提案目标的ID。例如，标志1，目标XXXXXX（哈希）表示删除submissions[hash]的提案
    uint256 creationDate;
    uint256 deadline;
    mapping (address => bool) voters;
    Vote[] votes;
    address submitter;
}

Proposal[] public proposals;
uint256 proposalCount = 0;
event ProposalAdded(uint256 id, uint8 typeFlag, bytes32 hash, string description, address submitter);
event ProposalExecuted(uint256 id);
event Voted(address voter, bool vote, uint256 power, string justification);

struct Vote {
    bool inSupport;
    address voter;
    string justification;
    uint256 power;
}</code>

Vorschläge enthalten eine Wählerkarte, um zu verhindern, dass Personen zweimal in einem Vorschlag stimmen, sowie einige andere Metadaten, die selbsterklärend sein sollten. Die Abstimmung wird eine Stimme von Ja oder gegen die Gründe für den Wähler und das Wahlrecht sein - die Anzahl der Token, die sie verwenden möchten, um für diesen Vorschlag zu stimmen. Wir haben auch eine Reihe von Vorschlägen hinzugefügt, damit wir sie irgendwo aufbewahren können, sowie einen Zähler, um die Anzahl der Vorschläge zu zählen.

Lassen Sie uns nun ihre Unterstützungsfunktionen aufbauen, beginnend mit der Abstimmungsfunktion:

<code>modifier tokenHoldersOnly() {
    require(token.balanceOf(msg.sender) >= 10**token.decimals());
    _;
}

function vote(uint256 _proposalId, bool _vote, string _description, uint256 _votePower) tokenHoldersOnly public returns (int256) {

    require(_votePower > 0, "At least some power must be given to the vote.");
    require(uint256(_votePower) <= token.balanceOf(msg.sender), "Vote power exceeds token balance.");
    Proposal storage p = proposals[_proposalId];

    require(p.executed == false, "Proposal must not have been executed already.");
    require(p.deadline > now, "Proposal must not have expired.");
    require(p.voters[msg.sender] == false, "User must not have already voted.");

    uint256 voteid = p.votes.length++;
    Vote storage pvote = p.votes[voteid];
    pvote.inSupport = _vote;
    pvote.justification = _description;
    pvote.voter = msg.sender;
    pvote.power = _votePower;

    p.voters[msg.sender] = true;

    p.currentResult = (_vote) ? p.currentResult + int256(_votePower) : p.currentResult - int256(_votePower);
    token.increaseLockedAmount(msg.sender, _votePower);

    emit Voted(msg.sender, _vote, _votePower, _description);
    return p.currentResult;
}</code>

Beachten Sie den Funktionsmodifikator: Indem wir diesen Modifikator zu unserem Vertrag hinzufügen, können wir ihn an jede zukünftige Funktion anhängen und sicherstellen, dass nur Token -Inhaber die Funktion ausführen können. Dies ist eine wiederverwendbare Sicherheitsprüfung!

Die Abstimmungsfunktion führt einige sanitäre Schecks durch, wie das Stimmrecht positiv, der Wähler hat genug Token, um tatsächlich abzustimmen usw. Wir nehmen dann den Vorschlag aus dem Speicher und stellen sicher, dass er weder abgelaufen noch ausgeführt wird. Es macht keinen Sinn, über einen abgeschlossenen Vorschlag abzustimmen. Wir müssen auch sicherstellen, dass diese Person noch nicht gestimmt hat. Wir können zulassen, dass das Abstimmungsrechte geändert wird, aber dies kann DAOs angesichts einiger Schlupflöcher, wie z. B. Menschen, die in letzter Minute ihre Stimmen zurückziehen Vielleicht ein Kandidat für eine zukünftige Version?

Wir registrieren dann die neue Stimme in den Vorschlag, ändern das aktuelle Ergebnis, um die Punktzahl zu finden, und geben schließlich das Abstimmungsveranstalter aus. Aber was ist token.increaselockedAmount?

Diese Logik erhöht die Anzahl der gesperrten Token für Benutzer. Diese Funktion kann nur vom Eigentümer des Token -Vertrags ausgeführt werden (diesmal wird gehofft, ein DAO zu sein) und verhindert, dass der Benutzer mehr als den gesperrten Betrag an sein Konto registriert wird. Dieses Schloss wird veröffentlicht, nachdem der Vorschlag fehlschlägt oder ausgeführt wird.

Schreiben wir nun eine Funktion zum Präsentieren von Löscheinträgen.

Abstimmung zum Löschen und Blacklist

Im ersten Teil dieser Serie haben wir drei Eintragslöschungsfunktionen geplant:

1. Eintrag löschen: Löschen Sie nach der Stimmabteilung den Zieleintrag. Abstimmungszeit: 48 Stunden.
2. Notfall -Löscheintrag [Nur Eigentümer]: Nur vom Eigentümer ausgelöst. Löschen Sie nach der Wahlbestätigung den Zieleintrag. Abstimmungszeit: 24 Stunden.
3. Notfallbilder [Nur Eigentümer]: Nur für Bildeinträge anwendbar. Nur vom Besitzer ausgelöst. Löschen Sie nach der Wahlbestätigung den Zieleintrag. Abstimmungszeit: 4 Stunden.

Das Löschen von fünf Einträgen für eine einzige Adresse führt zu einer schwarzen Liste.

Mal sehen, wie wir das jetzt machen. Löschen Sie zuerst die Funktion:

<code>struct Proposal {
    string description;
    bool executed;
    int256 currentResult;
    uint8 typeFlag; // 1 = delete
    bytes32 target; // 提案目标的ID。例如，标志1，目标XXXXXX（哈希）表示删除submissions[hash]的提案
    uint256 creationDate;
    uint256 deadline;
    mapping (address => bool) voters;
    Vote[] votes;
    address submitter;
}

Proposal[] public proposals;
uint256 proposalCount = 0;
event ProposalAdded(uint256 id, uint8 typeFlag, bytes32 hash, string description, address submitter);
event ProposalExecuted(uint256 id);
event Voted(address voter, bool vote, uint256 power, string justification);

struct Vote {
    bool inSupport;
    address voter;
    string justification;
    uint256 power;
}</code>

Nach der Übermittlung wird der Vorschlag zur Vorschlagliste hinzugefügt und der Zieleintrag wird vom Eintragshash festgestellt. Speichern Sie die Beschreibung und fügen Sie einige Standardwerte hinzu und berechnen Sie die Frist basierend auf dem Vorschlagstyp. Ein Ereignis zur Add-Proposal wird ausgestellt und die Gesamtzahl der Vorschläge steigt.

Als nächstes sehen wir, wie der Vorschlag umgesetzt wird. Um durchsetzbar zu sein, muss ein Vorschlag ausreichend Stimmen haben und seine Frist überschreiten. Die Ausführungsfunktion akzeptiert die ID des ausführenden Vorschlags. Es gibt keine einfache Möglichkeit, dass die EVM alle anstehenden Vorschläge gleichzeitig ausführen. Möglicherweise gibt es zu viele anhängige Vorschläge zur Ausführung und sie können erhebliche Änderungen an den Daten im DAO vornehmen, was die Gasgrenzen des Ethereum -Blocks überschreiten kann, was zu Transaktionsfehlern führt. Es ist viel einfacher, eine manuelle Ausführungsfunktion zu erstellen, die von jedem aufgerufen werden kann, der genau definierte Regeln entspricht, damit sich die Community auf Vorschläge konzentrieren kann, die ausgeführt werden müssen.

<code>modifier tokenHoldersOnly() {
    require(token.balanceOf(msg.sender) >= 10**token.decimals());
    _;
}

function vote(uint256 _proposalId, bool _vote, string _description, uint256 _votePower) tokenHoldersOnly public returns (int256) {

    require(_votePower > 0, "At least some power must be given to the vote.");
    require(uint256(_votePower) <= token.balanceOf(msg.sender), "Vote power exceeds token balance.");
    Proposal storage p = proposals[_proposalId];

    require(p.executed == false, "Proposal must not have been executed already.");
    require(p.deadline > now, "Proposal must not have expired.");
    require(p.voters[msg.sender] == false, "User must not have already voted.");

    uint256 voteid = p.votes.length++;
    Vote storage pvote = p.votes[voteid];
    pvote.inSupport = _vote;
    pvote.justification = _description;
    pvote.voter = msg.sender;
    pvote.power = _votePower;

    p.voters[msg.sender] = true;

    p.currentResult = (_vote) ? p.currentResult + int256(_votePower) : p.currentResult - int256(_votePower);
    token.increaseLockedAmount(msg.sender, _votePower);

    emit Voted(msg.sender, _vote, _votePower, _description);
    return p.currentResult;
}</code>

Wir erhalten den Vorschlag durch seine ID, prüfen Geben Sie das neue Ereignis aus (fügen Sie es an die Spitze des Vertrags hinzu). Der Assert -Anruf funktioniert genauso wie die dort erfordernde Anweisung: Assert wird normalerweise verwendet, um das Ergebnis zu "gründen". Erfordernis wird für Voraussetzungen verwendet. Funktionell sind sie gleich, der Unterschied besteht darin, dass die Assert -Anweisung keine Nachrichtenparameter akzeptieren kann, um Situationen zu verarbeiten, in denen sie versagen. Diese Funktion endet damit, dass Token für alle Stimmen im Vorschlag freigeschaltet wird.

Wir können andere Arten von Vorschlägen mit derselben Methode hinzufügen, aber zunächst aktualisieren wir die DeleteSubmission -Funktion, um die Benutzer mit fünf oder mehr Löschern auf ihrem Konto zu verbieten: Dies bedeutet, dass sie immer Inhalte einreichen, die die Community einweichte. Aktualisieren wir die DeleteSubmission -Funktion:

<code>struct Proposal {
    string description;
    bool executed;
    int256 currentResult;
    uint8 typeFlag; // 1 = delete
    bytes32 target; // 提案目标的ID。例如，标志1，目标XXXXXX（哈希）表示删除submissions[hash]的提案
    uint256 creationDate;
    uint256 deadline;
    mapping (address => bool) voters;
    Vote[] votes;
    address submitter;
}

Proposal[] public proposals;
uint256 proposalCount = 0;
event ProposalAdded(uint256 id, uint8 typeFlag, bytes32 hash, string description, address submitter);
event ProposalExecuted(uint256 id);
event Voted(address voter, bool vote, uint256 power, string justification);

struct Vote {
    bool inSupport;
    address voter;
    string justification;
    uint256 power;
}</code>

Das ist besser. Automatisch schwarzlistet und fünfmal gelöscht. Es ist unfair, keine schwarze Liste der Adressen zu geben, um einzubeziehen. Wir müssen auch die Blacklist -Funktion selbst definieren. Lassen Sie uns beide Dinge tun und die Gebühr festlegen, um die schwarze Liste beispielsweise auf 0,05 Ether zu stornieren.

<code>modifier tokenHoldersOnly() {
    require(token.balanceOf(msg.sender) >= 10**token.decimals());
    _;
}

function vote(uint256 _proposalId, bool _vote, string _description, uint256 _votePower) tokenHoldersOnly public returns (int256) {

    require(_votePower > 0, "At least some power must be given to the vote.");
    require(uint256(_votePower) <= token.balanceOf(msg.sender), "Vote power exceeds token balance.");
    Proposal storage p = proposals[_proposalId];

    require(p.executed == false, "Proposal must not have been executed already.");
    require(p.deadline > now, "Proposal must not have expired.");
    require(p.voters[msg.sender] == false, "User must not have already voted.");

    uint256 voteid = p.votes.length++;
    Vote storage pvote = p.votes[voteid];
    pvote.inSupport = _vote;
    pvote.justification = _description;
    pvote.voter = msg.sender;
    pvote.power = _votePower;

    p.voters[msg.sender] = true;

    p.currentResult = (_vote) ? p.currentResult + int256(_votePower) : p.currentResult - int256(_votePower);
    token.increaseLockedAmount(msg.sender, _votePower);

    emit Voted(msg.sender, _vote, _votePower, _description);
    return p.currentResult;
}</code>

Bitte beachten Sie, dass Token für Blacklist -Konten gesperrt werden, bis sie eine Gebühr gesendet haben, um die schwarze Liste zu stornieren.

Andere Stimmenarten

Versuchen Sie, andere Vorschläge zu schreiben, die auf der Inspiration für die oben geschriebenen Funktionen basieren. Sehen Sie sich die Github -Code -Basis des Projekts für Spoiler an und kopieren Sie den endgültigen Code von dort. Gehen wir für die Kürze zu den anderen Funktionen, die wir noch im DAO haben.

Ende des Kapitels

Sobald die Zeit- oder Kapitelgrenze der Geschichte erreicht ist, ist es Zeit, die Geschichte zu beenden. Nach dem Datum kann jeder die Endfunktion aufrufen, wodurch die Dividende zurückgezogen werden kann. Erstens brauchen wir eine neue StoryDao -Immobilie und eine Veranstaltung:

<code>modifier memberOnly() {
    require(whitelist[msg.sender]);
    require(!blacklist[msg.sender]);
    _;
}

function proposeDeletion(bytes32 _hash, string _description) memberOnly public {

    require(submissionExists(_hash), "Submission must exist to be deletable");

    uint256 proposalId = proposals.length++;
    Proposal storage p = proposals[proposalId];
    p.description = _description;
    p.executed = false;
    p.creationDate = now;
    p.submitter = msg.sender;
    p.typeFlag = 1;
    p.target = _hash;

    p.deadline = now + 2 days;

    emit ProposalAdded(proposalId, 1, _hash, _description, msg.sender);
    proposalCount = proposalId + 1;
}

function proposeDeletionUrgent(bytes32 _hash, string _description) onlyOwner public {

    require(submissionExists(_hash), "Submission must exist to be deletable");

    uint256 proposalId = proposals.length++;
    Proposal storage p = proposals[proposalId];
    p.description = _description;
    p.executed = false;
    p.creationDate = now;
    p.submitter = msg.sender;
    p.typeFlag = 1;
    p.target = _hash;

    p.deadline = now + 12 hours;

    emit ProposalAdded(proposalId, 1, _hash, _description, msg.sender);
    proposalCount = proposalId + 1;
}    

function proposeDeletionUrgentImage(bytes32 _hash, string _description) onlyOwner public {

    require(submissions[_hash].image == true, "Submission must be existing image");

    uint256 proposalId = proposals.length++;
    Proposal storage p = proposals[proposalId];
    p.description = _description;
    p.executed = false;
    p.creationDate = now;
    p.submitter = msg.sender;
    p.typeFlag = 1;
    p.target = _hash;

    p.deadline = now + 4 hours;

    emit ProposalAdded(proposalId, 1, _hash, _description, msg.sender);
    proposalCount = proposalId + 1;
}</code>

Erstellen wir dann die Funktion:

<code>function executeProposal(uint256 _id) public {
    Proposal storage p = proposals[_id];
    require(now >= p.deadline && !p.executed);

    if (p.typeFlag == 1 && p.currentResult > 0) {
        assert(deleteSubmission(p.target));
    }

    uint256 len = p.votes.length;
    for (uint i = 0; i < len; i++) {
        token.decreaseLockedAmount(p.votes[i].voter, p.votes[i].power);
    }

    p.executed = true;
    emit ProposalExecuted(_id);
}</code>

Einfach: Es deaktiviert die Geschichte, nachdem sie die gesammelten Gebühren an den Eigentümer gesendet und eine Veranstaltung gesendet haben. Aber in Wirklichkeit verändert dies die Gesamtsituation von DAO nicht wirklich: Andere Funktionen reagieren nicht auf das Ende. Erstellen wir also einen weiteren Modifikator:

<code>function deleteSubmission(bytes32 hash) internal returns (bool) {
    require(submissionExists(hash), "Submission must exist to be deletable.");
    Submission storage sub = submissions[hash];

    sub.exists = false;
    deletions[submissions[hash].submitter] += 1;
    if (deletions[submissions[hash].submitter] >= 5) {
        blacklistAddress(submissions[hash].submitter);
    }

    emit SubmissionDeleted(
        sub.index,
        sub.content,
        sub.image,
        sub.submitter
    );

    nonDeletedSubmissions -= 1;
    return true;
}</code>

Dann fügen wir diesen Modifikator allen Funktionen außer dem Rückzug hinzu, wie unten gezeigt:

<code>function blacklistAddress(address _offender) internal {
    require(blacklist[_offender] == false, "Can't blacklist a blacklisted user :/");
    blacklist[_offender] == true;
    token.increaseLockedAmount(_offender, token.getUnlockedAmount(_offender));
    emit Blacklisted(_offender, true);
}

function unblacklistMe() payable public {
    unblacklistAddress(msg.sender);
}

function unblacklistAddress(address _offender) payable public {
    require(msg.value >= 0.05 ether, "Unblacklisting fee");
    require(blacklist[_offender] == true, "Can't unblacklist a non-blacklisted user :/");
    require(notVoting(_offender), "Offender must not be involved in a vote.");
    withdrawableByOwner = withdrawableByOwner.add(msg.value);
    blacklist[_offender] = false;
    token.decreaseLockedAmount(_offender, token.balanceOf(_offender));
    emit Blacklisted(_offender, false);
}

function notVoting(address _voter) internal view returns (bool) {
    for (uint256 i = 0; i < proposals.length; i++) {
        if (proposals[i].executed == false && proposals[i].voters[_voter] == true) {
            return false;
        }
    }
    return true;
}</code>

Wenn im DAO noch übrige Token vorhanden sind, nehmen wir sie zurück und übernehmen Sie die Besitzer dieser Token, damit wir sie später für eine andere Geschichte verwenden können:

<code>bool public active = true;
event StoryEnded();</code>

UnlockMyTokens werden alle gesperrten Token entsperren, die ein bestimmter Benutzer sperren kann. Dies sollte nicht geschehen, und diese Funktion sollte mit vielen Tests entfernt werden.

DIP -Dividendenverteilung und Abnahme

Jetzt, da die Geschichte vorbei ist, müssen die Gebühren für Einsendungen allen Token -Inhabern zugewiesen werden. Wir können unsere Whitelist wiederverwenden, um alle zu markieren, die ihre Gebühren bereits zurückgezogen haben:

<code>function endStory() storyActive external {
    withdrawToOwner();
    active = false;
    emit StoryEnded();
}</code>

Wenn diese Dividenden nicht innerhalb eines bestimmten Zeitlimits zurückgezogen werden, kann der Eigentümer den verbleibenden Teil erhalten:

<code>modifier storyActive() {
    require(active == true);
    _;
}</code>

als Hausaufgaben, überlegen Sie, wie einfach oder schwierig es ist, diesen implementierten Smart Contract wiederzuverwenden, die Daten zu löschen, Token im Pool zu halten und ein weiteres Kapitel von hier aus zu starten, ohne dies zu neu ausführen. Versuchen Sie dies selbst und folgen Sie der Codebasis für zukünftige Updates, die diese Serie abdeckt! Betrachten Sie auch zusätzliche Anreize: Vielleicht wirkt sich die Anzahl der Token auf dem Konto auf die Dividenden aus, die sie vom Ende der Geschichte erhalten? Ihre Fantasie ist unendlich!

Bereitstellungsprobleme

Angesichts der Tatsache, dass unser Vertrag jetzt ziemlich groß ist, kann er die Gasgrenzen des Ethereum -Blocks einsetzen und/oder Tests überschreiten. Dies ist es, was große Anwendungen daran beschränkt, im Ethereum -Netzwerk bereitzustellen. Um es ohnehin bereitzustellen, verwenden Sie den Code -Optimierer während der Kompilierung, indem Sie die Datei truffle.js ändern, um die optimierten Solc -Einstellungen wie folgt einzuschließen:

<code>struct Proposal {
    string description;
    bool executed;
    int256 currentResult;
    uint8 typeFlag; // 1 = delete
    bytes32 target; // 提案目标的ID。例如，标志1，目标XXXXXX（哈希）表示删除submissions[hash]的提案
    uint256 creationDate;
    uint256 deadline;
    mapping (address => bool) voters;
    Vote[] votes;
    address submitter;
}

Proposal[] public proposals;
uint256 proposalCount = 0;
event ProposalAdded(uint256 id, uint8 typeFlag, bytes32 hash, string description, address submitter);
event ProposalExecuted(uint256 id);
event Voted(address voter, bool vote, uint256 power, string justification);

struct Vote {
    bool inSupport;
    address voter;
    string justification;
    uint256 power;
}</code>

Dadurch wird der Optimierer 200 -mal auf dem Code ausgeführt, um Bereiche zu finden, die vor dem Einsatz eingegrenzt, gelöscht oder abstrahiert werden können, was die Bereitstellungskosten erheblich senken sollte.

Schlussfolgerung

Dies beendet unsere detaillierte DAO -Entwicklung - aber der Kurs ist noch nicht vorbei! Wir müssen die Benutzeroberfläche für diese Geschichte noch erstellen und einsetzen. Glücklicherweise ist es viel einfacher, das vordere Ende zu bauen, da das Backend auf der Blockchain vollständig gehostet wird. Schauen wir uns das im vorletzten Teil dieser Serie an.

Häufig gestellte Fragen zum Aufbau von Ethereum Dapps und zur Abstimmung mit benutzerdefinierten Token

Wie funktioniert Blockchain -Stimmabgabe in der Praxis?

Blockchain -Abstimmung ist ein dezentrales Wahlsystem, das die Transparenz und Sicherheit der Blockchain -Technologie nutzt. Theoretisch sollte es perfekt funktionieren, aber in der Praxis stößt es oft vor Herausforderungen. Der Abstimmungsprozess umfasst die Erstellung intelligenter Verträge zur Ethereum -Blockchain, und jede Abstimmung ist eine überprüfbare Transaktion. Fragen wie die Anonymität, die Abstimmung von Wählern und die technische Komplexität der Verwendung von Blockchain -Plattformen können jedoch ihre tatsächliche Implementierung behindern.

Was ist der DAO -Abstimmungsmechanismus?

DAO (dezentrale autonome Organisation) Stimmmechanismus ist ein System, das es Token -Inhabern in DAO ermöglicht, über Vorschläge auf der Grundlage ihres Token -Eigentums abzustimmen. Zu den häufigsten Mechanismen gehören eine einfache Mehrheitswahl, die akzeptiert wird, wenn der Vorschlag mehr als 50% der Stimmen erhält, und eine sekundäre Abstimmung, bei denen die Kosten für die Abstimmung mehrerer Stimmen über den Vorschlag exponentiell zunehmen.

Wie funktioniert Governance in Sicherheitstoken?

Governance in sicheren Token wird normalerweise durch ein Wahlsystem behandelt, in dem Token -Inhaber über verschiedene Aspekte des Projekts abstimmen können. Dies kann Entscheidungen über die Projektentwicklung, die Token -Ökonomie und sogar die Änderungen des Governance -Systems selbst umfassen. Die Stimmrechte von Token -Inhabern sind in der Regel proportional zur Anzahl der Token, die sie halten.

Wie kann ich Dao Governance einrichten?

Aufbau von DAO -Governance beinhaltet die Erstellung eines intelligenten Vertrags über die Ethereum -Blockchain, in der die Regeln der Organisation, einschließlich Stimmrechte und Vorschlagsmechanismen, beschrieben werden. Dieser Vertrag wird dann in der Blockchain eingesetzt und die Token, die die Stimmrechte vertreten, werden an die Mitglieder verteilt. Die Mitglieder können dann Änderungen an der Organisation vorschlagen und stimmen.

Was sind die Risiken, Dao -Governance -Token zu halten?

Halten von DAO -Governance -Token kann aufgrund der Volatilität der Kryptowährungen und der regulatorischen Unsicherheit im Zusammenhang mit DAO riskant sein. Zum Beispiel warnt die Commodity Futures Trading Commission (CFTC), dass die Verwendung von Dao -Token zur Abstimmung als Form der Marktmanipulation angesehen werden könnte. Darüber hinaus können Token -Inhaber ihre Investition verlieren, wenn der DAO schlecht verwaltet wird oder Opfer von Hacker -Angriffen wird.

Wie erstellt man benutzerdefinierte Token für die Abstimmung in Ethereum Dapp?

Erstellen maßgefertigter Token für Stimmen in Ethereum DAPP beinhaltet das Schreiben und Bereitstellen von intelligenten Verträgen auf der Ethereum -Blockchain. Dieser Vertrag definiert die Attribute des Tokens, wie z. B. Namen, Symbol und Gesamtversorgung. Sobald der Vertrag eingesetzt wurde, können die Token an Benutzer verteilt werden, und Benutzer können sie dann verwenden, um über Vorschläge in der DAPP abzustimmen.

Was sind die Vorteile der Verwendung von Blockchain zur Abstimmung?

Blockchain -Abstimmung bietet eine Vielzahl von Vorteilen, einschließlich Transparenz, Sicherheit und Unveränderlichkeit. Die Stimmen werden als Transaktionen auf der Blockchain aufgezeichnet, wodurch sie transparent und überprüfbar sind. Die dezentrale Natur der Blockchain erschwert es auch jeder einzelnen Partei, den Abstimmungsprozess zu manipulieren.

Wie kann man die Anonymität der Wähler in der Blockchain -Abstimmung sicherstellen?

Da die Wähleranonymität in der Blockchain -Abstimmung aufgrund der transparenten Natur von Blockchain -Transaktionen eine Herausforderung sein kann. Techniken wie Null-Wissen-Beweise können jedoch verwendet werden, um die Gültigkeit des Wählers zu überprüfen, ohne die Identität des Wählers zu enthüllen.

Was sind die Herausforderungen bei der Umsetzung der Blockchain -Abstimmung?

Die Implementierung der Blockchain -Abstimmung kann aufgrund der technischen Komplexität, der regulatorischen Unsicherheit und der potenziellen Sicherheitsrisiken eine Herausforderung sein. Benutzer müssen mit der Blockchain -Technologie vertraut sein, um am Abstimmungsprozess teilzunehmen, und die Aufsichtsbehörden können Bedenken hinsichtlich der Legitimität und Sicherheit des Blockchain -Abstimmungssystems zum Ausdruck bringen.

Wie kann man die mit Dao -Governance -Token verbundenen Risiken mildern?

Das obige ist der detaillierte Inhalt vonBauen von Ethereum Dapps: Stimmen mit Sonderangebot. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!