🥇Izvajanje javnih in zasebnih transakcij v blockchainu JPMorgan Quorum z uporabo Web3

Quorum — blockchain based on Ethereum, developed by JPMorgan and recently becoming the first distributed ledger platform offered by Microsoft Azure.

Quorum supports private and public transactions and has many commercial use cases.

In this article, we will examine one such scenario — deploying a distributed ledger network between a supermarket and a warehouse owner to ensure up-to-date information about the temperature of the storage space.

The code used in this guide can be found in shrambi na GitHubu.

The article covers:

creating a smart contract;
deploying a Quorum network using Chainstack;
public Quorum transactions;
private Quorum transactions.

The scenario illustrates temperature monitoring in the storage spaces of Quorum network participants within the Internet of Things (IoT).

Kontekst

A group of warehouse companies joins a consortium to collaboratively store information and automate processes on the blockchain. To achieve this, the companies chose to use Quorum. In this article, we will cover two scenarios: public transactions and private transactions.

Transactions are created by different participants to interact with the consortium they belong to. Each transaction either deploys a contract or calls a function in the contract to upload data to the network. These actions are replicated across all nodes in the network.

Public transactions are available for viewing by all consortium participants. Private transactions add a layer of confidentiality and are only accessible to those participants who have the necessary permissions.

For both scenarios, we use the same contract for clarity.

smart-contract

Below is a simple smart contract created for our scenario. It has a public variable temperature, which can be modified by the method set and accessed by the method pridobi.

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 the contract to work with web3.js, it needs to be converted to ABI and bytecode format. Using the function formatContract, shown below, compiles the contract using solc-js.

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

The final contract looks like this:

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

Zdaj, ko je pogodba pripravljena, bomo razporedili omrežje in namestili pogodbo.

Razvijanje vozlišč

Namestitev vozlišča je lahko precej zamudna in ta postopek lahko nadomestimo z uporabo storitve. Chainstack.

Spodaj je prikazan postopek namestitve omrežja Quorum s konsenzom Raft in tremi vozlišči.

Najprej bomo ustvarili projekt in ga poimenovali Quorum Project:

Ustvarili bomo omrežje Quorum s konsenzom Raft na Google Cloud Platform:

Obstoječemu privzetemu vozlišču dodajmo še dve vozli.

Tri zagnana vozlišča:

Stran podrobnosti vozlišča prikazuje RPC endpoint, javni ključ itd.

Omrežje je razporejeno. Zdaj se bomo ukvarjali z nameščanjem pametnih pogodb in izvajanjem transakcij s pomočjo web3.js.

Javne transakcije

Kontekst

Temperatura skladiščnega prostora ima velik pomen za znižanje stroškov, še posebej za izdelke, ki jih je treba shranjevati pri negativnih temperaturah.

S tem, da podjetjem omogočimo deljenje vrednosti zunanje temperature njihove geografske lokacije v realnem času in zapisovanje v nespremenljiv register, člani omrežja zmanjšujejo stroške in čas.

Izvedli bomo tri naloge, prikazane na diagramu:

Namestili bomo pogodbo preko Node 1:

const contractAddress = await deployContract(raft1Node);
console.log(`Naslov pogodbe po namestitvi: ${contractAddress}`);

Nastavili bomo temperaturo preko Node 2 na 3 stopinje:

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

Node 3 bo pridobil informacije iz pametne pogodbe. Pogodba bo vrnila vrednost 3 stopinje:
```
const temp = await getTemperature(raft3Node, contractAddress);
console.log(‘Pridobljena temperatura pogodbe’, temp);
```
Nato bomo preučili, kako izvesti javno transakcijo v omrežju Quorum z uporabo web3.js.

Inicializiramo instanco preko RPC za tri vozlišča:

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

Namestimo pametno pogodbo:

// 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 ponuja dve metodi za interakcijo s pogodbo: call in send.

Posodobimo temperaturo pogodbe z izvajanjem set z uporabo metode 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;
  });
}

Nato uporabimo metodo web3 call za pridobitev temperature pogodbe. Upoštevajte, da se metoda call izvaja na lokalnem vozlišču in transakcija na blockchainu ne bo ustvarjena.

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

Zdaj lahko zagnamo public.js za pridobitev naslednjega rezultata:

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

Nato lahko v Quorum Explorerju v nadzorni plošči Chainstack pogledamo zapise, kot je prikazano spodaj.

Vse tri vozlišča so medsebojno delovala in transakcije so bile posodobljene:

Prva transakcija je implementirala pogodbo.
Druga transakcija je nastavila temperaturo pogodbe na 3 stopinje.
Pridobitev temperature se izvede preko lokalnega vozlišča, zato transakcija ni bila ustvarjena.

Zasebne transakcije

Kontekst

