🥇Performing ëffentlech a privat Transaktiounen op der JPMorgan Quorum blockchain benotzt Web3

Quorum ass eng Ethereum-baséiert Blockchain entwéckelt vum JPMorgan a gouf viru kuerzem déi éischt verdeelt Ledger Plattform déi vu Microsoft Azure ugebuede gëtt.

Quorum ënnerstëtzt privat an ëffentlech Transaktiounen an huet vill kommerziell Notzungsfäll.

An dësem Artikel wäerte mir een esou Szenario ënnersichen - den Détachement vun engem verdeelt Ledger Netzwierk tëscht engem Supermarché an engem Lagerbesëtzer fir aktuell Informatioun iwwer d'Temperatur vum Lager ze liwweren.

De Code deen an dësem Tutorial benotzt gëtt ass an Repositories op GitHub.

Den Artikel deckt:

Schafung vun engem Smart Kontrakt;
Détachement vum Quorum Netzwierk benotzt Kettenstack;
Quorum ëffentlech Transaktiounen;
Quorum privat Transaktiounen.

Fir ze illustréieren, benotze mir e Szenario fir d'Temperatur an de Lagere vu Membere vum Quorum Netzwierk am Internet of Things (IoT) ze iwwerwaachen.

Kontext

Eng Grupp vu Lagerfirmen vereenegt sech an engem Konsortium fir zesummen Informatioun ze späicheren an Prozesser op der Blockchain ze automatiséieren. Fir dëst hunn d'Firmen decidéiert de Quorum ze benotzen. An dësem Artikel wäerte mir zwee Szenarie ofdecken: ëffentlech Transaktiounen a privat Transaktiounen.

Transaktioune gi vu verschiddene Participanten erstallt fir mam Konsortium ze interagéieren, zu deem se gehéieren. All Transaktioun benotzt entweder e Kontrakt oder rifft eng Funktioun am Kontrakt fir Daten an d'Netz eropzelueden. Dës Aktiounen ginn op all Noden am Netz replizéiert.

Ëffentlech Transaktioune si verfügbar fir ze gesinn vun all Konsortium Participanten. Privat Transaktiounen addéieren eng Schicht vu Vertraulechkeet a sinn nëmme verfügbar fir déi Participanten déi Rechter hunn dat ze maachen.

Fir béid Szenarie benotze mir dee selwechte Kontrakt fir Kloerheet.

Smart Kontrakt

Drënner ass en einfache Smart Kontrakt erstallt fir eise Szenario. Et huet eng ëffentlech Variabel temperature, déi geännert ka ginn benotzt set a kréien duerch Method 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;
  }
}

Fir de Kontrakt mat ze schaffen web3.js, et muss an ABI Format a Bytecode iwwersat ginn. Benotzt d'Funktioun formatContractdrënner kompiléiert de Kontrakt benotzt solc-js.

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

De fäerdege Kontrakt gesäit esou 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

Elo datt de Kontrakt fäerdeg ass, wäerte mir d'Netzwierk ofsetzen an de Kontrakt ofsetzen.

Node Détachement

En Node z'installéieren kann zimmlech Aarbechtsintensiv sinn an dëse Prozess kann duerch e Service ersat ginn Kettenstack.

Drënner ass de Prozess fir de Quorum Netzwierk mat Raft Konsens an dräi Noden z'installéieren.

Als éischt, loosst eis e Projet erstellen an et Quorum Project nennen:

Loosst eis e Quorum Netzwierk mat Raft Konsens op Google Cloud Plattform erstellen:

Loosst eis zwee méi Wirbelen op den Node addéieren, dee scho standardiséiert gouf:

Dräi lafenden Noden:

D'Node Detailer Säit weist den RPC Endpunkt, ëffentleche Schlëssel, etc.

D'Netz ass ofgebaut. Loosst eis elo Smart Kontrakter ofsetzen an Transaktiounen ausféieren mat web3.js.

Ëffentlech Transaktiounen

Kontext

Warehouse Temperatur ass vu grousser Wichtegkeet fir d'Käschte ze reduzéieren, besonnesch fir Produkter déi virgesi sinn fir bei Temperaturen ënner Null ze späicheren.

Andeems Dir Firmen erlaabt d'Äussertemperatur vun hirer geographescher Positioun an Echtzäit ze deelen an et an engem onverännerbare Ledger opzehuelen, reduzéieren d'Netzwierk Participanten d'Käschte an d'Zäit.

Mir wäerten dräi Aufgaben ausféieren, illustréiert am Diagramm:

Mir setzen de Kontrakt iwwer Node 1:

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

Setzt d'Temperatur duerch Node 2 ëm 3 Grad:

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

Node 3 wäert Informatiounen aus dem Smart Kontrakt kréien. De Kontrakt gëtt de Wäert 3 Grad zréck:
```
const temp = await getTemperature(raft3Node, contractAddress);
console.log(‘Retrieved contract Temperature’, temp);
```
Als nächst wäerte mir kucken wéi Dir eng ëffentlech Transaktioun am Quorum Netzwierk ausféiert web3.js.

Mir initiéieren eng Instanz iwwer RPC fir dräi Noden:

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

Loosst eis de Smart Kontrakt ofsetzen:

// 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 bitt zwou Methoden fir mat dem Kontrakt ze interagéieren: call и send.

Loosst eis d'Kontrakttemperatur aktualiséieren andeems Dir ausféiert set benotzt Web3 Method 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ächst benotze mir d'Web3 Method call d'Kontrakttemperatur ze kréien. Maacht weg datt d'Method call gëtt op engem lokalen Node ausgefouert an d'Transaktioun gëtt net op der Blockchain erstallt.

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

