Rekapitulieren

In Teil 1 haben wir die Einrichtung einer privaten Ethereum-Blockchain mit zwei Knoten abgeschlossen. Jetzt stellen wir einen Vertrag für diese Blockchain bereit, und die Konten beider Knoten können auf den Vertrag zugreifen und die Funktionen ausführen.

Mein Plan ist es, den Vertrag auf Knoten 1 bereitzustellen und zu sehen, wie Knoten 2 auf diesen Vertrag zugreift.

Der Vertrag, den ich benutze, ist der “Voting.sol” von Mahesh Murthy in seinem Blog (Verknüpfung). Er schrieb einen sehr umfassenden Leitfaden über die Anwendung von Ethereum. Während er die Anwendung auf testrpc bereitstellte, plane ich, denselben Vertrag in meiner privaten Blockchain mit demselben Bereitstellungsbeispiel bereitzustellen. Sie können das Bereitstellungsverfahren leicht überprüfen.

Da er sehr detailliert erklärt hat, wie die Codekompilierung funktioniert, werde ich das Detail überspringen und nur auf einige Punkte verweisen, die für meine Vertragsbereitstellung relevant sind. Bitte beziehen Sie sich auf seinen Teil 1 (Verknüpfung) zum Detail über den Code und die Zusammenstellung.

Der Code “Voting.sol”

Voting.sol (Quelle: Verknüpfung)

Pragma Solidität ^ 0.4.11;

// Wir müssen angeben, mit welcher Compilerversion dieser Code kompiliert wird

Vertragsabstimmung {

/ * Das Zuordnungsfeld unten entspricht einem assoziativen Array oder Hash.

Der Schlüssel der Zuordnung ist der Kandidatenname, der als Typ bytes32 gespeichert ist, und der Wert ist

eine vorzeichenlose Ganzzahl zum Speichern der Stimmenzahl

* /

Zuordnung (bytes32 => uint8) öffentliche Stimmen erhalten;

/ * Solidity lässt Sie (noch) kein Array von Strings im Konstruktor übergeben..

Wir werden stattdessen ein Array von bytes32 verwenden, um die Liste der Kandidaten zu speichern

* /

bytes32 [] public CandidateList;

/ * Dies ist der Konstruktor, der einmal aufgerufen wird, wenn Sie

Stellen Sie den Vertrag in der Blockchain bereit. Wenn wir den Vertrag bereitstellen,

Wir werden eine Reihe von Kandidaten passieren, die an den Wahlen teilnehmen werden

* /

Funktion Voting (bytes32 [] Kandidatennamen) {

CandidateList = CandidateNames;

}}

// Diese Funktion gibt die Gesamtzahl der Stimmen zurück, die ein Kandidat bisher erhalten hat

Die Funktion totalVotesFor (bytes32 Kandidat) gibt (uint8) {zurück

if (validCandidate (Kandidat) == false) throw;

RückstimmenReceived [Kandidat];

}}

// Diese Funktion erhöht die Stimmenzahl für den angegebenen Kandidaten. Dies

// entspricht einer Stimmabgabe

Funktion voteForCandidate (bytes32 Kandidat) {

if (validCandidate (Kandidat) == false) throw;

Stimmen empfangen [Kandidat] + = 1;

}}

Funktion validCandidate (bytes32 Kandidat) gibt (bool) {zurück

für (uint i = 0; i < KandidatListe.Länge; i ++) {

if (Kandidatenliste [i] == Kandidat) {

return true;

}}

}}

falsch zurückgeben;

}}

}}

d! ‘

Dies ist ein einfacher Vertrag, um die Funktionsweise des Solidity-Codes zu veranschaulichen. Hier sind einige Punkte, auf die wir in diesem Teil Bezug nehmen werden.

  1. Der Vertrag erfordert eine Kandidatenliste (siehe Konstruktor). Wir werden dies bei der Bereitstellung eines neuen Vertrags eingeben.
  2. In diesem Vertrag sind zwei Funktionen definiert: Gesamtstimme für und Abstimmung für Kandidaten. Wir werden diese beiden Funktionen verwenden, um von beiden Knoten aus mit dem Vertrag zu interagieren.

