🥇Udførelse af offentlige og private transaktioner i blockchain JPMorgan Quorum ved hjælp af Web3

Quorum — en blockchain baseret på Ethereum, udviklet af JPMorgan, og for nylig blevet den første distribuerede registerplatform, som Microsoft Azure tilbyder.

Quorum understøtter private og offentlige transaktioner og har mange kommercielle anvendelsesscenarier.

I denne artikel vil vi gennemgå et af sådanne scenarier — implementeringen af et distribueret registernetværk mellem et supermarked og en lager ejer for at sikre opdaterede oplysninger om temperaturerne i lagerlokaler.

Koden, der bruges i denne vejledning, findes i repository på GitHub.

Artiklen dækker:

oprettelse af en smart kontrakt;
implementering af Quorum-netværket ved hjælp af Chainstack;
offentlige transaktioner i Quorum;
private transaktioner i Quorum.

Til illustration bruges et scenarie til overvågning af temperaturer i lagerlokalerne for deltagerne i Quorum-netværket inden for Internet of Things (IoT).

Kontext

En gruppe lagerfirmaer slår sig sammen i et konsortium for at dele information og automatisere processerne på blockchain. For dette formål besluttede virksomhederne at bruge Quorum. I denne artikel vil vi dække to scenarier: offentlige transaktioner og private transaktioner.

Transaktioner oprettes af forskellige deltagere for at interagere med konsortiet, de tilhører. Hver transaktion deployerer enten en kontrakt eller kalder en funktion i kontrakten for at indlæse data i netværket. Disse handlinger replikeres på alle noder i netværket.

Offentlige transaktioner er tilgængelige for alle deltagere i konsortiet. Private transaktioner tilføjer et lag af fortrolighed og er kun tilgængelige for de deltagere, der har tilladelse til det.

For begge scenarier bruger vi af illustrativ hensyn den samme kontrakt.

Smartkontrakt

Nedenfor er en simpel smart kontrakt, der er oprettet til vores scenarie. Den har en offentlig variabel temperature, som kan ændres med metoden set og hentes med metoden 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;
  }
}

For at kontrakten kan fungere med web3.js, skal den konverteres til ABI-format og bytekode. Brug af funktionen formatContract, der er angivet nedenfor, kompilerer kontrakten ved hjælp af solc-js.

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

Den færdige kontrakt ser således ud:

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

Nu hvor kontrakten er klar, vil vi implementere netværket og deploye kontrakten.

Udrulning af noder

Implementeringen af en node kan være ret tidskrævende, og denne proces kan erstattes med brugen af en tjeneste. Chainstack.

Nedenfor er processen for implementering af Quorum-netværket med Raft-konsensus og tre noder.

Lad os først oprette et projekt og kalde det Quorum Project:

Lad os oprette et Quorum-netværk med Raft-konsensus på Google Cloud Platform:

Til den allerede oprettede node tilføjer vi yderligere to noder:

Tre kørende noder:

Node-detaljesiden viser RPC-endepunktet, den offentlige nøgle osv.

Netværket er implementeret. Nu skal vi håndtere deployment af smart contracts og udføre transaktioner ved hjælp af web3.js.

Offentlige transaktioner

Kontext

Temperaturen i lagerlokalet er afgørende for at reducere omkostningerne, især for produkter, der skal opbevares ved minusgrader.

Ved at give virksomheder mulighed for at dele værdierne af den eksterne temperatur i realtid fra deres geografiske placering og registrere dem i et uforanderligt register, reducerer deltagerne i netværket omkostninger og tid.

Vi vil udføre tre opgaver, der er illustreret i diagrammet:

Vi deployer kontrakten gennem Node 1:

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

Vi vil sætte temperaturen gennem Node 2 med 3 grader:

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

Node 3 vil hente oplysninger fra smart contracten. Kontrakten vil returnere værdien 3 grader:
```
const temp = await getTemperature(raft3Node, contractAddress);
console.log('Retrieved contract Temperature', temp);
```
Lad os nu se på, hvordan man udfører en offentlig transaktion i Quorum-netværket ved hjælp af web3.js.

Vi initierer en instans via RPC for de tre noder:

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

Vi deployer smart contracten:

// 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 giver to metoder til at interagere med kontrakten: call og send.

Vi opdaterer kontraktens temperatur ved at udføre set ved hjælp af web3-metoden 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;
  });
}

