🥇Durchführung von öffentlichen und privaten Transaktionen in der Blockchain von JPMorgan Quorum mit Web3

Quorum — eine auf Ethereum basierende Blockchain, die von JPMorgan entwickelt wurde und kürzlich die erste Distributed-Ledger-Plattform ist, die Microsoft Azure anbietet.

Quorum unterstützt private und öffentliche Transaktionen und bietet zahlreiche kommerzielle Nutzungsszenarien.

In diesem Artikel werden wir ein solches Szenario untersuchen – die Bereitstellung eines Distributed-Ledger-Netzwerks zwischen einem Supermarkt und dem Lagerbesitzer, um aktuelle Informationen über die Temperatur im Lager zu gewährleisten.

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

Der Artikel behandelt:

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

Zur Veranschaulichung wird ein Szenario zur Temperaturüberwachung in den Lagerhäusern der Teilnehmer im Quorum-Netzwerk im Rahmen des Internet der Dinge (IoT) verwendet.

Kontext

Eine Gruppe von Lagerunternehmen schließt sich zu einem Konsortium zusammen, um Informationen gemeinsam zu speichern und Prozesse auf der Blockchain zu automatisieren. Zu diesem Zweck haben die Unternehmen beschlossen, Quorum zu verwenden. In diesem Artikel werden wir zwei Szenarien behandeln: öffentliche Transaktionen und private Transaktionen.

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

Öffentliche Transaktionen sind für alle Mitglieder des Konsortiums einsehbar. Private Transaktionen fügen hingegen eine Ebene der Vertraulichkeit hinzu und sind nur für die Teilnehmer zugänglich, die über entsprechende Berechtigungen verfügen.

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

Smart-Contract

Nachfolgend 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 gesetzt 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.jsfunktioniert, muss er in das ABI- und Bytecode-Format konvertiert werden. Die Verwendung der unten angegebenen Funktion formatContractkompiliert 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, da der Vertrag bereit ist, werden wir das Netzwerk bereitstellen und den Vertrag implementieren.

Bereitstellung von Knoten

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

Im Folgenden finden Sie den Prozess zur Bereitstellung eines Quorum-Netzwerks mit Raft-Konsens und drei Knoten.

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

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

Wir fügen zu dem bereits standardmäßig erstellten Knoten zwei weitere Knoten hinzu:

Drei aktive Knoten:

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

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

Öffentlichen Transaktionen

Kontext

Die Temperatur im Lagerraum ist entscheidend für die Kostensenkung, insbesondere für Produkte, die bei Minusgraden gelagert werden müssen.

Indem sie Unternehmen ermöglichen, die Werte der Außentemperatur an ihrem geografischen Standort in Echtzeit zu teilen und in einem unveränderlichen Register aufzuzeichnen, senken die Teilnehmer des Netzwerks Kosten und Zeit.

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

Wir werden 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 erhalten. Der Vertrag wird den Wert von 3 Grad zurückgeben:
```
const temp = await getTemperature(raft3Node, contractAddress);
console.log('Abgerufene Vertragstemperatur', temp);
```
Als Nächstes sehen wir uns an, wie man eine öffentliche Transaktion im Quorum-Netzwerk mit Hilfe 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 werden den Smart Contract bereitstellen:

// 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 zur Interaktion mit dem Vertrag: 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 um die Temperatur des Vertrags abzurufen. Bitte beachten Sie, dass die Methode call auf dem lokalen 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 public.js ausführen, um das nächste Ergebnis zu erhalten:

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

Anschließend können wir die Aufzeichnungen im Quorum-Explorer im Chainstack-Dashboard wie unten dargestellt ansehen.

Alle drei Knoten haben miteinander 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

Ein häufiges Anliegen von Organisationen ist der Datenschutz. Ein Beispiel ist das Szenario, in dem ein Supermarkt ein Lagerhaus für die Lagerung von Meeresfrüchten von einem separaten Anbieter:

Anbieter unter Einsatz von IoT-Sensoren alle 30 Sekunden Temperaturwerte abruft und diese an den Supermarkt;
Diese Werte sollten nur für den Anbieter und den Supermarkt, der in einem Konsortium verbunden ist, zugänglich sein.

Wir werden vier Aufgaben durchführen, die im obigen Diagramm dargestellt 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 ist. und Anbieter.
Dritte Parteien haben keinen Zugriff auf den Smart Contract.

Wir werden die Methoden get und set im Namen von den Supermarkt ist. und Anbieter zur Demonstration einer privaten Quorum-Transaktion.

Lassen Sie uns 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(`Vertragsadresse nach der Bereitstellung: ${contractAddress}`);

Setzen wir die Temperatur auf Dritte Partei (externer Knoten) und erhalten wir 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}`);

Setzen wir die Temperatur auf Anbieter (interner Knoten) und erhalten wir den Temperaturwert:

Die Temperatur in diesem Szenario sollte den Wert 12 aus dem Smart Contract zurückgeben. Beachten Sie, dass Anbieter hiermit Zugriff auf den Smart Contract gewährt 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}`);

Holen wir die Temperatur von Dritte Partei (externer Knoten):
In Schritt 3 wurde die Temperatur auf den Wert 12 gesetzt, aber Dritte Parteien hat keinen Zugriff auf den Smart Contract. Daher sollte der zurückgegebene Wert 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 uns die Ausführung privater Transaktionen im Quorum-Netz genauer ansehen 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 Zugang mit Erlaubnis (permissioned) durch die entsprechenden Knoten bei der Einbeziehung des öffentlichen Vertrags zum Zeitpunkt der Bereitstellung des Vertrags gewährt werden, und nicht danach.

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üssel der Knoten einbezogen werden
    privateFor: [publicKey],
  })
  .then((contract) => {
    return contract.options.address;
  });
}

Auf die gleiche Weise werden private Transaktionen durchgeführt – durch die Einbeziehung des öffentlichen Schlüssels der Teilnehmer zum Zeitpunkt der Durchfü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,
    // Berechtigung gewähren, indem die öffentlichen Schlüssel der Knoten einbezogen 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 abgerufen nach Aktualisierung des Vertrags von externen Knoten: null
[Node2] Temperatur abgerufen nach Aktualisierung des Vertrags von internen Knoten: 12
[Node3] Temperatur abgerufen von externen Knoten nach Aktualisierung: null

Der Quorum-Explorer in Chainstack zeigt Folgendes an:

Deployment des Vertrags durch den Teilnehmer Der Supermarkt;
Ausführung SetTemperature ab Dritte Partei;
Ausführung SetTemperature durch den Teilnehmer Anbieter.

Wie Sie sehen können, wurden beide Transaktionen durchgeführt, aber nur die Transaktion des Teilnehmers Anbieter hat die Temperatur im Vertrag aktualisiert. So gewährleisten private Transaktionen Unveränderlichkeit, geben jedoch keine Daten an Dritte weiter.

Fazit

Wir haben ein kommerzielles Nutzungsszenario für Quorum betrachtet, um aktuelle Temperaturinformationen im Lager zu gewährleisten, indem wir ein Netzwerk zwischen zwei Parteien - dem Supermarkt und dem Lagerbesitzer - aufbauen.

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

Es können sehr viele Anwendungsszenarien entstehen, und wie Sie sehen, ist es ganz einfach.

Experimentieren Sie, versuchen Sie, Ihr eigenes Szenario zu implementieren. Zumal die Blockchain-Technologie bis 2024 um nahezu das Zehnfache wachsen könnte..

Quelle: habr.com