Vykonávajte verejné a súkromné ​​transakcie na blockchaine JPMorgan Quorum pomocou Web3

kvórum je blockchain založený na Ethereu vyvinutý spoločnosťou JPMorgan a najnovšie sa stal prvou platformou distribuovanej účtovnej knihy, ktorú ponúka Microsoft Azure.

Kvórum podporuje súkromné ​​a verejné transakcie a má mnoho prípadov komerčného využitia.

V tomto článku preskúmame jeden takýto scenár – nasadenie distribuovanej účtovnej siete medzi supermarketom a majiteľom skladu, aby sme poskytli aktuálne informácie o teplote skladu.

Kód použitý v tomto návode je in úložiská na GitHub.

Článok pokrýva:

• vytvorenie inteligentnej zmluvy;
• nasadenie siete Kvóra pomocou Chainstack;
• Verejné transakcie kvóra;
• Súkromné ​​transakcie kvóra.

Na ilustráciu použijeme scenár sledovania teploty v skladoch členov siete Quorum v rámci internetu vecí (IoT).

kontext

Skupina skladových spoločností sa spája do konzorcia, aby spoločne uložili informácie a automatizovali procesy na blockchaine. Na tento účel sa spoločnosti rozhodli použiť Kvórum. V tomto článku sa budeme zaoberať dvoma scenármi: verejnými transakciami a súkromnými transakciami.

Transakcie vytvárajú rôzni účastníci na interakciu s konzorciom, do ktorého patria. Každá transakcia buď nasadí zmluvu, alebo zavolá funkciu v zmluve na nahranie údajov do siete. Tieto akcie sa replikujú na všetky uzly v sieti.

Verejné transakcie si môžu pozrieť všetci účastníci konzorcia. Súkromné ​​transakcie pridávajú vrstvu dôvernosti a sú dostupné len tým účastníkom, ktorí na to majú právo.

Pre obidva scenáre používame pre prehľadnosť rovnakú zmluvu.

Inteligentná zmluva

Nižšie je uvedená jednoduchá inteligentná zmluva vytvorená pre náš scenár. Má verejnú premennú temperature, ktorý je možné zmeniť pomocou set a prijímať metódou 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;
  }
}

Aby zmluva fungovala web3.js, musí byť preložený do formátu ABI a bajtkódu. Pomocou funkcie formatContractnižšie zostavuje zmluvu pomocou solc-js.

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

Hotová zmluva vyzerá takto:

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

Teraz, keď je zmluva pripravená, nasadíme sieť a nasadíme zmluvu.

Nasadenie uzla

Nasadenie uzla môže byť dosť náročné na prácu a tento proces možno nahradiť použitím služby Chainstack.

Nižšie je uvedený proces nasadenia siete Quorum s konsenzom Raft a tromi uzlami.

Najprv vytvorte projekt a nazvime ho Projekt kvóra:

Poďme vytvoriť sieť kvóra s konsenzom Raft na platforme Google Cloud:

Pridajme ďalšie dva uzly k uzlu, ktorý už bol predvolene vytvorený:

Tri bežiace uzly:

Stránka s podrobnosťami o uzle zobrazuje koncový bod RPC, verejný kľúč atď.

Sieť je nasadená. Teraz poďme nasadiť inteligentné zmluvy a vykonávať transakcie pomocou web3.js.

Verejné transakcie

kontext

Teplota v sklade má veľký význam pri znižovaní nákladov, najmä pri produktoch určených na skladovanie pri mínusových teplotách.

Tým, že spoločnostiam umožňujú zdieľať vonkajšiu teplotu ich geografickej polohy v reálnom čase a zaznamenávať ju do nemennej účtovnej knihy, účastníci siete znižujú náklady a čas.

Vykonáme tri úlohy znázornené na obrázku:

1. Zmluvu nasadíme cez Uzol 1:

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

2. Nastavte teplotu cez Uzol 2 o 3 stupne:

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

3. Uzol 3 dostane informácie zo smart kontraktu. Zmluva vráti hodnotu 3 stupne:

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

   Ďalej sa pozrieme na to, ako vykonať verejnú transakciu v sieti Quorum pomocou web3.js.

Spustíme inštanciu prostredníctvom RPC pre tri uzly:

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

Poďme nasadiť smart kontrakt:

// 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 poskytuje dva spôsoby interakcie so zmluvou: call и send.

