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

Kvorum je blockchain založený na Ethereu vyvinutý společností JPMorgan a nedávno se stal první platformou distribuované účetní knihy nabízenou společností Microsoft Azure.

Quorum podporuje soukromé a veřejné transakce a má mnoho případů komerčního použití.

V tomto článku prozkoumáme jeden takový scénář – nasazení sítě distribuovaných účetních knih mezi supermarketem a majitelem skladu za účelem poskytování aktuálních informací o teplotě skladu.

Kód použitý v tomto tutoriálu je in úložiště na GitHubu.

Článek pokrývá:

vytvoření chytré smlouvy;
nasazení sítě Quorum pomocí řetězový zásobník;
Kvorum veřejné transakce;
Soukromé transakce kvora.

Pro ilustraci používáme scénář pro sledování teploty ve skladech členů sítě Quorum v rámci internetu věcí (IoT).

Kontext

Skupina skladových společností se sjednocuje v konsorcium, které společně ukládá informace a automatizuje procesy na blockchainu. K tomu se společnosti rozhodly využít Quorum. V tomto článku pokryjeme dva scénáře: veřejné transakce a soukromé transakce.

Transakce jsou vytvářeny různými účastníky za účelem interakce s konsorciem, ke kterému patří. Každá transakce buď nasadí smlouvu, nebo zavolá funkci ve smlouvě, která nahraje data do sítě. Tyto akce jsou replikovány na všechny uzly v síti.

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

Pro oba scénáře používáme pro přehlednost stejnou smlouvu.

Inteligentní smlouva

Níže je jednoduchá chytrá smlouva vytvořená pro náš scénář. Má veřejnou proměnnou temperature, které lze změnit pomocí set a přijímat metodou 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 smlouva fungovala web3.js, musí být přeložen do formátu ABI a bajtkódu. Pomocí funkce formatContractníže sestaví smlouvu pomocí solc-js.

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

Hotová smlouva 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 smlouva připravena, nasadíme síť a nasadíme smlouvu.

Nasazení uzlů

Nasazení uzlu může být poměrně pracné a tento proces lze nahradit použitím služby řetězový zásobník.

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

Nejprve vytvořte projekt a nazvěme ho Projekt kvora:

Pojďme vytvořit síť Kvora s konsensem Raft na Google Cloud Platform:

Přidejme další dva uzly k již vytvořenému uzlu:

Tři běžící uzly:

Stránka s podrobnostmi o uzlu zobrazuje koncový bod RPC, veřejný klíč atd.

Síť je nasazena. Nyní pojďme nasadit chytré smlouvy a provádět transakce pomocí web3.js.

Veřejné transakce

Kontext

Teplota ve skladu má velký význam pro snižování nákladů, zejména u produktů určených ke skladování při teplotách pod nulou.

Tím, že umožňuje společnostem sdílet venkovní teplotu jejich geografické polohy v reálném čase a zaznamenávat ji do neměnné účetní knihy, účastníci sítě snižují náklady a čas.

Provedeme tři úkoly, znázorněné na obrázku:

Smlouvu nasadíme přes Uzel 1:

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

Nastavte teplotu přes Uzel 2 o 3 stupně:

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

Uzel 3 obdrží informace z chytré smlouvy. Smlouva vrátí hodnotu 3 stupně:
```
const temp = await getTemperature(raft3Node, contractAddress);
console.log(‘Retrieved contract Temperature’, temp);
```
Dále se podíváme na to, jak provést veřejnou transakci v síti Quorum pomocí web3.js.

Iniciujeme instanci prostřednictvím 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,
 },
);

Pojďme nasadit chytrou smlouvu:

// 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 způsoby interakce se smlouvou: call и send.

Proveďme aktualizaci teploty kontraktu provedením set pomocí 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í smluvní teploty. Vezměte prosím na vědomí, že metoda call se provádí na lokálním uzlu a transakce nebude vytvořena na blockchainu.

// 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ůžete běžet public.js abyste získali následující výsledek:

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

Dále můžeme zobrazit položky v Průzkumníku Kvora na panelu Chainstack, jak je znázorněno níže.

Všechny tři uzly interagovaly a transakce byly aktualizovány:

