🥇Efektivigi publikajn kaj privatajn transakciojn sur la blokĉeno de JPMorgan Quorum uzante Web3

Kvorumo estas Ethereum-bazita blokĉeno evoluigita fare de JPMorgan kaj plej lastatempe fariĝis la unua distribuita ĉeflibroplatformo ofertita de Microsoft Azure.

Kvorumo subtenas privatajn kaj publikajn transakciojn kaj havas multajn komercajn uzkazojn.

En ĉi tiu artikolo, ni ekzamenos unu tian scenaron - la disfaldiĝon de distribua ĉeflibroreto inter superbazaro kaj magazenisto por provizi ĝisdatajn informojn pri la temperaturo de la magazeno.

La kodo uzata en ĉi tiu lernilo estas en deponejoj sur GitHub.

La artikolo kovras:

kreado de inteligenta kontrakto;
deplojo de la Quorum reto uzante Ĉenstako;
Kvorumaj publikaj transakcioj;
Kvorumaj privataj transakcioj.

Por ilustri, ni uzas scenaron por monitori temperaturon en magazenoj de membroj de la Quorum-reto ene de la Interreto de Aĵoj (IoT).

Kunteksto

Grupo de magazenaj kompanioj kuniĝas en konsorcio por kune stoki informojn kaj aŭtomatigi procezojn sur la blokĉeno. Por tio, kompanioj decidis uzi Quorum. En ĉi tiu artikolo ni kovros du scenarojn: publikaj transakcioj kaj privataj transakcioj.

Transakcioj estas kreitaj de malsamaj partoprenantoj por interagi kun la konsorcio al kiu ili apartenas. Ĉiu transakcio aŭ deplojas kontrakton aŭ vokas funkcion en la kontrakto por alŝuti datumojn al la reto. Ĉi tiuj agoj estas reproduktitaj al ĉiuj nodoj en la reto.

Publikaj transakcioj estas disponeblaj por spektado de ĉiuj konsorciaj partoprenantoj. Privataj transakcioj aldonas tavolon de konfidenco kaj estas haveblaj nur al tiuj partoprenantoj, kiuj havas rajtojn fari tion.

Por ambaŭ scenaroj, ni uzas la saman kontrakton por klareco.

Inteligenta kontrakto

Malsupre estas simpla inteligenta kontrakto kreita por nia scenaro. Ĝi havas publikan variablon temperature, kiu povas esti ŝanĝita uzante set kaj ricevi per metodo 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;
  }
}

Por ke la kontrakto funkciu kun retejo3.js, ĝi devas esti tradukita en ABI-formaton kaj bajtkodon. Uzante la funkcion formatContractsube kompilas la kontrakton uzante solc-js.

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

La finita kontrakto aspektas jene:

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

Nun kiam la kontrakto estas preta, ni deplojos la reton kaj deplojos la kontrakton.

Noda deplojo

Deploji nodon povas esti sufiĉe labor-intensa kaj ĉi tiu procezo povas esti anstataŭigita per uzado de servo Ĉenstako.

Malsupre estas la procezo por deploji la Quorum-reton kun Raft-konsento kaj tri nodoj.

Unue, ni kreu projekton kaj nomu ĝin Kvoruma Projekto:

Ni kreu Quorum-reton kun Raft-konsento en Google Cloud Platform:

Ni aldonu du pliajn nodojn al la jam kreita defaŭlte:

Tri kurantaj nodoj:

La noda detaloj-paĝo montras la RPC-finpunkton, publikan ŝlosilon ktp.

La reto estas deplojita. Nun ni disfaldu inteligentajn kontraktojn kaj faru transakciojn uzante retejo3.js.

Publikaj transakcioj

Kunteksto

Stoktemperaturo estas de granda graveco en reduktado de kostoj, precipe por produktoj intencitaj por esti stokitaj ĉe sub-nulaj temperaturoj.

Permesante al kompanioj dividi la eksteran temperaturon de sia geografia loko en reala tempo kaj registri ĝin en neŝanĝebla ĉeflibro, retaj partoprenantoj reduktas kostojn kaj tempon.

Ni plenumos tri taskojn, ilustritajn en la diagramo:

Ni deplojos la kontrakton per Nodo 1:

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

Agordu la temperaturon per Nodo 2 je 3 gradoj:

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

Nodo 3 ricevos informojn de la inteligenta kontrakto. La kontrakto redonos la valoron 3 gradoj:
```
const temp = await getTemperature(raft3Node, contractAddress);
console.log(‘Retrieved contract Temperature’, temp);
```
Poste, ni rigardos kiel efektivigi publikan transakcion sur la Quorum-reto uzante retejo3.js.

Ni iniciatas ekzemplon per RPC por tri nodoj:

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

Ni deplojigu la inteligentan kontrakton:

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

retejo3.js disponigas du metodojn por interagado kun la kontrakto: call и send.

Ni ĝisdatigu la kontraktotemperaturon per ekzekuto set uzante web3-metodon 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;
  });
}

