🥇 Provádění veřejných a soukromých transakcí v blockchainu JPMorgan Quorum pomocí Web3

Quorum — blockchain založený na Ethereum, vyvinutý firmou JPMorgan, který se nedávno stal první platformou distribuované knihy nabízenou Microsoft Azure.

Quorum podporuje soukromé i veřejné transakce a má mnoho komerčních scénářů použití.

V tomto článku se podíváme na jeden z těchto scénářů — nasazení sítě distribuované knihy mezi supermarketem a vlastníkem skladu za účelem zajištění aktuálních informací o teplotě skladovacích prostor.

Kód použitý v této příručce se nachází v repozitáři na GitHubu.

Článek pokrývá:

vytvoření chytrého kontraktu;
nasazení sítě Quorum pomocí Chainstack;
veřejné transakce Quorum;
soukromé transakce Quorum.

Pro ilustraci se používá scénář monitorování teploty ve skladovacích prostorech účastníků sítě Quorum v rámci Internet of Things (IoT).

Kontext

Skupina skladovacích společností se spojuje do konsorcia pro společné uchovávání informací a automatizaci procesů na blockchainu. Z tohoto důvodu se společnosti rozhodly využít Quorum. V tomto článku pokryjeme dva scénáře: veřejné transakce a soukromé transakce.

Transakce vytvářejí různí účastníci pro interakci s konsorciem, kterému patří. Každá transakce buď nasazuje kontrakt, nebo vyvolává funkci v kontraktu pro načtení dat do sítě. Tyto akce se replikují na všechny uzly v síti.

Veřejné transakce jsou dostupné k nahlédnutí všem účastníkům konsorcia. Soukromé transakce však přidávají vrstvu důvěrnosti a jsou dostupné pouze těm účastníkům, kteří mají na to práva.

Pro oba scénáře používáme pro názornost stejný kontrakt.

Chytrý kontrakt

Níže je uveden jednoduchý chytrý kontrakt vytvořený pro náš scénář. Obsahuje veřejnou proměnnou temperature, kterou lze měnit metodou set a získávat metodou získat.

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 kontrakt fungoval se web3.js, je třeba ho převést do formátu ABI a bajtkódu. Použití funkce formatContract, uvedené níže, kompiluje kontrakt pomocí solc-js.

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

Hotový kontrakt vypadá 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

Nyní, když je kontrakt připraven, nasadíme síť a nasadíme kontrakt.

Nasazení uzlů

Nasazení uzlu může být poměrně zdlouhavé a tento proces lze nahradit použitím služby Chainstack.

Níže je uveden proces nasazení sítě Quorum s konsensem Raft a třemi uzly.

Nejprve vytvoříme projekt a pojmenujeme ho Quorum Project:

Vytvoříme síť Quorum s konsensem Raft na Google Cloud Platform:

K již vytvořenému uzlu přidáme další dva uzly:

Tři spuštěné uzly:

Stránka podrobností uzlu ukazuje RPC endpoint, veřejný klíč atd.

Síť je nasazena. Nyní se zaměříme na nasazení smart kontraktů a provádění transakcí pomocí web3.js.

Veřejné transakce

Kontext

Teplota ve skladu má velký význam pro snižování nákladů, zejména pro produkty určené k uložení při záporné teplotě.

Umožněním firmám sdílet hodnoty vnější teploty jejich geografického umístění v reálném čase a zapisovat je do neměnného registru, účastníci sítě snižují náklady a čas.

Provedeme tři úkoly, jak je znázorněno na diagramu:

Nasadíme kontrakt přes Uzlu 1:

const contractAddress = await deployContract(raft1Node);
console.log(`Adresa kontraktu po nasazení: ${contractAddress}`);

Nastavíme teplotu přes Uzlu 2 na 3 stupně:

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

Uzlu 3 dostane informace ze smart kontraktu. Kontrakt vrátí hodnotu 3 stupně:
```
const temp = await getTemperature(raft3Node, contractAddress);
console.log('Získaná teplota kontraktu', temp);
```
Dále se podíváme, jak vykonat veřejnou transakci v síti Quorum za použití web3.js.

Inicializujeme instanci přes RPC pro tři 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,
 },
);

Nasadíme 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 nabízí dvě metody pro interakci s kontraktem: call a send.

Aktualizujeme teplotu kontraktu provedením set použitím metody 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;
  });
}

Dále použijeme metodu web3 call pro získání teploty kontraktu. Všimněte si, že metoda call se provádí na místním uzlu a na blockchainu transakce vytvořena nebude.

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

Nyní můžeme spustit public.js pro získání následujícího výsledku:

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

Nyní se můžeme podívat na záznamy v prohlížeči Quorum na panelu Chainstack, jak je ukázáno níže.

Všechny tři uzly vzájemně komunikovaly a transakce byly aktualizovány:

