🥇Ausführung öffentlicher und privater Transaktionen in der JPMorgan Quorum-Blockchain unter Verwendung von Web3

Quorum — eine Blockchain, die auf Ethereum basiert, entwickelt von JPMorgan und kürzlich zur ersten Plattform für verteilte Ledger geworden ist, die Microsoft Azure anbietet.

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

In diesem Artikel werden wir einen solchen Anwendungsfall untersuchen – die Bereitstellung eines verteilten Ledger-Netzwerks zwischen einem Supermarkt und einem Lagerhausbesitzer, um aktuelle Informationen über die Temperatur des Lagerraums bereitzustellen.

Der im Folgenden verwendete Code befindet sich in dem Repository auf GitHub.

Der Artikel behandelt:

die Erstellung eines Smart Contracts;
die Bereitstellung eines Quorum-Netzwerks mit Hilfe von Chainstack;
öffentliche Transaktionen von Quorum;
private Transaktionen von Quorum.

Zur Veranschaulichung verwenden wir das Szenario der Temperaturüberwachung in Lagerhäusern, die Teil des Quorum-Netzwerks im Rahmen des Internet der Dinge (IoT) sind.

Kontext

Eine Gruppe von Lagerunternehmen bildet ein Konsortium zur gemeinsamen Speicherung von Informationen und zur Automatisierung von Prozessen auf der Blockchain. Dazu haben sich die Unternehmen entschieden, Quorum zu verwenden. In diesem Artikel behandeln wir zwei Szenarien: öffentliche Transaktionen und private Transaktionen.

Transaktionen werden von verschiedenen Teilnehmern erstellt, um mit dem Konsortium, dem sie angehören, zu interagieren. Jede Transaktion deployt entweder einen Vertrag oder ruft eine Funktion im Vertrag auf, um Daten ins Netzwerk zu laden. Diese Aktionen werden auf allen Knoten im Netzwerk repliziert.

Öffentliche Transaktionen sind für alle Mitglieder des Konsortiums einsehbar. Private Transaktionen fügen eine Ebene der Vertraulichkeit hinzu und sind nur für diejenigen Teilnehmer zugänglich, die dazu berechtigt sind.

Für beide Szenarien verwenden wir zur Veranschaulichung denselben Vertrag.

Smart Contract

Im Folgenden finden Sie einen einfachen Smart Contract, der für unser Szenario erstellt wurde. Er enthält eine öffentliche Variable temperature, die mit der Methode set und mit der Methode get.

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, muss er in das ABI- und Bytecode-Format konvertiert werden. Die Verwendung der Funktion formatContract, die im Folgenden angegeben ist, kompiliert den Vertrag mit Hilfe von solc-js.

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

Der fertige Vertrag sieht wie folgt aus:

// 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
0x608060405234801561001057600080fd5b50610104806100206000396000f30060806040526004361060525763ffffffff7c01000000000000000000000000000000000000000000000000000000006000350416636d4ce63c81146057578063adccea12146082578063faee13b9146094575b600080fd5b348015606257600080fd5b50606960ae565b60408051600092830b90920b8252519081900360200190f35b348015608d57600080fd5b50606960b7565b348015609f57600080fd5b5060ac60043560000b60c0565b005b60008054900b90565b60008054900b81565b6000805491810b60ff1660ff199092169190911790555600a165627a7a72305820af0086d55a9a4e6d52cb6b3967afd764ca89df91b2f42d7bf3b30098d222e5c50029

Jetzt, wo der Vertrag bereit ist, werden wir das Netzwerk bereitstellen und den Vertrag implementieren.

Bereitstellung der Knoten

Die Bereitstellung eines Knotens kann ziemlich arbeitsintensiv sein, und dieser Prozess kann durch die Nutzung eines Dienstes ersetzt werden. Chainstack.

Im Folgenden wird der Prozess zur Bereitstellung eines Quorum-Netzwerks mit dem Raft-Konsens und drei Knoten dargestellt.