Pogosta zahteva organizacij je zaščita podatkov. Kot primer razmislimo o scenariju, v katerem supermarket najemajo skladiščni prostor za shranjevanje morskih sadežev pri posebnem dobavitelju:

Dobavitelj s pomočjo IoT senzorjev beležijo temperaturne vrednosti vsakih 30 sekund in jih posredujejo supermarketu.;
Te vrednosti morajo biti dostopne samo dobavitelju. in Supermarketu, združenemu v konzorcij.

Izvedli bomo štiri naloge, ki so ilustrirane na zgornjem diagramu.

Uporabimo ista tri vozlišča iz prejšnjega scenarija za demonstracijo zasebnih transakcij:
Supermarket implementira pametno pogodbo, ki je privatna za supermarket. in dobavitelju.
Tretja stran nima pravice do dostopa do pametne pogodbe.

Poklicali bomo metode pridobi in set v imenu supermarket. in dobavitelju za demonstracijo zasebne transakcije Quorum.

Implementirali bomo zasebno pogodbo za udeležence Supermarket in Dobavitelj preko udeleženca Supermarket:

const contractAddress = await deployContract(
raft1Node,
process.env.PK2,
);
console.log(`Naslov pogodbe po implementaciji: ${contractAddress}`);

Nastavimo temperaturo od Tretje strani (zunanje vozlišče) in dobimo temperaturno vrednost:

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

Nastavimo temperaturo od dobavitelju (notranje vozlišče) in dobimo temperaturno vrednost:

Temperatura v tem scenariju bi morala vrniti iz pametne pogodbe vrednost 12. Upoštevajte, da Dobavitelj tu ima dovoljen dostop do pametne pogodbe.

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

Pridobimo temperaturo od Tretje strani (zunanje vozlišče):
Na 3. koraku je bila temperatura nastavljena na 12, vendar Tretja stran nima dostopa do pametne pogodbe. Zato bi morala vrniti vrednost null.
```
// This returns null
const temp3 = await getTemperature(raft3Node, contractAddress);
console.log(`[Node3] temp retrieved from external nodes after update ${temp}`);
```
Nato bomo podrobneje preučili izvajanje zasebnih transakcij v mreži Quorum z web3.js. Ker se večina kode ujema s javnimi transakcijami, bomo izpostavili le tiste dele, ki se razlikujejo za zasebne transakcije.

Upoštevajte, da je pogodba, naložena v omrežje, nespremenljiva, zato morajo biti dostopi z dovoljenjem (permissioned) dodeljeni ustreznim vozliščem z vključitvijo javne pogodbe ob trenutku namestitve pogodbe, in ne pozneje.

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', 
    // Dodelite dovoljenje pogodbi z vključitvijo javnih ključev vozlišč
    privateFor: [publicKey],
  })
  .then((contract) => {
    return contract.options.address;
  });
}

Na podoben način se izvajajo zasebne transakcije — z vključitvijo javnega ključa udeležencev ob izvajanju.

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,
    // Dodelite dovoljenje z vključitvijo javnih ključev vozlišč
    privateFor: [publicKey],
  }).then((receipt) => {
    return receipt.status;
  });
}

Zdaj lahko začnemo private.js z naslednjimi rezultati:

node private.js
Naslov pogodbe po namestitvi: 0x85dBF88B4dfa47e73608b33454E4e3BA2812B21D
[Node3] temperatura pridobljena po posodobitvi pogodbe z zunanjih vozlišč: null
[Node2] temperatura pridobljena po posodobitvi pogodbe z notranjih vozlišč: 12
[Node3] temperatura pridobljena z zunanjih vozlišč po posodobitvi: null

Quorum explorer v Chainstack bo prikazal naslednje:

namestitev pogodbe s strani udeleženca Supermarket;
Izvrševanje SetTemperature od Tretje strani;
Izvrševanje SetTemperature s strani udeleženca Dobavitelj.

Kot vidite, sta bili obe transakciji izvedeni, vendar je le transakcija s strani udeleženca Dobavitelj posodobila temperaturo v pogodbi. Tako zasebne transakcije zagotavljajo nespremenljivost, a ne razkrivajo podatkov tretji strani.

Zaključek

Obravnvali smo poslovni scenarij uporabe Quorum za zagotavljanje aktualnih informacij o temperaturi v skladišču z razporeditvijo omrežja med dvema stranema — supermarketom in lastnikom skladišča.

Pokazali smo, kako lahko aktualne informacije o temperaturi ohranjamo tako s prek javnih kot tudi s prek zasebnih transakcij.

Možnosti uporabe je lahko zelo veliko in, kot vidite, to ni nikakor zapleteno.

Eksperimentirajte, poskusite z razporeditvijo svojega scenarija. Še posebej, ker se lahko industrija blockchain tehnologij do leta 2024 skoraj desetkrat poveča.

Izvor: habr.com