Lad os derefter bruge web3-metoden call til at hente kontraktens temperatur. Bemærk, at metoden call udføres på en lokal node, og transaktionen vil ikke blive oprettet på blockchain.

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

Nu kan vi køre public.js for at få det næste resultat:

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

Here we can look at the records in the Quorum explorer in the Chainstack panel, as shown below.

All three nodes interacted, and the transactions were updated:

The first transaction deployed the contract.
The second transaction set the contract temperature to 3 degrees.
Temperature retrieval occurs through the local node, so no transaction is created.

Private transactions

Kontext

A common requirement for organizations is data protection. For example, let's consider a scenario where The supermarket rents a storage facility for storing seafood from a separate Vendor:

Leverandør uses IoT sensors to read temperature values every 30 seconds and transmits them to the Supermarket;
these values should only be accessible to the Vendor og Supermarket, combined into a consortium network.

We will perform four tasks illustrated in the diagram above.

We will use the same three nodes from the previous scenario to demonstrate private transactions:
The supermarket deploys a smart contract that is private to the Supermarket og Vendor.
The third party does not have access to the smart contract.

We will call the methods get og set on behalf of the Supermarket og Vendor to demonstrate a private Quorum transaction.

We will deploy a private contract for participants The supermarket og Leverandør through the participant The supermarket:

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

We will set the temperature from the third party (external node) and get the temperature value:

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

We will set the temperature from Vendor (internal node) and get the temperature value:

The temperature in this scenario should return the value 12 from the smart contract. Note that Leverandør has authorized access to the smart contract here.

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

We will get the temperature from the third party (external node):
In step 3, the temperature was set to 12, but The third party does not have access to the smart contract. Therefore, the return value should be null.
```
// This returns null
const temp3 = await getTemperature(raft3Node, contractAddress);
console.log(`[Node3] temp retrieved from external nodes after update ${temp}`);
```
Next, we will take a closer look at executing private transactions in the Quorum network with web3.js. Since most of the code matches public transactions, we will highlight only the parts that differ for private transactions.

Bemærk, at kontrakten, der er uploadet til netværket, er uforanderlig, så adgang med tilladelse (permissioned) skal gives til de relevante noder ved at inkludere den offentlige kontrakt på tidspunktet for kontraktdistributionen, og ikke efterfølgende.

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', 
    // Giv tilladelse til kontrakten ved at inkludere noderne offentlige nøgler
    privateFor: [publicKey],
  })
  .then((contract) => {
    return contract.options.address;
  });
}

På samme måde udføres private transaktioner — ved at inkludere deltagernes offentlige nøgle på tidspunktet for udførelsen.

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,
    // Giv tilladelse ved at inkludere noderne offentlige nøgler
    privateFor: [publicKey],
  }).then((receipt) => {
    return receipt.status;
  });
}

Nu kan vi starte private.js med følgende resultater:

node private.js
Kontraktadresse efter distribution: 0x85dBF88B4dfa47e73608b33454E4e3BA2812B21D
[Node3] temperatur hentet efter opdatering af kontrakt fra eksterne noder: null
[Node2] temperatur hentet efter opdatering af kontrakt fra interne noder: 12
[Node3] temperatur hentet fra eksterne noder efter opdatering: null

Quorum Exploreren i Chainstack vil vise følgende:

udrulning af kontrakt fra deltageren The supermarket;
Udførelse SetTemperature fra the third party;
Udførelse SetTemperature fra deltageren Leverandør.

Som du kan se, blev begge transaktioner udført, men kun transaktionen fra deltageren Leverandør opdaterede temperaturen i kontrakten. Således sikrer private transaktioner uforanderlighed, men afslører ikke data til tredjepart.

Konklusion

Vi har gennemgået et kommercielt anvendelsesscenarie for Quorum til at sikre aktuel information om temperaturen i lagerlokalet ved at implementere et netværk mellem to parter — supermarkedet og lagerets ejer.

Vi har vist, hvordan aktuel information om temperaturen kan vedligeholdes både gennem offentlige og private transaktioner.

Der kan være mange anvendelsesscenarier, og som du kan se, er det slet ikke svært.

Eksperimentér, prøv at udrulle dit scenarie. Desuden kan blockchain-teknologibranchen vokse næsten ti gange inden 2024.

Kilde: habr.com

Udøvelse af offentlige og private transaktioner i blockchainen JPMorgan Quorum ved hjælp af Web3

Kontext

Smartkontrakt

Udrulning af noder

Offentlige transaktioner

Kontext

Private transactions

Kontext

Konklusion