Zunächst erstellen wir ein Projekt und nennen es Quorum Project:

Wir erstellen ein Quorum-Netzwerk mit dem Raft-Konsens auf der Google Cloud Platform:

Wir fügen dem bereits vorhandenen Standardknoten zwei weitere Knoten hinzu:

Drei laufende Knoten:

Die Detailseite des Knotens zeigt den RPC-Endpunkt, den öffentlichen Schlüssel usw.

Das Netzwerk ist bereitgestellt. Jetzt kümmern wir uns um die Implementierung von Smart Contracts und die Durchführung von Transaktionen mit Hilfe von web3.js.

Öffentliche Transaktionen

Kontext

Die Temperatur des Lagerraums ist von großer Bedeutung für die Kostensenkung, insbesondere für Produkte, die zur Lagerung bei Minusgraden bestimmt sind.

Indem Unternehmen die Möglichkeit gegeben wird, die Werte der Außentemperatur ihres geografischen Standorts in Echtzeit zu teilen und in einem unveränderlichen Register aufzuzeichnen, reduzieren die Teilnehmer des Netzwerks Kosten und Zeit.

Wir werden drei Aufgaben ausführen, die in der Abbildung dargestellt sind:

Wir implementieren den Vertrag über Knoten 1:

const contractAddress = await deployContract(raft1Node);
console.log(`Vertragsadresse nach der Bereitstellung: ${contractAddress}`);

Wir setzen die Temperatur über Knoten 2 auf 3 Grad:

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

Knoten 3 wird Informationen aus dem Smart Contract abrufen. Der Vertrag wird den Wert 3 Grad zurückgeben:
```
const temp = await getTemperature(raft3Node, contractAddress);
console.log('Abgerufene Vertrags Temperatur', temp);
```
Als Nächstes sehen wir uns an, wie man eine öffentliche Transaktion im Quorum-Netzwerk unter Verwendung von web3.js.

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,
 },
);

Wir implementieren den Smart Contract:

// 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 stellt zwei Methoden zur Interaktion mit dem Vertrag bereit: call und send.

Wir aktualisieren die Temperatur des Vertrags durch Ausführung von set unter Verwendung der Web3-Methode send.

// 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-Methode call zum Abrufen der Temperatur des Vertrags. Beachten Sie, dass die Methode call lokal auf dem Knoten ausgeführt wird und die Transaktion auf der Blockchain nicht 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 wir starten public.js 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 können wir die Einträge im Quorum-Explorer im Chainstack-Dashboard sehen, wie unten dargestellt.

Alle drei Knoten haben interagiert und die Transaktionen wurden aktualisiert:

Die erste Transaktion hat den Vertrag bereitgestellt.
Die zweite Transaktion hat die Temperatur des Vertrags auf 3 Grad eingestellt.
Die Temperatur wird über den lokalen Knoten abgerufen, daher wurde keine Transaktion erstellt.

Private Transaktionen

Kontext

Eine häufige Anforderung von Organisationen ist der Datenschutz. Als Beispiel betrachten wir ein Szenario, in dem der Supermarkt einen Lagerraum für die Lagerung von Meeresfrüchten von einem separaten Anbieter:

Anbieter mit Hilfe von IoT-Sensoren alle 30 Sekunden Temperaturwerte abruft und diese an den Supermarkt;
Diese Werte sollten nur dem Anbieter und dem Supermarkt, der in einem Konsortium vernetzt ist.

Wir werden vier Aufgaben durchführen, die in dem obigen Diagramm illustriert sind.

Wir verwenden dieselben drei Knoten aus dem vorherigen Szenario, um private Transaktionen zu demonstrieren:
Der Supermarkt stellt einen Smart Contract bereit, der privat für den Supermarkt und Anbieter.
Dritte hat keinen Zugriff auf den Smart Contract.

Wir werden die Methoden get und set im Namen von den Supermarkt und Anbieter aufrufen, um eine private Quertransaktion zu demonstrieren.

