🥇Avalike ja privaatsete tehingute teostamine JPMorgani Quorumi plokiahelas, kasutades Web3

Quorum — Ethereum-põhine plokiahel, mille on välja töötanud JPMorgan ja mis on hiljuti saanud Microsoft Azure'i poolt pakutakse esimene jaotatud pearaamatute platvorm.

Quorum toetab nii privaatsed kui ka avalikud tehingud ning sellel on palju ärilisi kasutusvõimalusi.

Selles artiklis arutame ühte sellist stsenaariumi — jaotatud pearaamatu võrgu juurutamist supermarketite ja ladude omanike vahel, et tagada ladustustingimuste temperatuuri täpsus.

Kood, mida selles juhendis kasutatakse, asub GitHubi repostaariumist.

Artikkel katab:

nutilepingu loomine;
Quorum võrgustiku juurutamine Chainstack;
Quorum avalikud tehingud;
Quorum privaatsed tehingud.

Illustreerimiseks kasutatakse temperatuuri jälgimise stsenaariumi Quorum võrgu liikmete ladudes Internet of Things (IoT) raames.

Kontekst

Ladustamisettevõtted loovad konsortsiumi, et jagada teavet ja automatiseerida protsesse plokiahelas. Selleks otsustasid ettevõtted kasutada Quorum'i. Selles artiklis katame kaks stsenaariumi: avalikud tehingud ja privaatsed tehingud.

Tehingud luuakse erinevate osalejate poolt, et suhelda konsortsiumiga, mille moodustavad. Iga tehing kas kasutab lepingut või kutsub välja funktsiooni lepingus andmete võrgus üleslaadimiseks. Need toimingud replitseeritakse kõigile võrgus olevatele nodidele.

Avalikud tehingud on kõigile konsortsiumi osalejatele vaatamiseks kergesti kättesaadavad. Privaatsed tehingud lisavad aga konfidentsiaalsuse kihi, ja need on kergesti kättesaadavad ainult neile osalejatele, kellel on selleks õigused.

Mõlemas scenaaris kasutame silmapaistvuse tõttu ühte ja sama lepingut.

Nutileping

Allpool on lihtne nutileping, mis on loodud meie stsenaariumi jaoks. Sellel on avalik muutuja temperature, mida saab muuta meetodi set ja mis on saadaval meetodi 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;
  }
}

Kuna leping peab töötama web3.js, peab see olema konverteeritud ABI ja bytecode formaati. Funktsiooni formatContract, mis on allpool esitatud, kompileerib lepingut kasutades solc-js.

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

Valminud leping näeb välja järgmiselt:

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

Nüüd, kui leping on valmis, käivitame võrgu ja juurutame lepingu.

Node'ide juurutamine

Node'ide juurutamine võib olla üsna aeganõudev ja seda protsessi saab asendada teenuse kasutamisega. Chainstack.

Allpool on toodud Quorum võrgu juurutamise protsess Rafti konsensuse ja kolme node'iga.

Alustamiseks loome projekti ja nimetame selle Quorum projektiks:

Loome Quorum võrgu Rafti konsensusega Google Cloud Platformis:

Lisame juba loodud vaikimisi node'ile veel kaks node'id:

Kolm aktiivset node'ed:

Node'i detailide leht näitab RPC lõpp-punkti, avalikku võtme jne.

Võrk on juurutatud. Nüüd keskendume nutilepingute juurutamisele ja tehingute tegemisele kasutades. web3.js.

Avalikud tehingud

Kontekst

Laokambrist saadud temperatuur on kulude vähendamiseks väga oluline, eriti toodetele, mis on ette nähtud madalatel temperatuuridel ladustamiseks.

Andmete jagamine välise temperatuuriga oma geograafilises asukohas reaalajas ja selle salvestamine muutumatutesse registritesse võimaldab ettevõtetel vähendada kulusid ja aega.

Me täidame kolm ülesannet, nagu on näidatud diagrammil:

Leidsime lepingu kaudu Node 1:

const contractAddress = await deployContract(raft1Node);
console.log(`Lepingu aadress pärast juurutamist: ${contractAddress}`);

Seame temperatuuri läbi Node 2 kolme kraadi võrra:

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

Node 3 saab teavet nutilepingust. Leping tagastab väärtuse 3 kraadi:
```
const temp = await getTemperature(raft3Node, contractAddress);
console.log('Saadud lepingu temperatuur', temp);
```
Edasi vaatame, kuidas teostada avalikku tehingut Quorum'is, kasutades web3.js.

Algatame instantsi kolme sõlme kaudu RPC:

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

Leidke nutileping:

// 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 pakub kahte meetodit, et suhelda lepinguga: call ja send.

Uuendame lepingu temperatuuri teostamisega set kasutades web3 meetodit 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;
  });
}

Edasi kasutame web3 meetodit call lepingute temperatuuri saamiseks. Pange tähele, et meetod call käivitub kohaliku noodiga ja plokiahelas tehingut ei registreerita.

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

