🥇Utføre offentlige og private transaksjoner på JPMorgan Quorum blockchain ved hjelp av Web3

quorum er en Ethereum-basert blokkjede utviklet av JPMorgan og ble sist den første distribuerte hovedbokplattformen som tilbys av Microsoft Azure.

Quorum støtter private og offentlige transaksjoner og har mange kommersielle brukssaker.

I denne artikkelen vil vi undersøke et slikt scenario - utplasseringen av et distribuert hovedboknettverk mellom et supermarked og en lagereier for å gi oppdatert informasjon om temperaturen på lageret.

Koden som brukes i denne opplæringen er i repositories på GitHub.

Artikkelen dekker:

opprettelse av en smart kontrakt;
distribusjon av Quorum-nettverket ved hjelp av Kjedestak;
Quorum offentlige transaksjoner;
Quorum private transaksjoner.

For å illustrere bruker vi et scenario for å overvåke temperaturen i varehusene til medlemmer av Quorum-nettverket innenfor tingenes internett (IoT).

Kontekst

En gruppe lagerbedrifter går sammen i et konsortium for i fellesskap å lagre informasjon og automatisere prosesser på blokkjeden. For dette bestemte bedrifter seg for å bruke Quorum. I denne artikkelen vil vi dekke to scenarier: offentlige transaksjoner og private transaksjoner.

Transaksjoner opprettes av forskjellige deltakere for å samhandle med konsortiet de tilhører. Hver transaksjon distribuerer enten en kontrakt eller kaller en funksjon i kontrakten for å laste opp data til nettverket. Disse handlingene replikeres til alle noder på nettverket.

Offentlige transaksjoner er tilgjengelige for visning av alle konsortiumdeltakere. Private transaksjoner legger til et lag med konfidensialitet og er kun tilgjengelig for de deltakerne som har rettigheter til å gjøre det.

For begge scenariene bruker vi samme kontrakt for klarhet.

Smart kontrakt

Nedenfor er en enkel smart kontrakt laget for vårt scenario. Den har en offentlig variabel temperature, som kan endres ved hjelp av set og motta etter metode 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 skal fungere med web3.js, må den oversettes til ABI-format og bytekode. Bruker funksjonen formatContractnedenfor sammenstiller kontrakten ved hjelp av solc-js.

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

Den ferdige kontrakten ser slik ut:

// 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å som kontrakten er klar, vil vi distribuere nettverket og distribuere kontrakten.

Nodedistribusjon

Å distribuere en node kan være ganske arbeidskrevende, og denne prosessen kan erstattes ved å bruke en tjeneste Kjedestak.

Nedenfor er prosessen for å distribuere Quorum-nettverket med Raft-konsensus og tre noder.

Først, la oss lage et prosjekt og kalle det Quorum Project:

La oss lage et Quorum-nettverk med Raft-konsensus på Google Cloud Platform:

La oss legge til ytterligere to noder til noden som allerede er opprettet som standard:

Tre løpende noder:

Nodedetaljsiden viser RPC-endepunktet, den offentlige nøkkelen osv.

Nettverket er utplassert. La oss nå distribuere smarte kontrakter og utføre transaksjoner ved hjelp av web3.js.

Offentlige transaksjoner

Kontekst

Lagertemperatur er av stor betydning for å redusere kostnadene, spesielt for produkter som skal lagres ved minusgrader.

Ved å la bedrifter dele utetemperaturen på sin geografiske plassering i sanntid og registrere den i en uforanderlig hovedbok, reduserer nettverksdeltakerne kostnader og tid.

Vi skal utføre tre oppgaver, illustrert i diagrammet:

Vi vil distribuere kontrakten via Node 1:

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

Still inn temperaturen via Node 2 med 3 grader:

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

Node 3 vil motta informasjon fra smartkontrakten. Kontrakten vil returnere verdien 3 grader:
```
const temp = await getTemperature(raft3Node, contractAddress);
console.log(‘Retrieved contract Temperature’, temp);
```
Deretter skal vi se på hvordan du utfører en offentlig transaksjon på Quorum-nettverket ved hjelp av web3.js.

Vi starter en forekomst via RPC for 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,
 },
);

La oss implementere den smarte kontrakten:

// 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 gir to metoder for å samhandle med kontrakten: call и send.

La oss oppdatere kontraktstemperaturen ved å utføre set ved hjelp av 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;
  });
}

