Magsagawa ng mga pampubliko at pribadong transaksyon sa JPMorgan Quorum blockchain gamit ang Web3

Korum ay isang Ethereum-based blockchain na binuo ng JPMorgan at pinakahuling naging unang distributed ledger platform na inaalok ng Microsoft Azure.

Sinusuportahan ng Quorum ang mga pribado at pampublikong transaksyon at maraming kaso ng paggamit sa komersyo.

Sa artikulong ito, susuriin namin ang isang ganoong sitwasyon - ang pag-deploy ng isang distributed ledger network sa pagitan ng isang supermarket at isang may-ari ng warehouse upang magbigay ng up-to-date na impormasyon tungkol sa temperatura ng warehouse.

Ang code na ginamit sa tutorial na ito ay nasa mga repositoryo sa GitHub.

Sinasaklaw ng artikulo ang:

• paglikha ng isang matalinong kontrata;
• deployment ng Quorum network gamit ang Chainstack;
• Mga pampublikong transaksyon sa korum;
• Mga pribadong transaksyon sa korum.

Upang ilarawan, gumagamit kami ng senaryo para sa pagsubaybay sa temperatura sa mga bodega ng mga miyembro ng network ng Quorum sa loob ng Internet of Things (IoT).

Konteksto

Ang isang grupo ng mga kumpanya ng warehouse ay nagkakaisa sa isang consortium upang magkasamang mag-imbak ng impormasyon at mag-automate ng mga proseso sa blockchain. Para dito, nagpasya ang mga kumpanya na gamitin ang Quorum. Sa artikulong ito tatalakayin natin ang dalawang senaryo: pampublikong transaksyon at pribadong transaksyon.

Ang mga transaksyon ay nilikha ng iba't ibang kalahok upang makipag-ugnayan sa consortium kung saan sila nabibilang. Ang bawat transaksyon ay maaaring mag-deploy ng isang kontrata o tumawag ng isang function sa kontrata upang mag-upload ng data sa network. Ang mga pagkilos na ito ay ginagaya sa lahat ng mga node sa network.

Ang mga pampublikong transaksyon ay magagamit para sa pagtingin ng lahat ng kalahok ng consortium. Ang mga pribadong transaksyon ay nagdaragdag ng isang layer ng pagiging kumpidensyal at magagamit lamang sa mga kalahok na may karapatang gawin ito.

Para sa parehong mga sitwasyon, ginagamit namin ang parehong kontrata para sa kalinawan.

Matalinong kontrata

Nasa ibaba ang isang simpleng smart contract na ginawa para sa aming senaryo. Mayroon itong pampublikong variable temperature, na maaaring baguhin gamit ang set at tumanggap sa pamamagitan ng pamamaraan 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;
  }
}

Upang gumana ang kontrata web3.js, dapat itong isalin sa ABI format at bytecode. Gamit ang function formatContractsa ibaba ay nag-compile ng kontrata gamit solc-js.

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

Ang natapos na kontrata ay ganito ang hitsura:

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

Ngayong handa na ang kontrata, ide-deploy namin ang network at i-deploy ang kontrata.

Pag-deploy ng node

Ang pag-deploy ng node ay maaaring masyadong matrabaho at ang prosesong ito ay maaaring palitan sa pamamagitan ng paggamit ng isang serbisyo Chainstack.

Nasa ibaba ang proseso para sa pag-deploy ng Quorum network na may Raft consensus at tatlong node.

Una, gumawa tayo ng proyekto at tawagin itong Quorum Project:

Gumawa tayo ng isang Quorum network na may Raft consensus sa Google Cloud Platform:

Magdagdag tayo ng dalawa pang node sa node na nilikha na bilang default:

Tatlong tumatakbong node:

Ipinapakita ng pahina ng mga detalye ng node ang RPC endpoint, pampublikong key, atbp.

Na-deploy ang network. Ngayon, mag-deploy tayo ng mga matalinong kontrata at magsagawa ng mga transaksyon gamit web3.js.

Mga pampublikong transaksyon

Konteksto

Ang temperatura ng bodega ay may malaking kahalagahan sa pagbabawas ng mga gastos, lalo na para sa mga produktong inilaan na itago sa mga sub-zero na temperatura.

Sa pamamagitan ng pagpayag sa mga kumpanya na ibahagi ang temperatura sa labas ng kanilang heyograpikong lokasyon sa real time at itala ito sa isang hindi nababagong ledger, binabawasan ng mga kalahok sa network ang mga gastos at oras.

Magsasagawa kami ng tatlong gawain, na inilalarawan sa diagram:

1. Ide-deploy namin ang kontrata sa pamamagitan ng Node 1:

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

2. Itakda ang temperatura sa pamamagitan ng Node 2 sa pamamagitan ng 3 degrees:

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

3. Node 3 ay makakatanggap ng impormasyon mula sa matalinong kontrata. Ibabalik ng kontrata ang halaga na 3 degrees:

   const temp = await getTemperature(raft3Node, contractAddress);
   console.log(‘Retrieved contract Temperature’, temp);

   Susunod, titingnan natin kung paano magsagawa ng pampublikong transaksyon sa Quorum network gamit web3.js.

Nagsisimula kami ng isang instance sa pamamagitan ng RPC para sa tatlong node:

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

I-deploy natin ang matalinong kontrata:

// 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 nagbibigay ng dalawang paraan para sa pakikipag-ugnayan sa kontrata: call и send.

I-update natin ang temperatura ng kontrata sa pamamagitan ng pag-execute set gamit ang web3 method 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;
  });
}

