Durchführen öffentlicher und privater Transaktionen in der JPMorgan Quorum-Blockchain mit Web3

Quorum ist eine Ethereum-basierte Blockchain, die von JPMorgan entwickelt wurde und zuletzt die erste verteilte Registrierungsplattform ist, die Microsoft Azure anbietet.

Das Quorum unterstützt private und öffentliche Transaktionen und hat viele kommerzielle Anwendungsfälle.

In diesem Artikel analysieren wir eines dieser Szenarien - die Bereitstellung eines verteilten Registrierungsnetzwerks zwischen einem Supermarkt und einem Lagerbesitzer, um relevante Informationen über die Temperatur eines Lagers bereitzustellen.

Der in diesem Handbuch verwendete Code befindet sich im Repository auf GitHub .

Der Artikel behandelt:

• Erstellen eines intelligenten Vertrags;
• Bereitstellen des Quorum-Netzwerks mit Chainstack
• Quorum öffentliche Transaktionen
• Quorum private Transaktionen.

Um dies zu veranschaulichen, verwenden wir das Skript zur Überwachung der Temperatur in den Lagerräumen der Mitglieder des Quorum-Netzwerks als Teil des Internet der Dinge (IoT).

Kontext

Eine Gruppe von Lagerunternehmen ist in einem Konsortium für die gemeinsame Speicherung von Informationen und die Automatisierung von Prozessen in der Blockchain zusammengefasst. Dafür haben sich die Unternehmen für Quorum entschieden. In diesem Artikel werden zwei Szenarien behandelt: öffentliche Transaktionen und private Transaktionen.

Transaktionen werden von verschiedenen Teilnehmern erstellt, um mit dem Konsortium zu interagieren, zu dem sie gehören. Jede Transaktion stellt entweder einen Vertrag bereit oder ruft eine Funktion in einem Vertrag auf, um Daten in das Netzwerk hochzuladen. Diese Aktionen werden auf alle Knoten im Netzwerk repliziert.

Öffentliche Transaktionen können von allen Mitgliedern des Konsortiums eingesehen werden. Private Transaktionen bieten eine zusätzliche Vertraulichkeitsebene und stehen nur den Teilnehmern zur Verfügung, die Rechte daran haben.

Für beide Szenarien verwenden wir aus Gründen der Übersichtlichkeit denselben Vertrag.

Intelligenter Vertrag

Im Folgenden finden Sie einen einfachen Smart-Vertrag, der für unser Szenario erstellt wurde. Es hat eine öffentliche variable temperature , die mit der set Methode geändert und mit der get Methode abgerufen werden kann.

 pragma solidity ^0.4.25; contract TemperatureMonitor { int8 public temperature; function set(int8 temp) public { temperature = temp; } function get() view public returns (int8) { return temperature; } } 

Damit der Vertrag mit web3.js funktioniert , muss er in das ABI-Format und den Bytecode konvertiert werden. Mit der formatContract Funktion formatContract wird der Vertrag mit solc-js kompiliert .

 function formatContract() { const path = './contracts/temperatureMonitor.sol'; const source = fs.readFileSync(path,'UTF8'); return solc.compile(source, 1).contracts[':TemperatureMonitor']; } 

Der abgeschlossene Vertrag lautet wie folgt:

 // interface [ { constant: true, inputs: [], name: 'get', outputs: [Array], payable: false, stateMutability: 'view', type: 'function' }, { constant: true, inputs: [], name: 'temperature', outputs: [Array], payable: false, stateMutability: 'view', type: 'function' }, { constant: false, inputs: [Array], name: 'set', outputs: [], payable: false, stateMutability: 'nonpayable', type: 'function' } ] 

 // bytecode 

Nachdem der Vertrag fertig ist, werden wir das Netzwerk und den Vertrag bereitstellen.

Knotenbereitstellung

Das Bereitstellen eines Knotens kann sehr zeitaufwändig sein und dieser Prozess kann mithilfe des Chainstack- Dienstes ersetzt werden.

