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; // 提案目標(biāo)的ID。例如，標(biāo)志1，目標(biāo)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; // 提案目標(biāo)的ID。例如，標(biāo)志1，目標(biāo)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; // 提案目標(biāo)的ID。例如，標(biāo)志1，目標(biāo)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>

Mit der Funktion

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; // 提案目標(biāo)的ID。例如，標(biāo)志1，目標(biāo)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?

Die mit DAO -Governance -Token im Zusammenhang mit DAO -Governance -Token mildernden Risiken umfasst eine sorgf?ltige Verwaltung von DAOs, gründliche Sicherheitsma?nahmen und die stets im Auge behaltener Regulierungsentwicklungen. Es ist auch wichtig, Ihr Portfolio zu diversifizieren und nicht mehr zu investieren, als Sie sich leisten k?nnen.

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!