🥇 Perfformio trafodion cyhoeddus a phreifat ar blockchain JPMorgan Quorum gan ddefnyddio Web3

Cworwm yn blockchain seiliedig ar Ethereum a ddatblygwyd gan JPMorgan ac yn fwyaf diweddar daeth y llwyfan cyfriflyfr dosbarthedig cyntaf i gael ei gynnig gan Microsoft Azure.

Mae Quorum yn cefnogi trafodion preifat a chyhoeddus ac mae ganddo lawer o achosion defnydd masnachol.

Yn yr erthygl hon, byddwn yn archwilio un senario o'r fath - defnyddio rhwydwaith cyfriflyfr dosbarthedig rhwng archfarchnad a pherchennog warws i ddarparu'r wybodaeth ddiweddaraf am dymheredd y warws.

Mae'r cod a ddefnyddir yn y tiwtorial hwn i mewn storfeydd ar GitHub.

Mae'r erthygl yn ymdrin â:

creu contract call;
defnyddio'r rhwydwaith Cworwm gan ddefnyddio Stac Cadwyn;
trafodion cyhoeddus cworwm;
Trafodion preifat cworwm.

I ddangos, rydym yn defnyddio senario ar gyfer monitro tymheredd mewn warysau aelodau o'r rhwydwaith Cworwm o fewn Rhyngrwyd Pethau (IoT).

Cyd-destun

Mae grŵp o gwmnïau warws yn uno mewn consortiwm i storio gwybodaeth ar y cyd ac awtomeiddio prosesau ar y blockchain. Ar gyfer hyn, penderfynodd cwmnïau ddefnyddio Cworwm. Yn yr erthygl hon byddwn yn ymdrin â dwy senario: trafodion cyhoeddus a thrafodion preifat.

Caiff trafodion eu creu gan wahanol gyfranogwyr i ryngweithio â'r consortiwm y maent yn perthyn iddo. Mae pob trafodiad naill ai'n defnyddio contract neu'n galw swyddogaeth yn y contract i uwchlwytho data i'r rhwydwaith. Mae'r camau hyn yn cael eu hailadrodd i bob nod ar y rhwydwaith.

Mae trafodion cyhoeddus ar gael i bawb sy'n cymryd rhan yn y consortiwm eu gweld. Mae trafodion preifat yn ychwanegu haen o gyfrinachedd ac maent ar gael i'r cyfranogwyr hynny sydd â'r hawl i wneud hynny yn unig.

Ar gyfer y ddau senario, rydym yn defnyddio'r un contract er eglurder.

Contract craff

Isod mae contract smart syml a grëwyd ar gyfer ein senario. Mae ganddo newidyn cyhoeddus temperature, y gellir ei newid gan ddefnyddio set a derbyn trwy ddull 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;
  }
}

Er mwyn i'r contract weithio ag ef gwe3.js, rhaid ei gyfieithu i fformat ABI a bytecode. Gan ddefnyddio'r swyddogaeth formatContractisod yn llunio'r contract gan ddefnyddio solc-js.

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

Mae'r contract gorffenedig yn edrych fel hyn:

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

Nawr bod y contract yn barod, byddwn yn defnyddio'r rhwydwaith ac yn defnyddio'r contract.

Gosod nodau

Gall gosod nod fod yn weddol lafur-ddwys a gellir disodli'r broses hon trwy ddefnyddio gwasanaeth Stac Cadwyn.

Isod mae'r broses ar gyfer defnyddio'r rhwydwaith Cworwm gyda chonsensws Raft a thri nod.

Yn gyntaf, gadewch i ni greu prosiect a'i alw'n Brosiect Cworwm:

Gadewch i ni greu rhwydwaith Cworwm gyda chonsensws Raft ar Google Cloud Platform:

Gadewch i ni ychwanegu dau nod arall at y nod a grëwyd eisoes yn ddiofyn:

Tri nod rhedeg:

Mae'r dudalen manylion nod yn dangos diweddbwynt RPC, allwedd gyhoeddus, ac ati.

Mae'r rhwydwaith yn cael ei ddefnyddio. Nawr, gadewch i ni ddefnyddio contractau smart a pherfformio trafodion gan ddefnyddio gwe3.js.

Trafodion cyhoeddus

Cyd-destun

Mae tymheredd warws yn bwysig iawn wrth leihau costau, yn enwedig ar gyfer cynhyrchion y bwriedir eu storio ar dymheredd is-sero.

Trwy ganiatáu i gwmnïau rannu tymheredd allanol eu lleoliad daearyddol mewn amser real a'i gofnodi mewn cyfriflyfr na ellir ei gyfnewid, mae cyfranogwyr y rhwydwaith yn lleihau costau ac amser.

Byddwn yn cyflawni tair tasg, a ddangosir yn y diagram:

Byddwn yn defnyddio'r contract drwy Node 1:

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

Gosodwch y tymheredd trwy Node 2 o 3 gradd:

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

Node 3 yn derbyn gwybodaeth o'r contract smart. Bydd y contract yn dychwelyd y gwerth 3 gradd:
```
const temp = await getTemperature(raft3Node, contractAddress);
console.log(‘Retrieved contract Temperature’, temp);
```
Nesaf, byddwn yn edrych ar sut i gyflawni trafodiad cyhoeddus ar rwydwaith Cworwm gan ddefnyddio gwe3.js.

Rydym yn cychwyn achos trwy RPC ar gyfer tri nod:

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

Gadewch i ni ddefnyddio'r contract smart:

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

gwe3.js yn darparu dau ddull ar gyfer rhyngweithio â’r contract: call и send.

Gadewch i ni ddiweddaru tymheredd y contract trwy weithredu set defnyddio dull gwe3 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;
  });
}