Das Folgende ist ein Quorum-Netzwerkbereitstellungsprozess mit einem Raft-Konsens und drei Knoten.

Beginnen wir mit einem Projekt und nennen es das Quorum-Projekt:

Erstellen Sie ein Quorum-Netzwerk mit Raft-Konsens auf der Google Cloud-Plattform:

Fügen Sie dem bereits erstellten Standardknoten zwei weitere Knoten hinzu:

Drei laufende Knoten:

Auf der Seite mit den Knotendetails werden der RPC-Endpunkt, der öffentliche Schlüssel usw. angezeigt.

Das Netzwerk wird bereitgestellt. Jetzt werden wir intelligente Verträge bereitstellen und Transaktionen mit web3.js ausführen.

Öffentliche Transaktionen

Kontext

Die Temperatur des Lagers ist von großer Bedeutung, um die Kosten zu senken, insbesondere für Produkte, die zur Lagerung bei Temperaturen unter Null bestimmt sind.

Durch die Möglichkeit für Unternehmen, Echtzeitwerte der Außentemperatur ihres geografischen Standorts zu teilen und in einem unveränderlichen Register aufzuzeichnen, reduzieren Netzwerkmitglieder Kosten und Zeit.

Wir werden die drei in der Abbildung dargestellten Aufgaben ausführen:

1. Wir werden den Vertrag über Knoten 1 kündigen:

   
   

    const contractAddress = await deployContract(raft1Node); console.log(`Contract address after deployment: ${contractAddress}`); 

   
   

2. Stellen Sie die Temperatur über Knoten 2 bis 3 Grad ein:

   
   

    const status = await setTemperature(raft2Node, contractAddress, 3); console.log(`Transaction status: ${status}`); 

   
   

3. Knoten 3 erhält Informationen aus dem Smart-Vertrag. Der Vertrag gibt einen Wert von 3 Grad zurück:

   
   

    const temp = await getTemperature(raft3Node, contractAddress); console.log('Retrieved contract Temperature', temp); 

   
   

   Als Nächstes sehen wir uns an, wie eine öffentliche Transaktion im Quorum-Netzwerk mit web3.js ausgeführt wird.

   
   

Wir initiieren eine Instanz über RPC für drei Knoten:

 const raft1Node = new Web3( new Web3.providers.HttpProvider(process.env.RPC1), null, { transactionConfirmationBlocks: 1, }, ); const raft2Node = new Web3( new Web3.providers.HttpProvider(process.env.RPC2), null, { transactionConfirmationBlocks: 1, }, ); const raft3Node = new Web3( new Web3.providers.HttpProvider(process.env.RPC3), null, { transactionConfirmationBlocks: 1, }, ); 

Zerstören Sie den intelligenten Vertrag:

 // returns the default account from the Web3 instance initiated previously function getAddress(web3) { return web3.eth.getAccounts().then(accounts => accounts[0]); } // Deploys the contract using contract's interface and node's default address async function deployContract(web3) { const address = await getAddress(web3); // initiate contract with contract's interface const contract = new web3.eth.Contract( temperatureMonitor.interface ); return contract.deploy({ // deploy contract with contract's bytecode data: temperatureMonitor.bytecode, }) .send({ from: address, gas: '0x2CD29C0', }) .on('error', console.error) .then((newContractInstance) => { // returns deployed contract address return newContractInstance.options.address; }); } 

web3.js bietet zwei Methoden für die Interaktion mit einem Vertrag: call und send .

Aktualisieren Sie die Temperatur des Vertrags, indem Sie set mit der web3-Sendemethode ausführen.

 // get contract deployed previously async function getContract(web3, contractAddress) { const address = await getAddress(web3); return web3.eth.Contract( temperatureMonitor.interface, contractAddress, { defaultAccount: address, } ); } // calls contract set method to update contract's temperature async function setTemperature(web3, contractAddress, temp) { const myContract = await getContract(web3, contractAddress); return myContract.methods.set(temp).send({}).then((receipt) => { return receipt.status; }); } 