Nüüd saame käivitada public.js järgmise tulemuse saamiseks:

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

Edasi saame näha kirjeid Quorum'i eksploreris Chainstacki paneelil, nagu allpool näidatud.

Kõik kolm nooti suhtlesid ja tehingud uuendati:

Esimene tehing tõstis lepingut.
Teine tehing seadis lepingute temperatuuri 3 kraadi.
Temperatuuri saamine toimub kohaliku noodiga, seega tehingut ei registreerita.

Privaatsed tehingud

Kontekst

Organisatsioonide sage nõue on andmete kaitsmine. Näiteks arutame stsenaariumi, kus Supermarket rendib laopinda mereandide hoidmiseks eraldi Teenusepakkuja:

Tarnija IoT-anduritena loetakse temperatuuri väärtusi iga 30 sekundi järel ja edastatakse Supermarketile;
need väärtused peavad olema kättesaadavad ainult Teenusepakkujale ja Supermarketile, mis on ühendatud konsortsiumi võrku.

Viime ellu neli ülesannet, nagu on illustreeritud ülaltoodud diagrammil.

Kasutame sama kolme sõlme eelnevas stsenaariumis privaatsete tehingute demonstreerimiseks:
Supermarket tõukab välja nutileping, mis on privaatsed Supermarketile ja Teenusepakkuja.
Kolmas osaline ei pääse nutilepingule.

Kutsume välja meetodeid get ja set esindajana Supermarketile ja Teenusepakkuja Quorum'i privaatse tehingu demonstreerimiseks.

Käivitame privaatsed lepingud osalejate jaoks Supermarket ja Tarnija osaleja kaudu Supermarket:

const contractAddress = await deployContract(
raft1Node,
process.env.PK2,
);
console.log(`Lepingu aadress pärast juurutamist: ${contractAddress}`);

Seame temperatuuri Kolmandalt osaliselt (välisest sõlmest) ja saame temperatuuri väärtuse:

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

Seame temperatuuri Teenusepakkuja (sisemisest sõlmest) ja saame temperatuuri väärtuse:

Temperatuur peaks selles stsenaariumis nutilepingust tagastama väärtuse 12. Pange tähele, et Tarnija siin on lubatud juurdepääs nutilepingule.

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

Saame temperatuuri Kolmandalt osaliselt (välisest sõlmest):
Sammule 3 seati temperatuur väärtuseks 12, kuid Kolmas osaline ei pääse nutilepingule. Seetõttu peaks tagastus olema null.
```
// This returns null
const temp3 = await getTemperature(raft3Node, contractAddress);
console.log(`[Node3] temp retrieved from external nodes after update ${temp}`);
```
Vaatame põhjalikumalt privaatsete tehingute täitmist Quorum'i võrgus web3.js. Kuna enamus koodist on jagatud avalike tehingutega, eristame ainult neid osi, mis on erinevad privaatsete tehingute jaoks.

Pange tähele, et võrku laaditud leping on muutamatu, seetõttu peab juurdepääs (permissioned) olema antud vastavatele sõlmedele, lisades avaliku lepingu lepingu juurutamise hetkel, mitte hiljem.

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

Sarnasel viisil toimuvad privaatsete tehingute teostamine — lisades osalejate avaliku võtme teostamise hetkel.

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

Nüüd saame käivitada private.js järgnevate tulemustega:

node private.js
Lepingu aadress pärast juurutamist: 0x85dBF88B4dfa47e73608b33454E4e3BA2812B21D
[Node3] ajutine, mis on saadud lepingu värskendamisel välistest sõlmedest: null
[Node2] ajutine, mis on saadud lepingu värskendamisel sisemistest sõlmedest: 12
[Node3] ajutine, mis on saadud välistest sõlmedest pärast värskendust null

Quorum'i eksplorer Chainstackis näitab järgmist:

lepingu juurutamine osaleja poolt Supermarket;
Täitmises SetTemperature alates Kolmandalt osaliselt;
Täitmises SetTemperature osaleja poolt Tarnija.

Nagu näete, on mõlemad tehingud toimunud, kuid ainult osaleja tehing Tarnija uuendas temperatuuri lepingus. Seega tagavad privaattehingud muutumatuse, kuid samas ei paljasta kolmandale osapoolele andmeid.

Kokkuvõte

Oleme käsitlenud Quorum'i ärilisse stsenaariumisse, et tagada vajalik teave temperatuuri kohta laohoones, juurutades võrku kahe osapoole vahel — supermarket ja lao omanik.

Oleme näidanud, kuidas vajalik teave temperatuuri kohta võib püsida nii avalike kui ka privaatsete tehingute kaudu.

Rakendusskeeme võib olla väga palju ja nagu näete, ei ole see sugugi keeruline.

Katsuge, proovige juurutada oma stsenaariumi. Eriti arvestades, et plokiahela tehnoloogia tööstus võib 2024. aastaks kasvada peaaegu kümme korda..

Allikas: habr.com