Nesaf rydym yn defnyddio'r dull web3 call i gael tymheredd y contract. Sylwch fod y dull call yn cael ei weithredu ar nod lleol ac ni fydd y trafodiad yn cael ei greu ar y blockchain.

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

Nawr gallwch chi redeg cyhoeddus.js i gael y canlyniad canlynol:

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

Nesaf, gallwn weld y cofnodion yn yr archwiliwr Cworwm yn y panel Chainstack, fel y dangosir isod.

Roedd y tri nod yn rhyngweithio a chafodd y trafodion eu diweddaru:

Defnyddiodd y trafodiad cyntaf y contract.
Gosododd yr ail drafodiad dymheredd y contract i 3 gradd.
Derbynnir y tymheredd trwy nod lleol, felly ni chrëir trafodiad.

Trafodion preifat

Cyd-destun

Un o ofynion cyffredin sefydliadau yw diogelu data. Fel enghraifft, ystyriwch senario lle Archfarchnad yn rhentu gofod warws ar gyfer storio bwyd môr o ar wahân Gwerthwr:

Gwerthwr gan ddefnyddio synwyryddion IoT, yn darllen gwerthoedd tymheredd bob 30 eiliad ac yn eu trosglwyddo I'r archfarchnad;
dim ond y gwerthoedd hyn ddylai fod ar gael I'r gwerthwr и I'r archfarchnad, wedi'i rhwydweithio gan gonsortiwm.

Byddwn yn cwblhau'r pedair tasg a ddangosir yn y diagram uchod.

Rydym yn defnyddio’r un tri nod o’r senario blaenorol i ddangos trafodion preifat:
Archfarchnad yn defnyddio contract smart sy'n breifat i Archfarchnad и Gwerthwr.
Y drydedd ochr nid oes ganddo'r hawl i gael mynediad at y contract smart.

Byddwn yn galw'r dulliau get и set ar ran Archfarchnad и Gwerthwr i ddangos trafodiad Cworwm preifat.

Byddwn yn defnyddio contract preifat ar gyfer cyfranogwyr Archfarchnad и Gwerthwr trwy gyfranogwr Archfarchnad:

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

Gadewch i ni osod y tymheredd o Trydydd parti (nod allanol) a chael y gwerth tymheredd:

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

Gadewch i ni osod y tymheredd o Gwerthwr (nod mewnol) a chael y gwerth tymheredd:

Dylai'r tymheredd yn y senario hwn ddychwelyd y gwerth 12 o'r contract smart. Sylwch hynny Gwerthwr yma wedi awdurdodi mynediad i'r contract smart.

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

Rydyn ni'n cael y tymheredd o Trydydd parti (nôd allanol):

Yng ngham 3 gosodwyd y tymheredd i 12, ond Y drydedd ochr nad oes ganddo fynediad at y contract smart. Felly rhaid i'r gwerth dychwelyd fod yn nwl.
```
// This returns null
const temp3 = await getTemperature(raft3Node, contractAddress);
console.log(`[Node3] temp retrieved from external nodes after update ${temp}`);
```
Nesaf, byddwn yn edrych yn agosach ar berfformio trafodion preifat ar y rhwydwaith Cworwm gyda gwe3.js. Gan fod y rhan fwyaf o'r cod yr un peth ar gyfer trafodion cyhoeddus, dim ond y rhannau hynny sy'n wahanol ar gyfer trafodion preifat y byddwn yn eu hamlygu.

Sylwch fod y contract a uwchlwythir i'r rhwydwaith yn ddigyfnewid, felly rhaid caniatáu mynediad â chaniatâd i'r nodau priodol trwy alluogi'r contract cyhoeddus ar yr adeg y caiff y contract ei ddefnyddio, nid ar ôl hynny.

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

Perfformir trafodion preifat mewn ffordd debyg - trwy gynnwys allwedd gyhoeddus y cyfranogwyr ar adeg gweithredu.

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

Nawr gallwn redeg preifat.js gyda'r canlyniadau canlynol:

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

Bydd yr archwiliwr Cworwm yn Chainstack yn dangos y canlynol:

defnyddio'r contract gan y cyfranogwr Archfarchnad;
Perfformiad SetTemperature o Trydydd parti;
Perfformiad SetTemperature gan gyfranogwr Gwerthwr.

Fel y gwelwch, mae'r ddau drafodiad yn cael eu cwblhau, ond dim ond y trafodiad gan y cyfranogwr Gwerthwr diweddaru'r tymheredd yn y contract. Felly, mae trafodion preifat yn darparu ansymudedd, ond ar yr un pryd nid ydynt yn datgelu data i drydydd parti.

Casgliad

Edrychwyd ar achos defnydd masnachol i Quorum ddarparu'r wybodaeth ddiweddaraf am dymheredd mewn warws trwy ddefnyddio rhwydwaith rhwng dau barti - archfarchnad a pherchennog warws.

Gwnaethom ddangos sut y gellir cynnal y wybodaeth ddiweddaraf am dymheredd trwy drafodion cyhoeddus a phreifat.

Gall fod llawer o senarios ymgeisio ac, fel y gwelwch, nid yw'n anodd o gwbl.

Arbrofwch, ceisiwch ehangu eich sgript. Ar ben hynny, mae'r diwydiant technoleg blockchain gallai dyfu bron i ddeg gwaith erbyn 2024.

Ffynhonnell: hab.com

Perfformio trafodion cyhoeddus a phreifat ar blockchain JPMorgan Quorum gan ddefnyddio Web3

Cyd-destun

Contract craff

Gosod nodau

Trafodion cyhoeddus

Cyd-destun

Trafodion preifat

Cyd-destun

Casgliad

Ychwanegu sylw Diddymu ateb