Deretter bruker vi web3-metoden call for å oppnå kontraktstemperaturen. Vær oppmerksom på at metoden call utføres på en lokal node og transaksjonen vil ikke bli opprettet på blokkjeden.

// 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å kan du løpe public.js for å få følgende resultat:

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

Deretter kan vi se oppføringene i Quorum Explorer i Chainstack-panelet, som vist nedenfor.

Alle tre nodene samhandlet og transaksjonene ble oppdatert:

Den første transaksjonen implementerte kontrakten.
Den andre transaksjonen satte kontraktstemperaturen til 3 grader.
Temperaturen mottas gjennom en lokal node, så ingen transaksjon opprettes.

Private transaksjoner

Kontekst

Et vanlig krav til organisasjoner er databeskyttelse. Som et eksempel, vurder et scenario der Supermarked leier en lagerplass for oppbevaring av sjømat fra en separat Leverandør:

Leverandør bruker IoT-sensorer, leser temperaturverdier hvert 30. sekund og sender dem Til supermarkedet;
disse verdiene skal bare være tilgjengelige Til selgeren и Til supermarkedet, nettverk av et konsortium.

Vi vil fullføre de fire oppgavene som er illustrert i diagrammet ovenfor.

Vi bruker de samme tre nodene fra forrige scenario for å demonstrere private transaksjoner:
Supermarked distribuerer en smart kontrakt som er privat til Supermarked и Leverandør.
Den tredje siden har ikke rett til tilgang til smartkontrakten.

Vi vil kalle metodene get и set på vegne av Supermarked и Leverandør for å demonstrere en privat quorumstransaksjon.

Vi vil distribuere en privat kontrakt for deltakerne Supermarked и Leverandør gjennom en deltaker Supermarked:

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

La oss sette temperaturen fra Tredjepart (ekstern node) og få temperaturverdien:

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

La oss sette temperaturen fra Leverandør (intern node) og få temperaturverdien:

Temperaturen i dette scenariet skal returnere verdien 12 fra smartkontrakten. Vær oppmerksom på det Leverandør her har autorisert tilgang til smartkontrakten.

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

Vi får temperaturen fra Tredjepart (ekstern node):

I trinn 3 ble temperaturen satt til 12, men Den tredje siden har ikke tilgang til smartkontrakten. Derfor må returverdien være null.
```
// This returns null
const temp3 = await getTemperature(raft3Node, contractAddress);
console.log(`[Node3] temp retrieved from external nodes after update ${temp}`);
```
Deretter skal vi se nærmere på å utføre private transaksjoner på Quorum-nettverket med web3.js. Siden det meste av koden er lik for offentlige transaksjoner, vil vi bare fremheve de delene som er forskjellige for private transaksjoner.

Merk at kontrakten som lastes opp til nettverket er uforanderlig, så tillatelse må gis til de aktuelle nodene ved å aktivere den offentlige kontrakten på tidspunktet kontrakten distribueres, ikke etter.

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

Private transaksjoner utføres på lignende måte - ved å inkludere den offentlige nøkkelen til deltakerne på tidspunktet for utførelse.

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å kan vi løpe private.js med følgende resultater:

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

Quorum Explorer i Chainstack vil vise følgende:

utplassering av kontrakten fra deltakeren Supermarked;
utførelse SetTemperature fra Tredjepart;
utførelse SetTemperature fra en deltaker Leverandør.

Som du kan se er begge transaksjonene fullført, men bare transaksjonen fra deltakeren Leverandør oppdatert temperaturen i kontrakten. Dermed gir private transaksjoner uforanderlighet, men avslører samtidig ikke data til en tredjepart.

Konklusjon

Vi så på en kommersiell brukssak for Quorum for å gi oppdatert temperaturinformasjon i et lager ved å distribuere et nettverk mellom to parter - et supermarked og en lagereier.

Vi viste hvordan oppdatert temperaturinformasjon kan opprettholdes gjennom både offentlige og private transaksjoner.

Det kan være mange applikasjonsscenarier, og som du kan se er det slett ikke vanskelig.

Eksperimenter, prøv å utvide skriptet ditt. Dessuten blockchain-teknologiindustrien kan vokse nesten tidoblet innen 2024.

Kilde: www.habr.com

Utfør offentlige og private transaksjoner på JPMorgan Quorum blockchain ved å bruke Web3

Kontekst

Smart kontrakt

Nodedistribusjon

Offentlige transaksjoner

Kontekst

Private transaksjoner

Kontekst

Konklusjon

Legg til en kommentar Avbryt svar