První transakce nasadila smlouvu.
Druhá transakce nastavila smluvní teplotu na 3 stupně.
Teplota je přijímána přes místní uzel, takže se nevytváří žádná transakce.

Soukromé transakce

Kontext

Společným požadavkem organizací je ochrana dat. Jako příklad zvažte scénář, ve kterém Supermarket pronajímá skladové prostory pro skladování mořských plodů od samostatné Prodejce:

Prodejce pomocí IoT senzorů čte hodnoty teploty každých 30 sekund a přenáší je Do supermarketu;
tyto hodnoty by měly být k dispozici pouze K prodejci и Do supermarketu, propojené konsorciem.

Dokončíme čtyři úkoly znázorněné na obrázku výše.

K demonstraci soukromých transakcí používáme stejné tři uzly z předchozího scénáře:
Supermarket nasadí inteligentní smlouvu, která je soukromá Supermarket и Prodejce.
Třetí strana nemá právo na přístup ke smart kontraktu.

Zavoláme metody get и set jménem Supermarket и Prodejce k prokázání soukromé transakce Kvora.

Pro účastníky nasadíme soukromou smlouvu Supermarket и Prodejce prostřednictvím účastníka Supermarket:

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

Nastavíme teplotu od Třetí strana (externí uzel) a získejte 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 Prodejce (vnitřní uzel) a získejte hodnotu teploty:

Teplota v tomto scénáři by měla vrátit hodnotu 12 z chytré smlouvy Prodejce zde má autorizovaný přístup ke 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}`);

Teplotu získáme z Třetí strana (externí uzel):

V kroku 3 byla teplota nastavena na 12, ale Třetí strana nemá přístup ke smart kontraktu. Proto musí být vrácená hodnota null.
```
// This returns null
const temp3 = await getTemperature(raft3Node, contractAddress);
console.log(`[Node3] temp retrieved from external nodes after update ${temp}`);
```
Dále se blíže podíváme na provádění soukromých transakcí v síti Quorum s web3.js. Protože většina kódu je stejná pro veřejné transakce, zvýrazníme pouze ty části, které se liší pro soukromé transakce.

Všimněte si, že smlouva nahraná do sítě je neměnná, takže povolený přístup musí být udělen příslušným uzlům povolením veřejné smlouvy v době, kdy je smlouva nasazena, nikoli 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’, 
    // Grant Permission to Contract by including nodes public keys
    privateFor: [publicKey],
  })
  .then((contract) => {
    return contract.options.address;
  });
}

Soukromé transakce se provádějí obdobným způsobem – zahrnutím veřejného klíče úč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,
    // Grant Permission by including nodes public  keys
    privateFor: [publicKey],
  }).then((receipt) => {
    return receipt.status;
  });
}

Teď můžeme běžet private.js s následujícími výsledky:

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

Průzkumník Kvora v Chainstacku zobrazí následující:

nasazení smlouvy od účastníka Supermarket;
Provedení SetTemperature z Třetí strana;
Provedení SetTemperature od účastníka Prodejce.

Jak vidíte, obě transakce jsou dokončeny, ale pouze transakce od účastníka Prodejce aktualizoval teplotu ve smlouvě. Soukromé transakce tedy poskytují neměnnost, ale zároveň neprozradí data třetí straně.

Závěr

Podívali jsme se na případ komerčního použití pro Quorum, abychom mohli poskytovat aktuální informace o teplotě ve skladu nasazením sítě mezi dvě strany – supermarket a vlastník skladu.

Ukázali jsme, jak lze udržovat aktuální informace o teplotě prostřednictvím veřejných i soukromých transakcí.

Aplikačních scénářů může být spousta a jak vidíte, není to vůbec těžké.

Experimentujte, zkuste rozšířit svůj skript. Navíc blockchain technologický průmysl může do roku 2024 vzrůst téměř desetinásobně.

Zdroj: www.habr.com

Provádějte veřejné a soukromé transakce na blockchainu JPMorgan Quorum pomocí Web3

Kontext

Inteligentní smlouva

Nasazení uzlů

Veřejné transakce

Kontext

Soukromé transakce

Kontext

Závěr

Přidat komentář Zrušit odpověď na komentář