Elo kënnt Dir lafen public.js fir dat folgend Resultat ze kréien:

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

Als nächst kënne mir d'Entréen am Quorum Explorer am Chainstack Panel kucken, wéi hei ënnendrënner.

All dräi Noden interagéiert an d'Transaktioune goufen aktualiséiert:

Déi éischt Transaktioun huet de Kontrakt ofgesat.
Déi zweet Transaktioun huet d'Kontrakttemperatur op 3 Grad gesat.
D'Temperatur gëtt duerch e lokalen Node kritt, sou datt keng Transaktioun erstallt gëtt.

Privat Transaktiounen

Kontext

Eng gemeinsam Ufuerderung vun Organisatiounen ass Dateschutz. Als Beispill, betruecht engem Szenario an deem Supermarché lount e Lagerraum fir Seafood aus enger separater ze späicheren Verkeefer:

Verkeefer benotzt IoT Sensoren, liest Temperaturwäerter all 30 Sekonnen a vermëttelt se An de Supermarché;
dës Wäerter sollten nëmme verfügbar sinn An de Verkeefer и An de Supermarché, vernetzt vun engem Konsortium.

Mir wäerten déi véier Aufgaben ofgeschloss, déi am Diagramm hei uewen illustréiert sinn.

Mir benotzen déiselwecht dräi Wirbelen aus dem virege Szenario fir privat Transaktiounen ze demonstréieren:
Supermarché setzt e Smart Kontrakt deen privat ass Supermarché и Verkeefer.
Déi drëtt Säit huet net d'Recht op Zougang zum Smart Kontrakt.

Mir wäerten d'Methoden nennen get и set am Numm vun Supermarché и Verkeefer eng privat Quorum Transaktioun ze demonstréieren.

Mir wäerten e private Kontrakt fir d'Participanten ofsetzen Supermarché и Verkeefer duerch e Participant Supermarché:

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

Loosst eis d'Temperatur vun Drëtt Partei (extern Node) a kritt den Temperaturwäert:

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

Loosst eis d'Temperatur vun Verkeefer (internen Node) a kritt den Temperaturwäert:

D'Temperatur an dësem Szenario soll de Wäert zréckginn 12 vum Smart Kontrakt Verkeefer hei huet autoriséiert Zougang zu der Smart Kontrakt.

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

Mir kréien d'Temperatur vun Drëtt Partei (extern Node):

Am Schrëtt 3 war d'Temperatur op 12 gesat, awer Déi drëtt Säit huet keen Zougang zum Smart Kontrakt. Dofir muss de Retourwäert null sinn.
```
// This returns null
const temp3 = await getTemperature(raft3Node, contractAddress);
console.log(`[Node3] temp retrieved from external nodes after update ${temp}`);
```
Als nächst wäerte mir e méi no kucken op d'Ausféierung vun privaten Transaktiounen am Quorumnetz mat web3.js. Well de gréissten Deel vum Code d'selwecht ass fir ëffentlech Transaktiounen, markéiere mir nëmmen déi Deeler déi fir privat Transaktiounen ënnerschiddlech sinn.

Bedenkt datt de Kontrakt, deen an d'Netz eropgelueden ass, onverännerbar ass, sou datt den autoriséierten Zougang zu de passenden Node muss ginn, andeems den ëffentleche Kontrakt aktivéiert gëtt zur Zäit wou de Kontrakt ofgebaut gëtt, net duerno.

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

Privat Transaktioune ginn op eng ähnlech Manéier duerchgefouert - andeems de ëffentleche Schlëssel vun de Participanten zur Zäit vun der Ausféierung abegraff ass.

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

Elo kënne mir lafen privat.js mat de folgende Resultater:

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

De Quorum Explorer am Chainstack wäert déi folgend weisen:

Ofbau vum Kontrakt vum Participant Supermarché;
Leeschtung SetTemperature от Drëtt Partei;
Leeschtung SetTemperature vun engem Participant Verkeefer.

Wéi Dir gesitt, sinn béid Transaktiounen ofgeschloss, awer nëmmen d'Transaktioun vum Participant Verkeefer aktualiséiert d'Temperatur am Kontrakt. Also, privat Transaktiounen bidden onverännerbarkeet, awer gläichzäiteg verroden keng Donnéeën un eng Drëtt Partei.

Konklusioun

Mir hunn e kommerziellen Benotzungsfall fir Quorum gekuckt fir aktuell Temperaturinformatioun an engem Lager ze liwweren andeems en Netzwierk tëscht zwou Parteien ofgebaut gëtt - e Supermarché an e Lagerbesëtzer.

Mir hu gewisen, wéi aktuell Temperaturinformatioun duerch ëffentlech a privat Transaktiounen erhale ka ginn.

Et kënne vill Applikatiounsszenarie sinn an, wéi Dir gesitt, ass et guer net schwéier.

Experimentéiert, probéiert Äert Skript auszebauen. Ausserdeem ass d'Blockchain Technologie Industrie kéint bis 2024 bal zéngmol wuessen.

Source: will.com

Maacht ëffentlech a privat Transaktiounen op der JPMorgan Quorum Blockchain mat Web3

Kontext

Smart Kontrakt

Node Détachement

Ëffentlech Transaktiounen

Kontext

Privat Transaktiounen

Kontext

Konklusioun

Setzt e Commentaire annuléieren reply