🥇Uitvoering van publieke en privé-transacties in de blockchain van JPMorgan Quorum met behulp van Web3

Quorum — een blockchain gebaseerd op Ethereum, ontwikkeld door JPMorgan en recentelijk de eerste gedistribueerde registerplatform die wordt aangeboden door Microsoft Azure.

Quorum ondersteunt zowel privé- als publieke transacties en heeft veel commerciële gebruiksscenario's.

In dit artikel zullen we een van die scenario's bespreken — het opzetten van een gedistribueerd registernetwerk tussen een supermarkt en een magazijnbeheerder om actuele informatie over de temperatuur van het magazijn te waarborgen.

De code die in deze handleiding wordt gebruikt, bevindt zich in repository op GitHub.

Het artikel behandelt:

het maken van een smart contract;
het opzetten van een Quorum-netwerk met behulp van Chainstack;
publieke transacties van Quorum;
privétransacties van Quorum.

Voor de illustratie wordt een scenario gebruikt voor temperatuurmonitoring in de magazijnen van de deelnemers aan het Quorum-netwerk in het kader van het Internet of Things (IoT).

Context

Een groep opslagbedrijven komt samen in een consortium om informatie gezamenlijk op te slaan en processen te automatiseren op de blockchain. Ze hebben besloten om Quorum te gebruiken. In dit artikel behandelen we twee scenario's: publieke transacties en private transacties.

Transacties worden gecreëerd door verschillende deelnemers voor interactie met het consortium waartoe ze behoren. Elke transactie implementeert een contract of roept een functie in het contract aan om gegevens in het netwerk te laden. Deze acties worden gerepliceerd naar alle knooppunten in het netwerk.

Publieke transacties zijn zichtbaar voor alle deelnemers van het consortium. Privétransacties voegen een laag van vertrouwelijkheid toe en zijn alleen toegankelijk voor die deelnemers die daar toestemming voor hebben.

Voor beide scenario's gebruiken we ter illustratie hetzelfde contract.

Slim contract

Hieronder staat een eenvoudig smart contract dat is gemaakt voor ons scenario. Het bevat een openbare variabele temperature, die kan worden gewijzigd met de methode set en kan worden opgehaald met de methode krijgen.

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

Om het contract met web3.jste laten werken, moet het worden omgezet naar het ABI-formaat en bytecode. Het gebruik van de functie formatContract, zoals hieronder weergegeven, compileert het contract met behulp van solc-js.

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

Een kant-en-klaar contract ziet er als volgt uit:

// 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 het contract klaar is, zullen we het netwerk opzetten en het contract implementeren.

Implementatie van nodes

Het inzetten van een node kan behoorlijk arbeidsintensief zijn en dit proces kan worden vereenvoudigd door gebruik te maken van de service Chainstack.

Hieronder staat het proces voor het opzetten van een Quorum-netwerk met Raft-consensus en drie nodes.

Laten we beginnen met het opzetten van een project en dit Quorum Project noemen:

We creëren een Quorum-netwerk met Raft-consensus op Google Cloud Platform:

Aan de al standaard aangemaakte node voegen we nog twee nodes toe:

Drie actieve nodes:

De detailpagina van de node toont de RPC-endpoint, publieke sleutel, enz.

Het netwerk is opgezet. Laten we nu doorgaan met het implementeren van smart contracts en het uitvoeren van transacties met behulp van web3.js.

Publieke transacties

Context

De temperatuur van de opslagruimte is van groot belang voor het verlagen van kosten, vooral voor producten die bij koude temperaturen moeten worden opgeslagen.

Door bedrijven in staat te stellen real-time de externe temperatuur van hun geografische locatie te delen en deze in een onveranderlijk register vast te leggen, verlagen de netwerkdeelnemers de kosten en de tijd.

We zullen drie taken uitvoeren, zoals geïllustreerd in het diagram:

We implementeren het contract via Node 1:

const contractAddress = await deployContract(raft1Node);
console.log(`Contractadres na implementatie: ${contractAddress}`);

We stellen de temperatuur in via Node 2 op 3 graden:

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

Node 3 zal informatie uit het smart contract verkrijgen. Het contract retourneert de waarde van 3 graden:
```
const temp = await getTemperature(raft3Node, contractAddress);
console.log('Verkregen contracttemperatuur', temp);
```
Laten we nu kijken naar het uitvoeren van een publieke transactie in het Quorum-netwerk met behulp van web3.js.

We initialiseren een instantie via RPC voor drie nodes:

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

We implementeren het smart contract:

// 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 biedt twee methoden voor interactie met het contract: call en send.

We werken de temperatuur van het contract bij door set gebruikmakend van de web3-methode 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;
  });
}

Vervolgens gebruiken we de web3-methode call om de temperatuur van het contract te verkrijgen. Let op, de methode call wordt uitgevoerd op de lokale node en er zal geen transactie op de blockchain worden aangemaakt.

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

We kunnen nu public.js Starten om het volgende resultaat te verkrijgen:

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

Daarna kunnen we de records in de Quorum-explorer bekijken in het Chainstack-dashboard, zoals hieronder weergegeven.

Alle drie de knooppunten hebben samengewerkt en de transacties zijn bijgewerkt:

De eerste transactie heeft het contract gedeployed.
De tweede transactie heeft de temperatuur van het contract ingesteld op 3 graden.
Het verkrijgen van de temperatuur verloopt via het lokale knooppunt, waardoor er geen transactie is aangemaakt.