Aktualizujme zmluvnú teplotu vykonaním set pomocou metódy web3 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;
  });
}

Ďalej použijeme metódu web3 call na získanie zmluvnej teploty. Upozorňujeme, že metóda call sa vykonáva na lokálnom uzle a transakcia sa nevytvorí na blockchaine.

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

Teraz môžete bežať public.js aby ste získali nasledujúci výsledok:

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

Ďalej môžeme zobraziť položky v prieskumníkovi Kvóra na paneli Chainstack, ako je znázornené nižšie.

Všetky tri uzly interagovali a transakcie boli aktualizované:

1. Prvá transakcia nasadila zmluvu.
2. Druhá transakcia nastavila zmluvnú teplotu na 3 stupne.
3. Teplota sa prijíma cez lokálny uzol, takže sa nevytvorí žiadna transakcia.

Súkromné ​​transakcie

kontext

Spoločnou požiadavkou organizácií je ochrana údajov. Ako príklad si predstavte scenár, v ktorom Supermarket prenajíma skladové priestory na skladovanie morských plodov od samostatn Predajca:

• Predajca pomocou IoT senzorov číta hodnoty teploty každých 30 sekúnd a prenáša ich Do supermarketu;
• tieto hodnoty by mali byť dostupné K predajcovi и Do supermarketu, prepojené konzorciom.

Dokončíme štyri úlohy znázornené na obrázku vyššie.

• Na demonštráciu súkromných transakcií používame rovnaké tri uzly z predchádzajúceho scenára:
• supermarket nasadí inteligentnú zmluvu, ktorá je súkromná Supermarket и Predajca.
• Tretia strana nemá právo na prístup k smart kontraktu.

Zavoláme metódy get и set v mene Supermarket и Predajca na preukázanie súkromnej transakcie Kvóra.

1. Pre účastníkov nasadíme súkromnú zmluvu supermarket и Predajca prostredníctvom účastníka supermarket:

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

2. Nastavíme teplotu od Tretia strana (externý uzol) a získajte hodnotu teploty:

   // 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. Nastavíme teplotu od Predajca (vnútorný uzol) a získajte hodnotu teploty:

   Teplota v tomto scenári by mala vrátiť hodnotu 12 zo smart kontraktu Predajca tu má autorizovaný prístup k smart kontraktu.

   // 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. Teplotu získavame z Tretia strana (externý uzol):

   V kroku 3 bola teplota nastavená na 12, ale Tretia strana nemá prístup k smart kontraktu. Preto musí byť návratová hodnota null.

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

   Ďalej sa bližšie pozrieme na vykonávanie súkromných transakcií v sieti Quorum s web3.js. Keďže väčšina kódu je rovnaká pre verejné transakcie, zvýrazníme len tie časti, ktoré sa líšia pre súkromné ​​transakcie.

Upozorňujeme, že zmluva nahraná do siete je nemenná, takže príslušným uzlom musí byť udelený povolený prístup povolením verejnej zmluvy v čase nasadenia zmluvy, nie potom.

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

Súkromné ​​transakcie sa vykonávajú podobným spôsobom – zahrnutím verejného kľúča účastníkov v čase vykonania.

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

Teraz môžeme bežať private.js s nasledujúcimi výsledkami:

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

Prieskumník Kvóra v Chainstacku zobrazí nasledovné:

• nasadenie zmluvy od účastníka supermarket;
• poprava SetTemperature od Tretia strana;
• poprava SetTemperature od účastníka Predajca.

Ako vidíte, obe transakcie sú dokončené, ale iba transakcia od účastníka Predajca aktualizoval teplotu v zmluve. Súkromné ​​transakcie teda poskytujú nemennosť, no zároveň neprezradia údaje tretej strane.

Záver

Pozreli sme sa na prípad komerčného využitia pre Quorum na poskytovanie aktuálnych informácií o teplote v sklade nasadením siete medzi dvoma stranami – supermarketom a vlastníkom skladu.

Ukázali sme, ako je možné udržiavať aktuálne informácie o teplote prostredníctvom verejných aj súkromných transakcií.

Aplikačných scenárov môže byť veľa a ako vidíte, nie je to vôbec zložité.

Experimentujte, skúste rozšíriť svoj skript. Navyše, technologický priemysel blockchain môže do roku 2024 vzrásť takmer desaťnásobne.

Zdroj: hab.com