Susunod na ginagamit namin ang paraan ng web3 call upang makuha ang temperatura ng kontrata. Mangyaring tandaan na ang pamamaraan call ay isinasagawa sa isang lokal na node at ang transaksyon ay hindi gagawin sa 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);
}

Ngayon ay maaari kang tumakbo public.js upang makuha ang sumusunod na resulta:

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

Susunod, maaari nating tingnan ang mga entry sa Quorum explorer sa Chainstack panel, tulad ng ipinapakita sa ibaba.

Nakipag-ugnayan ang lahat ng tatlong node at na-update ang mga transaksyon:

1. Ang unang transaksyon ay nag-deploy ng kontrata.
2. Itinakda ng pangalawang transaksyon ang temperatura ng kontrata sa 3 degrees.
3. Ang temperatura ay natanggap sa pamamagitan ng isang lokal na node, kaya walang transaksyon na ginawa.

Mga pribadong transaksyon

Konteksto

Ang isang karaniwang kinakailangan ng mga organisasyon ay proteksyon ng data. Bilang halimbawa, isaalang-alang ang isang senaryo kung saan Supermarket umuupa ng puwang sa bodega para sa pag-iimbak ng seafood mula sa isang hiwalay Nagtitinda:

• Nagtitinda gamit ang mga sensor ng IoT, binabasa ang mga halaga ng temperatura bawat 30 segundo at ipinapadala ang mga ito Sa supermarket;
• ang mga halagang ito ay dapat na magagamit lamang Sa nagtitinda и Sa supermarket, na naka-network ng isang consortium.

Kukumpletuhin natin ang apat na gawain na inilalarawan sa diagram sa itaas.

• Ginagamit namin ang parehong tatlong node mula sa nakaraang senaryo upang ipakita ang mga pribadong transaksyon:
• Supermarket nag-deploy ng matalinong kontrata na pribado sa Supermarket и Nagtitinda.
• Ang ikatlong panig ay walang karapatang i-access ang matalinong kontrata.

Tatawagin natin ang mga pamamaraan get и set sa ngalan ng Supermarket и Nagtitinda upang magpakita ng pribadong transaksyon sa Korum.

1. Magpapakalat kami ng pribadong kontrata para sa mga kalahok Supermarket и Nagtitinda sa pamamagitan ng isang kalahok Supermarket:

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

2. Itakda natin ang temperatura mula sa Third party (panlabas na node) at kunin ang halaga ng temperatura:

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

3. Itakda natin ang temperatura mula sa Nagtitinda (panloob na node) at kunin ang halaga ng temperatura:

   Dapat ibalik ng temperatura sa sitwasyong ito ang value na 12 mula sa smart contract. Pakitandaan iyon Nagtitinda dito ay may awtorisadong pag-access sa matalinong kontrata.

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

4. Kinukuha namin ang temperatura mula sa Third party (panlabas na node):

   Sa hakbang 3 ang temperatura ay itinakda sa 12, ngunit Ang ikatlong panig walang access sa smart contract. Samakatuwid ang return value ay dapat na null.

   // This returns null
   const temp3 = await getTemperature(raft3Node, contractAddress);
   console.log(`[Node3] temp retrieved from external nodes after update ${temp}`);

   Susunod, susuriin nating mabuti ang pagsasagawa ng mga pribadong transaksyon sa network ng Quorum kasama ang web3.js. Dahil ang karamihan sa code ay pareho para sa mga pampublikong transaksyon, iha-highlight lamang namin ang mga bahaging naiiba para sa mga pribadong transaksyon.

Tandaan na ang kontrata na na-upload sa network ay hindi nababago, kaya ang pahintulot na pag-access ay dapat ibigay sa naaangkop na mga node sa pamamagitan ng pagpapagana sa pampublikong kontrata sa oras na ang kontrata ay i-deploy, hindi pagkatapos.

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

Ang mga pribadong transaksyon ay ginagawa sa katulad na paraan - sa pamamagitan ng pagsasama ng pampublikong susi ng mga kalahok sa oras ng pagpapatupad.

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

Ngayon ay maaari na tayong tumakbo private.js kasama ang mga sumusunod na resulta:

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

Ipapakita ng Quorum explorer sa Chainstack ang sumusunod:

• deployment ng kontrata mula sa kalahok Supermarket;
• Katuparan SetTemperature mula sa Third party;
• Katuparan SetTemperature mula sa isang kalahok Nagtitinda.

Tulad ng nakikita mo, ang parehong mga transaksyon ay nakumpleto, ngunit ang transaksyon lamang mula sa kalahok Nagtitinda na-update ang temperatura sa kontrata. Kaya, ang mga pribadong transaksyon ay nagbibigay ng immutability, ngunit sa parehong oras ay hindi nagbubunyag ng data sa isang third party.

Konklusyon

Tiningnan namin ang isang komersyal na kaso ng paggamit para sa Quorum upang magbigay ng up-to-date na impormasyon sa temperatura sa isang bodega sa pamamagitan ng pag-deploy ng network sa pagitan ng dalawang partido - isang supermarket at isang may-ari ng warehouse.

Ipinakita namin kung paano mapapanatili ang up-to-date na impormasyon sa temperatura sa pamamagitan ng pampubliko at pribadong mga transaksyon.

Maaaring magkaroon ng maraming mga sitwasyon ng aplikasyon at, tulad ng nakikita mo, hindi ito mahirap.

Mag-eksperimento, subukang palawakin ang iyong script. Bukod dito, ang industriya ng teknolohiya ng blockchain maaaring lumago ng halos sampung beses sa 2024.

Pinagmulan: www.habr.com