🥇Transakzio publiko eta pribatuak egitea JPMorgan Quorum blockchain-en Web3 erabiliz

quorum JPMorgan-ek garatutako Ethereum-en oinarritutako blockchain bat da eta azkenaldian Microsoft Azure-k eskaintzen duen liburu-liburu banatuko lehen plataforma bihurtu da.

Quorum-ek transakzio pribatu eta publikoak onartzen ditu eta erabilera komertzial ugari ditu.

Artikulu honetan, halako agertoki bat aztertuko dugu: supermerkatu baten eta biltegiaren jabe baten artean banatutako liburu-sare bat zabaltzea biltegiaren tenperaturari buruzko informazio eguneratua emateko.

Tutorial honetan erabilitako kodea hemen dago biltegiak GitHub-en.

Artikuluak honako hau hartzen du:

kontratu adimenduna sortzea;
Quorum sarearen hedapena erabiliz Chainstack;
Quorum transakzio publikoak;
Quorum transakzio pribatuak.

Irudikatzeko, Gauzen Interneten (IoT) Quorum sareko kideen biltegietan tenperatura kontrolatzeko eszenatoki bat erabiltzen dugu.

Testuingurua

Biltegiko enpresa talde bat partzuergo batean bat egiten ari da informazioa elkarrekin gordetzeko eta bloke-katean prozesuak automatizatzeko. Horretarako, enpresek Quorum erabiltzea erabaki zuten. Artikulu honetan bi eszenatoki aztertuko ditugu: transakzio publikoak eta transakzio pribatuak.

Parte-hartzaile ezberdinek sortzen dituzte transakzioak, parte hartzen duten partzuergoarekin elkarreragiteko. Transakzio bakoitzak kontratu bat zabaltzen du edo kontratuko funtzio bat deitzen du datuak sarera kargatzeko. Ekintza hauek sareko nodo guztietan errepikatzen dira.

Transakzio publikoak partzuergoko partaide guztiek ikus ditzakete. Transakzio pribatuek konfidentzialtasun-geruza bat gehitzen dute eta horretarako eskubideak dituzten parte-hartzaileentzat soilik daude eskuragarri.

Bi eszenatokietarako, kontratu bera erabiltzen dugu argitasunerako.

Kontratu adimenduna

Jarraian, gure eszenatokirako sortutako kontratu adimendun sinple bat dago. Aldagai publiko bat du temperature, erabilita alda daitekeena set eta metodo bidez jaso 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;
  }
}

Kontratuak lan egiteko web3.js, ABI formatura eta bytecodera itzuli behar da. Funtzioa erabiliz formatContractbehean kontratua osatzen du erabiliz solc-js.

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

Osatutako kontratua honelakoa da:

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

Orain kontratua prest dagoenez, sarea zabaldu eta kontratua zabalduko dugu.

Nodoen hedapena

Nodo bat zabaltzea nahiko lan handia izan daiteke eta prozesu hau zerbitzu bat erabiliz ordezkatu daiteke Chainstack.

Jarraian, Quorum sarea Raft adostasunarekin eta hiru nodorekin zabaltzeko prozesua dago.

Lehenik eta behin, sortu dezagun proiektu bat eta deitu Quorum Proiektua:

Sortu dezagun Quorum sare bat Raft adostasunarekin Google Cloud Platform-en:

Gehi ditzagun beste bi nodo lehenespenez sortutako nodoari:

Hiru nodo martxan:

Nodoaren xehetasunen orriak RPC amaierako puntua, gako publikoa eta abar erakusten ditu.

Sarea zabalduta dago. Orain inplementa ditzagun kontratu adimendunak eta egin ditzagun transakzioak erabiliz web3.js.

Transakzio publikoak

Testuingurua

Biltegiko tenperaturak garrantzi handia du kostuak murrizteko, batez ere zero azpiko tenperaturan biltegiratzeko produktuetan.

Enpresei beren kokapen geografikoko kanpo-tenperatura denbora errealean partekatzeko eta erregistro aldaezin batean erregistratzeko aukera emanez, sareko parte-hartzaileek kostuak eta denbora murrizten dituzte.

Hiru lan egingo ditugu, diagraman ilustratuta:

Kontratua bidez zabalduko dugu Nodoa 1:

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

Ezarri tenperatura bidez Nodoa 2 3 gradutan:

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

Nodoa 3 kontratu adimendunaren informazioa jasoko du. Kontratuak 3 graduko balioa itzuliko du:
```
const temp = await getTemperature(raft3Node, contractAddress);
console.log(‘Retrieved contract Temperature’, temp);
```
Ondoren, Quorum sarean transakzio publiko bat nola exekutatu aztertuko dugu web3.js.

Instantzia bat abiarazten dugu RPC bidez hiru nodoetarako:

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

Heda dezagun kontratu adimenduna:

// 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 Kontratuarekin harremanetan jartzeko bi modu eskaintzen ditu: call и send.

Eguneratu dezagun kontratuaren tenperatura exekutatuz set web3 metodoa erabiliz 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;
  });
}

Ondoren web3 metodoa erabiltzen dugu call kontratuaren tenperatura lortzeko. Kontuan izan metodoa call tokiko nodo batean exekutatzen da eta transakzioa ez da blockchain-en sortuko.

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