Privétransacties

Context

Een veelvoorkomende vereiste van organisaties is dat gegevens beschermd worden. Neem als voorbeeld een scenario waarin een supermarkt een magazijn huurt voor het opslaan van zeevruchten bij een afzonderlijke leverancier:

Leverancier de temperatuurwaarden elke 30 seconden leest met behulp van IoT-sensoren en deze doorgeeft aan de supermarkt;
deze waarden alleen toegankelijk moeten zijn voor de leverancier en supermarkt, verenigd in een consortium netwerk.We zullen vier taken uitvoeren, die worden geïllustreerd in het diagram hierboven.

We gebruiken dezelfde drie knooppunten uit het eerdere scenario om privétransacties te demonstreren:

De supermarkt
deployed een smart contract dat privé is voor de supermarkt. Een derde partij en leverancier.
heeft geen toegang tot het smart contract. We zullen de methoden aanroepen

namens krijgen en set om een privétransactie in Quorum te demonstreren. Een derde partij en leverancier We deployen een privécontract voor de deelnemers

via de deelnemer deployed een smart contract dat privé is voor en Leverancier const contractAddress = await deployContract( raft1Node, process.env.PK2, ); console.log(`Contractadres na uitrol: ${contractAddress}`); deployed een smart contract dat privé is voor:
```
We stellen de temperatuur in van
```

derde partij (externe knooppunt) en verkrijgen de temperatuurwaarde: (interne knooppunt) en verkrijgen de temperatuurwaarde:

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

derde partij leverancier De temperatuur in dit scenario zou uit het smart contract de waarde 12 moeten retourneren. Let op dat

hier toestemming heeft om toegang te krijgen tot het smart contract. Leverancier Laten we de temperatuur verkrijgen van

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

(externe knooppunt): (externe knooppunt) en verkrijgen de temperatuurwaarde: In stap 3 was de temperatuur ingesteld op 12, maar
heeft geen toegang tot het smart contract. Daarom zou de geretourneerde waarde null moeten zijn. heeft geen toegang tot het smart contract. Vervolgens zullen we dieper ingaan op het uitvoeren van privétransacties binnen het Quorum-netwerk met
```
// This returns null
const temp3 = await getTemperature(raft3Node, contractAddress);
console.log(`[Node3] temp retrieved from external nodes after update ${temp}`);
```
. Aangezien het merendeel van de code overeenkomt met openbare transacties, zullen we alleen die delen benadrukken die verschillen voor privétransacties. web3.jsAangezien het grootste deel van de code overeenkomt met openbare transacties, zullen we alleen de delen benadrukken die verschillen voor privétransacties.

Houd er rekening mee dat het contract dat op het netwerk is geüpload wijzigen is onmogelijk, daarom moet toegang met toestemming (permissioned) aan de juiste knooppunten worden verleend door het publieke contract in te schakelen op het moment van de implementatie van het contract, en niet erna.

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', 
    // Verleen toestemming aan contract door publieke sleutels van knooppunten op te nemen
    privateFor: [publicKey],
  })
  .then((contract) => {
    return contract.options.address;
  });
}

Op dezelfde manier worden privé-transacties uitgevoerd — door de publieke sleutel van de deelnemers op het moment van uitvoering op te nemen.

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,
    // Verleen toestemming door publieke sleutels van knooppunten op te nemen
    privateFor: [publicKey],
  }).then((receipt) => {
    return receipt.status;
  });
}

Nu kunnen we starten private.js met de volgende resultaten:

node private.js
Contractadres na implementatie: 0x85dBF88B4dfa47e73608b33454E4e3BA2812B21D
[Node3] temperatuur opgehaald na het bijwerken van het contract vanuit externe knooppunten: null
[Node2] temperatuur opgehaald na het bijwerken van het contract vanuit interne knooppunten: 12
[Node3] temperatuur opgehaald vanuit externe knooppunten na update: null

Quorum Explorer in Chainstack toont het volgende:

implementatie van contract door deelnemer deployed een smart contract dat privé is voor;
Uitvoering SetTemperature van (externe knooppunt) en verkrijgen de temperatuurwaarde:;
Uitvoering SetTemperature door deelnemer Leverancier.

Zoals je ziet, zijn beide transacties uitgevoerd, maar alleen de transactie van de deelnemer Leverancier heeft de temperatuur in het contract bijgewerkt. Zo zorgen privé-transacties voor onwankelbaarheid, maar geven ze geen gegevens aan derden.

Conclusie

We hebben het commerciële toepassingsscenario van Quorum bekeken voor het verstrekken van actuele informatie over de temperatuur in een magazijn door een netwerk tussen twee partijen te implementeren — een supermarkt en de magazijnhouder.

We hebben laten zien hoe actuele temperatuurinformatie kan worden behouden via zowel publieke als privé-transacties.

Er zijn talloze toepassingsscenario's mogelijk en, zoals je ziet, is het helemaal niet moeilijk.

Experimenteer, probeer je eigen scenario te implementeren. Zeker omdat de blockchain-technologie-industrie tegen 2024 bijna tien keer kan groeien.

Bron: habr.com

Het uitvoeren van publieke en private transacties op de JPMorgan Quorum blockchain met Web3

Context

Slim contract

Implementatie van nodes

Publieke transacties

Context

Privétransacties

Context

Conclusie