Wir werden einen privaten Vertrag für die Teilnehmer bereitstellen Der Supermarkt und Anbieter über den Teilnehmer Der Supermarkt:

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

Wir setzen die Temperatur von der Dritten außerhalb des Knotens und erhalten 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}`);

Wir setzen die Temperatur von Anbieter von innerhalb des Knotens und erhalten den Temperaturwert:

Die Temperatur in diesem Szenario sollte aus dem Smart Contract den Wert 12 zurückgeben. Beachten Sie, dass Anbieter hier Zugriff auf den Smart Contract erlaubt ist.

// 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}`);

Wir erhalten die Temperatur von der Dritten (außerhalb des Knotens):
In Schritt 3 wurde die Temperatur auf den Wert 12 eingestellt, aber Dritte hat keinen Zugriff auf den Smart Contract. Daher sollte 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}`);
```
Nun betrachten wir im Detail die Ausführung privater Transaktionen im Quorum-Netzwerk mit web3.js. Da der Großteil des Codes mit öffentlichen Transaktionen übereinstimmt, heben wir nur die Teile hervor, die sich für private Transaktionen unterscheiden.

Bitte beachten Sie, dass der in das Netzwerk hochgeladene Vertrag unveränderlich ist. Daher muss der Zugriff mit Berechtigung (permissioned) den entsprechenden Knoten gewährt werden, indem der öffentliche Vertrag zum Zeitpunkt der Bereitstellung des Vertrags und nicht danach eingeschlossen 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', 
    // Berechtigung für den Vertrag gewähren, indem die öffentlichen Schlüsseln der Knoten eingefügt werden
    privateFor: [publicKey],
  })
  .then((contract) => {
    return contract.options.address;
  });
}

Auf ähnliche Weise werden private Transaktionen durchgeführt – indem die öffentlichen Schlüssel der Teilnehmer zum Zeitpunkt der Ausführung eingefügt werden.

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,
    // Berechtigung gewähren, indem die öffentlichen Schlüssel der Knoten eingefügt werden
    privateFor: [publicKey],
  }).then((receipt) => {
    return receipt.status;
  });
}

Jetzt können wir starten private.js mit den folgenden Ergebnissen:

node private.js
Vertragsadresse nach der Bereitstellung: 0x85dBF88B4dfa47e73608b33454E4e3BA2812B21D
[Node3] Temperatur nach dem Aktualisieren des Vertrags von externen Knoten abgerufen: null
[Node2] Temperatur nach dem Aktualisieren des Vertrags von internen Knoten abgerufen: 12
[Node3] Temperatur von externen Knoten nach dem Update abgerufen: null

Der Quorum-Explorer in Chainstack zeigt Folgendes:

Bereitstellung des Vertrags durch den Teilnehmer Der Supermarkt;
Ausführung SetTemperature ab der Dritten;
Ausführung SetTemperature vom Teilnehmer Anbieter.

Wie Sie sehen, wurden beide Transaktionen ausgeführt, aber nur die Transaktion vom Teilnehmer Anbieter aktualisierte die Temperatur im Vertrag. Somit gewährleisten private Transaktionen Unveränderlichkeit, geben jedoch keine Daten an Dritte weiter.

Fazit

Wir haben ein kommerzielles Nutzungsszenario von Quorum betrachtet, um aktuelle Informationen über die Temperatur in einem Lagerraum bereitzustellen, indem ein Netzwerk zwischen zwei Parteien – einem Supermarkt und dem Lagerbesitzer – eingerichtet wurde.

Wir haben gezeigt, wie aktuelle Informationen über die Temperatur sowohl durch öffentliche als auch durch private Transaktionen aufrechterhalten werden können.

Es kann eine Vielzahl an Nutzungsszenarien geben und, wie Sie sehen, ist es ganz einfach.

Experimentieren Sie, versuchen Sie, Ihr Szenario bereitzustellen. Zumal die Branche für Blockchain-Technologie bis 2024 fast zehnmal wachsen könnte..

Quelle: habr.com