První transakce nasadila kontrakt.
Druhá transakce nastavila teplotu kontraktu na 3 stupně.
Získání teploty probíhá přes místní uzel, proto transakce nebyla vytvořena.

Privátní transakce

Kontext

Častým požadavkem organizací je ochrana dat. Jako příklad zvažme scénář, ve kterém supermarket pronajímá skladové prostory k uskladnění mořských plodů od jednotlivého dodavatele:

dodavatel pomocí IoT senzorů měří teplotní hodnoty každých 30 sekund a předává je supermarketu,;
tyto hodnoty by měly být přístupné pouze dodavateli a supermarketu,, který je součástí konsorcia.

Provedeme čtyři úkoly, které jsou znázorněny na výše uvedeném diagramu.

Použijeme stejné tři uzly z předchozího scénáře k demonstraci privátních transakcí:
Supermarket nasadí chytrý kontrakt, který je privátní pro supermarket. a dodavatele.
Třetí strana nemá přístup k chytrému kontraktu.

Vyvoláme metody získat a set jménem supermarket. a dodavatele k demonstraci privátní transakce Quorum.

Nasadíme privátní kontrakt pro účastníky Supermarket a dodavatel prostřednictvím účastníka Supermarket:

const contractAddress = await deployContract(
raft1Node,
process.env.PK2,
);
console.log(`Adresa kontraktu po nasazení: ${contractAddress}`);

Nastavíme teplotu od třetí strany (externí uzel) a získáme 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}`);

Nastavíme teplotu od dodavatele (interní uzel) a získáme hodnotu teploty:

Teplota v tomto scénáři by měla vrátit hodnotu 12 ze smart kontraktu. Všimněte si, že dodavatel má povolený přístup k chytrému 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}`);

Získáme teplotu od třetí strany (externí uzel):
Ve třetím kroku byla teplota nastavena na 12, ale Třetí strana nemá přístup k chytrému kontraktu. Proto by měla být vrácena hodnota null.
```
// This returns null
const temp3 = await getTemperature(raft3Node, contractAddress);
console.log(`[Node3] temp retrieved from external nodes after update ${temp}`);
```
Nyní se podrobněji podíváme na provádění privátních transakcí v síti Quorum s web3.js. Vzhledem k tomu, že většina kódu se shoduje s veřejnými transakcemi, zdůrazníme pouze ty části, které se liší pro privátní transakce.

Vezměte prosím na vědomí, že smlouva nahraná do sítě je neměnná, a proto musí být přístup s oprávněním (permissioned) udělen příslušným uzlům zahrnutím veřejné smlouvy v okamžiku nasazení smlouvy, nikoli až poté.

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’, 
    // Udělit oprávnění smlouvě zahrnutím veřejných klíčů uzlů
    privateFor: [publicKey],
  })
  .then((contract) => {
    return contract.options.address;
  });
}

Podobným způsobem se provádějí soukromé transakce — tím, že se zahrnuje veřejný klíč účastníků v okamžiku provedení.

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,
    // Udělit oprávnění zahrnutím veřejných klíčů uzlů
    privateFor: [publicKey],
  }).then((receipt) => {
    return receipt.status;
  });
}

Nyní můžeme spustit private.js s následujícími výsledky:

node private.js
Adresa smlouvy po nasazení: 0x85dBF88B4dfa47e73608b33454E4e3BA2812B21D
[Node3] teplota získaná po aktualizaci smlouvy z externích uzlů: null
[Node2] teplota získaná po aktualizaci smlouvy z interních uzlů: 12
[Node3] teplota získaná z externích uzlů po aktualizaci: null

Explorer Quorum v Chainstack zobrazí následující:

nasazení smlouvy od účastníka Supermarket;
Provedení SetTemperature od třetí strany;
Provedení SetTemperature od účastníka dodavatel.

Jak vidíte, obě transakce byly provedeny, ale pouze transakce od účastníka dodavatel aktualizovala teplotu ve smlouvě. Tímto způsobem soukromé transakce zajišťují neměnnost, ale zároveň nezveřejňují data třetí straně.

Závěr

Prozkoumali jsme obchodní scénář použití Quorum k zajištění aktuálních informací o teplotě ve skladové místnosti pomocí nasazení sítě mezi dvěma stranami — supermarketem a vlastníkem skladu.

Ukázali jsme, jak mohou být aktuální informace o teplotě udržovány jak prostřednictvím veřejných, tak prostřednictvím soukromých transakcí.

Aplikačních scénářů může být velmi mnoho a, jak vidíte, není to vůbec složité.

Experimentujte, zkuste nasadit svůj scénář. Tím víc, že průmysl blockchainových technologií by mohl do roku 2024 vyrůst téměř desetinásobně.

Zdroj: habr.com