Sie finden den detaillierten Prozess der Kompilierung (mit solc) Hier. Nach der Kompilierung benötigen wir zwei Informationen für die Vertragsbereitstellung. Sie sind das Application Binary Interface (ABI) und der Bytecode.

Application Binary Interface (ABI)

Es enthält die in diesem Vertrag verfügbaren Methoden, mit denen Benutzer interagieren können. Hier ist der ABI für diesen Abstimmungsvertrag.

‘[{"Konstante":falsch,"Eingänge": [{"Name"::"Kandidat","Art"::"bytes32"}],"Name"::"totalVotesFor","Ausgänge": [{"Name"::"","Art"::"uint8"}],"zahlbar":falsch,"Art"::"Funktion"}, {"Konstante":falsch,"Eingänge": [{"Name"::"Kandidat","Art"::"bytes32"}],"Name"::"validCandidate","Ausgänge": [{"Name"::"","Art"::"Bool"}],"zahlbar":falsch,"Art"::"Funktion"}, {"Konstante":wahr,"Eingänge": [{"Name"::"","Art"::"bytes32"}],"Name"::"Stimmen empfangen","Ausgänge": [{"Name"::"","Art"::"uint8"}],"zahlbar":falsch,"Art"::"Funktion"}, {"Konstante":wahr,"Eingänge": [{"Name"::"","Art"::"uint256"}],"Name"::"Kandidatenliste","Ausgänge": [{"Name"::"","Art"::"bytes32"}],"zahlbar":falsch,"Art"::"Funktion"}, {"Konstante":falsch,"Eingänge": [{"Name"::"Kandidat","Art"::"bytes32"}],"Name"::"voteForCandidate","Ausgänge": [],"zahlbar":falsch,"Art"::"Funktion"}, {"Eingänge": [{"Name"::"Kandidatennamen","Art"::"bytes32 []"}],"zahlbar":falsch,"Art"::"Konstrukteur"}] ‘

Bytecode

Dies ist der tatsächliche Vertragscode, der in der Blockchain bereitgestellt werden soll. Hier ist der Bytecode.

‚0x6060604052341561000c57fe5b6040516103d83803806103d8833981016040528080518201919050505b806001908051906020019061003f929190610047565b505b506100bf565b828054828255906000526020600020908101928215610089579160200282015b82811115610088578251829060001916905591602001919060010190610067565b5b509050610096919061009a565b5090565b6100bc91905b808211156100b85760008160009055506001016100a0565b5090565b90565b61030a806100ce6000396000f30060606040526000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff1680632f265cf714610067578063392e6678146100a55780637021939f146100e1578063b13c744b1461011f578063cc9ab2671461015b575bfe5b341561006f57fe5b61008960048080356000191690602001909190505061017f565b604051808260ff1660ff16815260200191505060405180910390f35b34156100ad57fe5b6100c76004808035600019169060200190919050506101cd565b604051808215151515815260200191505060405180910390f35b34156100e957fe5b610103600480803560001916906020019091905050610233565b604051808260ff1660ff16815260200191505060405180910390f35b341561012 757fe5b61013d6004808035906020019091905050610253565b60405180826000191660001916815260200191505060405180910390f35b341561016357fe5b61017d600480803560001916906020019091905050610278565b005b60006000151561018e836101cd565b1515141561019c5760006000fd5b60006000836000191660001916815260200190815260200160002060009054906101000a900460ff1690505b919050565b60006000600090505b6001805490508110156102285782600019166001828154811015156101f757fe5b906000526020600020900160005b505460001916141561021a576001915061022d565b5b80806001019150506101d6565b600091505b50919050565b60006020528060005260406000206000915054906101000a900460ff1681565b60018181548110151561026257fe5b906000526020600020900160005b915090505481565b60001515610285826101cd565b151514156102935760006000fd5b600160006000836000191660001916815260200190815260200160002060008282829054906101000a900460ff160192506101000a81548160ff021916908360ff1602179055505b505600a165627a7a72305820994b2ebbfeec46890216bc547cf9a1292547cc43f08440506866c34b2ff0ac9e0029′