Poste ni uzas la metodon web3 call por akiri la kontraktotemperaturon. Bonvolu noti, ke la metodo call estas ekzekutita sur loka nodo kaj la transakcio ne estos kreita sur la blokĉeno.

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

Nun vi povas kuri public.js por ricevi la sekvan rezulton:

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

Poste, ni povas vidi la enskribojn en la Kvoruma esploristo en la panelo Chainstack, kiel montrite sube.

Ĉiuj tri nodoj interagis kaj la transakcioj estis ĝisdatigitaj:

La unua transakcio deplojis la kontrakton.
La dua transakcio starigis la kontraktotemperaturon al 3 gradoj.
La temperaturo ricevas per loka nodo, do neniu transakcio estas kreita.

Privataj transakcioj

Kunteksto

Ofta postulo de organizoj estas datuma protekto. Ekzemple, konsideru scenaron en kiu Superbazaro luas magazenon por stoki marmanĝaĵojn de aparta Vendisto:

Vendisto uzante IoT-sensilojn, legas temperaturvalorojn ĉiujn 30 sekundojn kaj transdonas ilin Al la superbazaro;
ĉi tiuj valoroj devus esti nur disponeblaj Al la vendisto и Al la superbazaro, interkonektita de konsorcio.

Ni plenumos la kvar taskojn ilustritajn en la supra diagramo.

Ni uzas la samajn tri nodojn de la antaŭa scenaro por montri privatajn transakciojn:
Superbazaro deplojas inteligentan kontrakton, kiu estas privata al Superbazaro и Vendisto.
La tria flanko ne havas la rajton aliri la inteligentan kontrakton.

Ni nomos la metodojn get и set nome de Superbazaro и Vendisto por pruvi privatan Quorum-transakcion.

Ni deplojos privatan kontrakton por partoprenantoj Superbazaro и Vendisto per partoprenanto Superbazaro:

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

Ni agordu la temperaturon de Tria partio (ekstera nodo) kaj ricevu la temperaturvaloron:

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

Ni agordu la temperaturon de Vendisto (interna nodo) kaj ricevu la temperaturvaloron:

La temperaturo en ĉi tiu scenaro devus redoni la valoron 12 de la inteligenta kontrakto. Bonvolu noti tion Vendisto ĉi tie rajtigis aliron al la inteligenta kontrakto.

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

Ni ricevas la temperaturon de Tria partio (ekstera nodo):

En la paŝo 3 la temperaturo estis fiksita al 12, sed La tria flanko ne havas aliron al la inteligenta kontrakto. Tial la revena valoro devas esti nula.
```
// This returns null
const temp3 = await getTemperature(raft3Node, contractAddress);
console.log(`[Node3] temp retrieved from external nodes after update ${temp}`);
```
Poste, ni rigardos pli detale pri farado de privataj transakcioj en la Quorum-reto kun retejo3.js. Ĉar la plej granda parto de la kodo estas la sama por publikaj transakcioj, ni reliefigos nur tiujn partojn kiuj estas malsamaj por privataj transakcioj.

Notu, ke la kontrakto alŝutita al la reto estas neŝanĝebla, do permesata aliro devas esti koncedita al la taŭgaj nodoj ebligante la publikan kontrakton en la momento kiam la kontrakto estas deplojita, ne poste.

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

Privataj transakcioj estas faritaj en simila maniero - inkluzivante la publikan ŝlosilon de la partoprenantoj en la momento de ekzekuto.

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

Nun ni povas kuri privata.js kun la sekvaj rezultoj:

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

La Kvoruma esploristo en Chainstack montros la jenon:

deplojo de la kontrakto de la partoprenanto Superbazaro;
Agado SetTemperature el Tria partio;
Agado SetTemperature de partoprenanto Vendisto.

Kiel vi povas vidi, ambaŭ transakcioj estas kompletigitaj, sed nur la transakcio de la partoprenanto Vendisto ĝisdatigis la temperaturon en la kontrakto. Tiel, privataj transakcioj provizas neŝanĝeblecon, sed samtempe ne malkaŝas datumojn al tria partio.

konkludo

Ni rigardis komercan uzkazon por Quorum por provizi ĝisdatajn temperaturinformojn en magazeno per deplojado de reto inter du partioj - superbazaro kaj magazenposedanto.

Ni montris kiel ĝisdataj temperaturoj povas esti konservitaj per publikaj kaj privataj transakcioj.

Povas esti multaj aplikaj scenaroj kaj, kiel vi povas vidi, ĝi tute ne estas malfacila.

Eksperimentu, provu vastigi vian skripton. Plie, la blokĉena teknologia industrio povus kreski preskaŭ dekoble antaŭ 2024.

fonto: www.habr.com

Faru publikajn kaj privatajn transakciojn sur la blokĉeno de JPMorgan Quorum uzante Web3

Kunteksto

Inteligenta kontrakto

Noda deplojo

Publikaj transakcioj

Kunteksto

Privataj transakcioj

Kunteksto

konkludo

Aldoni komenton Отменить ответ