Orain korrika egin dezakezu publikoa.js emaitza hau lortzeko:

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

Ondoren, Quorum esploratzailean sarrerak ikus ditzakegu Chainstack panelean, behean erakusten den moduan.

Hiru nodoek elkarrekintzan aritu ziren eta transakzioak eguneratu ziren:

Lehenengo transakzioak kontratua zabaldu zuen.
Bigarren transakzioak kontratuaren tenperatura 3 gradutan ezarri zuen.
Tenperatura nodo lokal baten bidez jasotzen da, beraz, ez da transakziorik sortzen.

Transakzio pribatuak

Testuingurua

Erakundeen ohiko eskakizuna datuen babesa da. Adibide gisa, kontuan hartu eszenatoki bat zeinetan Supermerkatua biltegi bat alokatzen du itsaskiak bereizi batean gordetzeko Saltzailea:

Saltzailea IoT sentsoreak erabiliz, tenperatura-balioak irakurtzen ditu 30 segundoro eta transmititzen ditu Supermerkatura;
balio horiek soilik erabilgarri egon beharko lukete Saltzaileari и Supermerkatura, partzuergo batek saretuta.

Goiko diagraman azaltzen diren lau zereginak beteko ditugu.

Aurreko eszenatokiko hiru nodo berdinak erabiltzen ditugu transakzio pribatuak erakusteko:
Supermerkatua pribatua den kontratu adimenduna zabaltzen du Supermerkatua и Saltzailea.
Hirugarren aldea ez du kontratu adimendunean sartzeko eskubiderik.

Metodoei deituko diegu get и set izenean Supermerkatua и Saltzailea Quorum transakzio pribatu bat erakusteko.

Parte-hartzaileentzako kontratu pribatu bat zabalduko dugu Supermerkatua и Saltzailea parte-hartzaile baten bitartez Supermerkatua:

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

Ezar dezagun tenperatura Hirugarren festa (kanpoko nodoa) eta lortu tenperaturaren balioa:

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

Ezar dezagun tenperatura Saltzailea (barneko nodoa) eta lortu tenperaturaren balioa:

Egoera honetako tenperaturak 12 balioa itzuli beharko luke kontratu adimendunetik. Kontuan izan Saltzailea hemen kontratu adimendunerako sarbidea baimendu du.

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

Tenperaturatik ateratzen dugu Hirugarren festa (kanpoko nodoa):

3. urratsean tenperatura 12ra ezarri zen, baina Hirugarren aldea ez du kontratu adimendunerako sarbidea. Beraz, itzultzeko balioak nulua izan behar du.
```
// This returns null
const temp3 = await getTemperature(raft3Node, contractAddress);
console.log(`[Node3] temp retrieved from external nodes after update ${temp}`);
```
Jarraian, Quorum sarean transakzio pribatuak egiten aztertuko dugu web3.js. Kode gehiena transakzio publikoetarako berdina denez, transakzio pribatuetarako desberdinak diren zatiak soilik nabarmenduko ditugu.

Kontuan izan sarera kargatutako kontratua aldaezina dela, beraz, baimendutako sarbidea nodo egokiei eman behar zaie kontratua zabaltzen den unean kontratu publikoa gaituz, ez ondoren.

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

Transakzio pribatuak antzeko moduan egiten dira, parte-hartzaileen gako publikoa exekutatzeko unean sartuz.

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

Orain korrika egin dezakegu pribatua.js emaitza hauekin:

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

Chainstack-eko Quorum esploratzaileak honako hau erakutsiko du:

parte-hartzailearen kontratua zabaltzea Supermerkatua;
Emanaldia SetTemperature tik Hirugarren festa;
Emanaldia SetTemperature parte hartzaile batengandik Saltzailea.

Ikus dezakezunez, bi transakzioak burutu dira, baina parte-hartzailearen transakzioa bakarrik Saltzailea kontratuan tenperatura eguneratu du. Horrela, transakzio pribatuek aldaezintasuna ematen dute, baina, aldi berean, ez diote hirugarren bati datuak agerian uzten.

Ondorioa

Quorum-en erabilera-kasu komertzial bat aztertu dugu biltegi batean tenperaturari buruzko informazio eguneratua emateko bi alderdiren arteko sare bat zabalduz: supermerkatu bat eta biltegiaren jabea.

Tenperaturari buruzko informazio eguneratua nola mantendu daitekeen erakutsi genuen transakzio publiko zein pribatuen bidez.

Aplikazio eszenatoki asko egon daitezke eta, ikusten duzuenez, ez da batere zaila.

Probatu, saiatu zure gidoia zabaltzen. Gainera, blockchain teknologiaren industria 2024rako ia hamar aldiz hazi daiteke.

Iturria: www.habr.com

Egin transakzio publikoak eta pribatuak JPMorgan Quorum blockchain-en Web3 erabiliz

Testuingurua

Kontratu adimenduna

Nodoen hedapena

Transakzio publikoak

Testuingurua

Transakzio pribatuak

Testuingurua

Ondorioa

Gehitu iruzkin berria Idatzi