Schritte

Schritt 1: Installieren Sie node.js und web3 auf beiden Knoten

Die Interaktion zum Vertragsabschluss erfolgt über NodeJS und Web3Js. Wir müssen nodejs und die web3-Module installieren. Ich folge dem hier vorgeschlagenen Verfahren (Verknüpfung).

Knoten 1

$ sudo apt-get installiert Python-Software-Eigenschaften

$ curl -sL https://deb.nodesource.com/setup_6.x | sudo -E bash –

$ sudo apt-get install nodejs

Verwenden Sie $ node -v und $ npm -v, um die erfolgreiche Installation zu überprüfen. Die Version wird angezeigt.

Installieren Sie dann das web3-Modul.

Knoten 1

$ npm installiere web3

Wiederholen Sie diesen Schritt auch in Knoten 2.

Schritt 2: Greifen Sie über web3 in der Knotenkonsole auf Blockchain zu

Wir sind bereit, auf den Knoten zuzugreifen. Da wir sowohl den Geth-Client als auch die Knotenkonsole benötigen, werden wir den geteilten Bildschirm wieder verwenden. Das obere Terminal ist geth und das untere ist die Knotenkonsole.

Um das Geth zu starten, sollte jeder Befehl Sie zur Konsole zurückbringen, je nachdem, ob Geth noch ausgeführt wird.

Knoten 1 (geth)

$ geth –nodiscover console 2>>eth.log ODER

$ geth anhängen

Verwenden Sie dies einfach, um die Knotenkonsole zu starten

Knoten 1 (Knoten)

$ node

Zwei-Knoten-Einrichtung eines privaten Ethereum in AWS mit Vertragsbereitstellung (Teil 2)

Wir sind jetzt bereit, die Knotenkonsole zu verwenden, um über rpc auf geth zuzugreifen. Der Standard-RPC befindet sich unter http: // localhost: 8545 /.

Schalten Sie zuerst rpc auf geth ein:

Knoten 1 (geth)

> admin.startRPC ()

Auf der Knotenkonsole,

Knoten 1 (geth)

> admin.startRPC ()

Um zu überprüfen, ob der Knoten Geth erfolgreich erreichen kann, können wir verwenden > web3.eth.accounts auf der Knotenkonsole. Wir sollten das Konto sehen, das wir auf der Geth-Konsole erstellt haben.

Zwei-Knoten-Einrichtung eines privaten Ethereum in AWS mit Vertragsbereitstellung (Teil 2)

Wiederholen Sie diesen Schritt auf Knoten 2.

Schritt 3: Bereitstellen des Vertrags auf Knoten 1

Wir stellen den Vertrag jetzt für diese private Blockchain von Knoten 1 aus bereit.

Knoten 1 (Knoten)

> abi = <abi oben gezeigt>

> VotingContract = web3.eth.contract (JSON.parse (abi))

> byteCode = <Bytecode oben gezeigt>

Da für die Bereitstellung Gas erforderlich ist, müssen wir das Konto entsperren und das Mining aktivieren

Knoten 1 (geth)

> personal.unlockAccount (eth.accounts [0])

> Miner.start ()

Jetzt stellen wir den Vertrag bereit. Dieser Vertrag erfordert eine Kandidatenliste. Wir werden dies bei der Bereitstellung des Vertrags berücksichtigen.

Knoten 1 (Knoten)

> deployContract = VotingContract.new ([‘Rama’, ‘Nick’, ‘Jose’], {data: byteCode, from: web3.eth.accounts [0], gas: 4700000})

Jetzt wird der Vertrag bereitgestellt. Und wir können die Funktionen zur Verifizierung ausführen. Wir werden sehen, dass die Stimmenzahl steigt, wenn wir die Funktionen weiterhin ausführen.

Knoten 1 (Knoten)

> deployContract.totalVoteFor.call (‘Rama’)

> deployContract.voteForCandidate (‘Rama’, {from: web3.eth.accounts [0]})

Zwei-Knoten-Einrichtung eines privaten Ethereum in AWS mit Vertragsbereitstellung (Teil 2)