Als nächstes verwenden wir die web3-Aufrufmethode, um die Temperatur des Vertrags zu ermitteln. Bitte beachten Sie, dass die Aufrufmethode auf dem lokalen Knoten ausgeführt wird und die Transaktion nicht in der Blockchain erstellt wird.

 // calls contract get method to retrieve contract's temperature async function getTemperature(web3, contractAddress) { const myContract = await getContract(web3, contractAddress); return myContract.methods.get().call().then(result => result); } 

Jetzt können Sie public.js ausführen , um das folgende Ergebnis zu erhalten:

 // Execute public script node public.js Contract address after deployment: 0xf46141Ac7D6D6E986eFb2321756b5d1e8a25008F Transaction status: true Retrieved contract Temperature 3 

Als nächstes sehen wir die Einträge im Quorum Explorer im Chainstack-Bedienfeld, wie unten gezeigt.

Alle drei Knoten interagierten und Transaktionen wurden aktualisiert:

1. Die erste Transaktion hat einen Vertrag gesichert.
2. Bei der zweiten Transaktion wurde die Vertragstemperatur auf 3 Grad festgelegt.
3. Die Temperatur wird über den lokalen Knoten ermittelt, sodass die Transaktion nicht erstellt wurde.

Private Transaktionen

Kontext

Eine häufige Anforderung von Organisationen ist der Datenschutz. Stellen Sie sich als Beispiel ein Szenario vor, in dem ein Supermarkt ein Lager für die Lagerung von Meeresfrüchten von einem separaten Anbieter mietet:

• Der Anbieter liest mit Hilfe von IoT-Sensoren alle 30 Sekunden Temperaturwerte und leitet sie an den Supermarkt weiter .
• Diese Werte sollten nur dem Verkäufer und dem Supermarkt , einem vernetzten Konsortium, zur Verfügung stehen.

Wir werden die vier in der obigen Abbildung dargestellten Aufgaben ausführen.

• Wir verwenden dieselben drei Knoten aus dem vorherigen Szenario, um private Transaktionen zu demonstrieren:
• Der Supermarkt setzt einen intelligenten Vertrag ein, der für den Supermarkt und den Verkäufer privat ist.
• Ein Dritter hat keinen Zugriff auf den Smart-Vertrag.

Wir werden die get und set Methoden im Auftrag des Supermarkts und des Anbieters aufrufen, um die private Quorum-Transaktion zu demonstrieren.

1. Wir werden den privaten Vertrag für die Teilnehmer des Supermarkts und des Verkäufers über den Teilnehmer des Supermarkts kündigen:

   
   

    const contractAddress = await deployContract( raft1Node, process.env.PK2, ); console.log(`Contract address after deployment: ${contractAddress}`); 

   
   

2. Stellen Sie die Temperatur vom Drittanbieter (äußerer Knoten) ein und erhalten Sie den Temperaturwert:

   
   

    // Attempts to set Contract temperature to 10, this will not mutate contract's temperature await setTemperature( raft3Node, contractAddress, process.env.PK1, 10, ); // This returns null const temp = await getTemperature(raft3Node, contractAddress); console.log(`[Node3] temp retrieved after updating contract from external nodes: ${temp}`); 

   
   

3. Stellen Sie die Temperatur vom Lieferanten (innerer Knoten) ein und erhalten Sie den Temperaturwert:

   
   

   Die Temperatur in diesem Szenario sollte vom Smart-Vertrag auf 12 zurückkehren. Bitte beachten Sie, dass der Anbieter hier den Zugriff auf den Smart-Vertrag zugelassen hat.

   
   

    // Updated Contract temperature to 12 degrees await setTemperature( raft2Node, contractAddress, process.env.PK1, 12, ); // This returns 12 const temp2 = await getTemperature(raft2Node, contractAddress); console.log(`[Node2] temp retrieved after updating contract from internal nodes: ${temp2}`); 

   
   