Der Vertrag wurde erfolgreich bereitgestellt. Jetzt wechseln wir zu Knoten 2 und sehen, wie das Konto in Knoten 2 auch auf diesen Vertrag zugreifen kann.

Schritt 4: Zugriff auf Vertrag von Knoten 2

Stellen Sie sicher, dass Knoten 1 und Knoten 2 bereits einen Blick darauf geworfen haben. Überprüfen durch > admin.peers auf der Geth-Konsole auf beiden Knoten. Weitere Informationen finden Sie in Teil 1, falls erforderlich.

Die Informationen, die für ein Konto in Knoten 2 erforderlich sind, das auf diesen bereitgestellten Vertrag zugreift, sind (1) das ABI und (2) seine bereitgestellte Adresse. Wir haben bereits ABI-Informationen. Jetzt können wir von Knoten 1 diese bereitgestellte Adresse erhalten.

Knoten 1 (Knoten)

> deployContract.address

‘0x97a4b975c8fde24d8e40551054342c95676ed959’

0]})

Für ABI definieren wir VotingContract mit demselben Abi auf Knoten 2.

Knoten 2 (Knoten)

> abi = <abi oben gezeigt>

> VotingContract = web3.eth.contract (JSON.parse (abi))

Wir müssen keinen neuen Vertrag wie auf Knoten 1 bereitstellen. Stattdessen definieren wir die Vertragsinstanz basierend auf dem VotingContract und der Adresse, die wir von Knoten 1 erhalten haben.

Knoten 2 (Knoten)

> contractInstance = VotingContract.at (‘0x97a4b975c8fde24d8e40551054342c95676ed959’)

Die linke Seite ist Knoten 1 und die rechte Seite ist Knoten 2.

Zwei-Knoten-Einrichtung eines privaten Ethereum in AWS mit Vertragsbereitstellung (Teil 2)

Jetzt ist die Vertragsinstanz der Punkt, an dem wir auf diesen bereitgestellten Vertrag in Knoten 2 zugreifen können. Wir können die Befehle genauso ausgeben wie auf Knoten 1:

Knoten 2 (Knoten)

> contractInstance.totalVoteFor.call (‘Rama’)

> contractInstance.voteForCandidate (‘Rama’, {from: web3.eth.accounts [0]})

)

Vergessen Sie nicht, das Konto auf Knoten 2 bei der Abstimmung zu entsperren, da dies Gas verbraucht, um eine Funktion im Vertrag auszuführen.

Schritt 5: Überprüfung

Durch die Interaktion auf beiden Knoten sehen wir, dass Konten auf beiden Knoten auf denselben Vertrag reagieren. Hier fange ich die Interaktion zwischen den beiden Knoten ein.

  1. Beide Knoten sehen das gleiche Ergebnis (Stimmenzahl für Rama ist 4).
  2. Ein Konto auf Knoten 1 stimmt einmal für Rama.
  3. Ab Knoten 2 sehen wir, dass die Stimmenzahl für Rama jetzt 5 beträgt.
  4. Ein Konto auf Knoten 2 stimmt erneut für Rama.
  5. Ab Knoten 1 sehen wir jetzt, dass die Stimmenzahl jetzt 6 beträgt.

Schließen

Dieses Setup emuliert die reale Ethereum-Operation. Neue Knoten können problemlos der öffentlichen Kette beitreten und auf bereitgestellte Verträge zugreifen. Im wirklichen Leben wird natürlich höchstwahrscheinlich über die Weboberfläche auf die Anwendung zugegriffen. Die Verwendung der Konsole hilft jedoch dabei, die dahinter stehende Interaktion besser zu verstehen.

Nochmals vielen Dank für viele Arbeiten anderer, die mich inspirieren und leiten. Hier sind sie,

  • JJs Welt: Aufbau einer privaten Ethereum-Blockchain (Verknüpfung)
  • Mahesh Murthy: Ethereum für Webentwickler (Verknüpfung)
  • MLG Blockchain Consulting: Verwenden Sie Go-Ethereum, um eine Ethereum-Blockchain unter AWS einzurichten (Verknüpfung)

Mike Owergreen Administrator
Sorry! The Author has not filled his profile.
follow me