4. Holen Sie sich die Temperatur vom Drittanbieter (äußerer Knoten):

   
   

   In Schritt 3 wurde die Temperatur auf 12 eingestellt, aber der Dritte hat keinen Zugriff auf den Smart-Vertrag. Daher muss der Rückgabewert null sein.

   
   

    // This returns null const temp3 = await getTemperature(raft3Node, contractAddress); console.log(`[Node3] temp retrieved from external nodes after update ${temp}`); 

   
   

   Als nächstes werden wir die Ausführung privater Transaktionen im Quorum-Netzwerk mit web3.js genauer betrachten. Da der größte Teil des Codes mit öffentlichen Transaktionen übereinstimmt, wählen wir nur die Teile aus, die sich für private Transaktionen unterscheiden.

   
   

Bitte beachten Sie, dass der in das Netzwerk hochgeladene Vertrag unveränderlich ist. Daher muss den entsprechenden Knoten der Zugriff mit Erlaubnis gewährt werden, indem der öffentliche Vertrag zum Zeitpunkt der Bereitstellung des Vertrags und nicht danach einbezogen wird.

 async function deployContract(web3, publicKey) { const address = await getAddress(web3); const contract = new web3.eth.Contract( temperatureMonitor.interface, ); return contract.deploy({ data: temperatureMonitor.bytecode, }) .send({ from: address, gas: '0x2CD29C0', // Grant Permission to Contract by including nodes public keys privateFor: [publicKey], }) .then((contract) => { return contract.options.address; }); } 

Private Transaktionen werden auf die gleiche Weise ausgeführt - unter Einbeziehung des öffentlichen Schlüssels der Teilnehmer zum Zeitpunkt der Ausführung.

 async function setTemperature(web3, contractAddress, publicKey, temp) { const address = await getAddress(web3); const myContract = await getContract(web3, contractAddress); return myContract.methods.set(temp).send({ from: address, // Grant Permission by including nodes public keys privateFor: [publicKey], }).then((receipt) => { return receipt.status; }); } 

Jetzt können wir private.js mit den folgenden Ergebnissen ausführen :

 node private.js Contract address after deployment: 0x85dBF88B4dfa47e73608b33454E4e3BA2812B21D [Node3] temp retrieved after updating contract from external nodes: null [Node2] temp retrieved after updating contract from internal nodes: 12 [Node3] temp retrieved from external nodes after update null 

Der Quorum Explorer bei Chainstack zeigt Folgendes:

• Bereitstellung eines Vertrags von einem Supermarktteilnehmer
• Durchführen von SetTemperature von einem Dritten ;
• Führen Sie eine SetTemperature von einem Herstellerteilnehmer aus .

Wie Sie sehen, sind beide Transaktionen abgeschlossen, aber nur die Transaktion des teilnehmenden Anbieters hat die Temperatur im Vertrag aktualisiert. Private Transaktionen bieten somit Unveränderlichkeit, geben aber gleichzeitig keine Daten an Dritte weiter.

Fazit

Wir haben das kommerzielle Szenario für die Verwendung von Quorum untersucht, um aktuelle Temperaturinformationen in einem Lager bereitzustellen, indem wir ein Netzwerk zwischen zwei Parteien - einem Supermarkt und dem Lagerbesitzer - bereitgestellt haben.

Wir haben gezeigt, wie aktuelle Temperaturinformationen sowohl durch öffentliche als auch durch private Transaktionen aufrechterhalten werden können.

Es kann viele Anwendungsszenarien geben, und wie Sie sehen, ist dies überhaupt nicht schwierig.

Experimentieren Sie und versuchen Sie, Ihr Skript bereitzustellen. Darüber hinaus kann die Blockchain-Technologieindustrie bis 2024 fast zehnmal wachsen .