អនុវត្តប្រតិបត្តិការសាធារណៈ និងឯកជននៅលើ JPMorgan Quorum blockchain ដោយប្រើ Web3

កូរ៉ុម គឺជា blockchain ដែលមានមូលដ្ឋានលើ Ethereum ដែលបង្កើតឡើងដោយ JPMorgan ហើយថ្មីៗនេះបានក្លាយជាវេទិកាចែកចាយសៀវភៅកត់ត្រាដំបូងគេដែលត្រូវបានផ្តល់ជូនដោយ Microsoft Azure ។

កូរ៉ុមគាំទ្រប្រតិបត្តិការឯកជន និងសាធារណៈ ហើយមានករណីប្រើប្រាស់ពាណិជ្ជកម្មជាច្រើន។

នៅក្នុងអត្ថបទនេះ យើងនឹងពិនិត្យមើលសេណារីយ៉ូបែបនេះមួយ - ការដាក់ពង្រាយបណ្តាញបញ្ជីរាយការចែកចាយរវាងផ្សារទំនើប និងម្ចាស់ឃ្លាំង ដើម្បីផ្តល់ព័ត៌មានថ្មីៗអំពីសីតុណ្ហភាពនៃឃ្លាំង។

កូដ​ដែល​ប្រើ​ក្នុង​ការ​បង្រៀន​នេះ​គឺ​នៅ​ក្នុង ឃ្លាំងនៅលើ GitHub.

អត្ថបទគ្របដណ្តប់៖

• ការបង្កើតកិច្ចសន្យាឆ្លាតវៃ;
• ការដាក់ពង្រាយបណ្តាញកូរ៉ុមដោយប្រើ ឆាឆឺក;
• កូរ៉ុម ប្រតិបត្តិការសាធារណៈ;
• ប្រតិបត្តិការឯកជននៃកូរ៉ុម។

ដើម្បីបង្ហាញ យើងប្រើសេណារីយ៉ូសម្រាប់ត្រួតពិនិត្យសីតុណ្ហភាពនៅក្នុងឃ្លាំងរបស់សមាជិកនៃបណ្តាញកូរ៉ុមនៅក្នុងអ៊ីនធឺណែតនៃអ្វីៗ (IoT)។

បរិបទ

ក្រុម​ហ៊ុន​ឃ្លាំង​មួយ​កំពុង​រួប​រួម​គ្នា​ក្នុង​ក្រុម​ហ៊ុន​មួយ​ដើម្បី​រក្សា​ទុក​ព័ត៌មាន​រួម​គ្នា និង​ធ្វើ​ដំណើរ​ការ​ដោយ​ស្វ័យ​ប្រវត្តិ​នៅ​លើ blockchain។ សម្រាប់បញ្ហានេះ ក្រុមហ៊ុនបានសម្រេចចិត្តប្រើកូរ៉ុម។ នៅក្នុងអត្ថបទនេះ យើងនឹងរៀបរាប់អំពីសេណារីយ៉ូពីរ៖ ប្រតិបត្តិការសាធារណៈ និងប្រតិបត្តិការឯកជន។

ប្រតិបត្តិការត្រូវបានបង្កើតឡើងដោយអ្នកចូលរួមផ្សេងៗគ្នាដើម្បីធ្វើអន្តរកម្មជាមួយសម្ព័ន្ធដែលពួកគេជាកម្មសិទ្ធិ។ ប្រតិបត្តិការនីមួយៗដាក់ពង្រាយកិច្ចសន្យា ឬហៅមុខងារមួយនៅក្នុងកិច្ចសន្យា ដើម្បីផ្ទុកទិន្នន័យទៅក្នុងបណ្តាញ។ សកម្មភាពទាំងនេះត្រូវបានចម្លងទៅកាន់ថ្នាំងទាំងអស់នៅលើបណ្តាញ។

ប្រតិបត្តិការសាធារណៈគឺអាចរកបានសម្រាប់មើលដោយអ្នកចូលរួមគ្រប់សម្ព័ន្ធ។ ប្រតិបត្តិការឯកជនបន្ថែមស្រទាប់នៃការសម្ងាត់ ហើយមានសម្រាប់តែអ្នកចូលរួមដែលមានសិទ្ធិធ្វើដូច្នេះប៉ុណ្ណោះ។

សម្រាប់សេណារីយ៉ូទាំងពីរ យើងប្រើកិច្ចសន្យាដូចគ្នាសម្រាប់ភាពច្បាស់លាស់។

កិច្ចសន្យាឆ្លាតវៃ

ខាងក្រោមនេះគឺជាកិច្ចសន្យាឆ្លាតវៃសាមញ្ញមួយដែលត្រូវបានបង្កើតឡើងសម្រាប់សេណារីយ៉ូរបស់យើង។ វាមានអថេរសាធារណៈ temperatureដែលអាចផ្លាស់ប្តូរបានដោយប្រើ set និងទទួលដោយវិធីសាស្រ្ត 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;
  }
}

ដើម្បីឱ្យកិច្ចសន្យាធ្វើការជាមួយ គេហទំព័រ 3.jsវាត្រូវតែត្រូវបានបកប្រែទៅជាទម្រង់ ABI និង bytecode។ ការប្រើប្រាស់មុខងារ formatContractខាងក្រោមចងក្រងកិច្ចសន្យាដោយប្រើ solc-js.

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

កិច្ចសន្យាដែលបានបញ្ចប់មើលទៅដូចនេះ៖

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

ឥឡូវនេះកិច្ចសន្យារួចរាល់ យើងនឹងពង្រាយបណ្តាញ និងពង្រាយកិច្ចសន្យា។

ការដាក់ពង្រាយថ្នាំង

ការដាក់ពង្រាយថ្នាំងអាចប្រើកម្លាំងពលកម្មខ្លាំង ហើយដំណើរការនេះអាចត្រូវបានជំនួសដោយការប្រើប្រាស់សេវាកម្ម ឆាឆឺក.

ខាងក្រោមនេះគឺជាដំណើរការសម្រាប់ដាក់ពង្រាយបណ្តាញ Quorum ជាមួយនឹង Raft consensus និងថ្នាំងបី។

ជាដំបូង ចូរយើងបង្កើតគម្រោងមួយ ហើយហៅវាថា គម្រោងកូរ៉ុម៖

តោះបង្កើតបណ្តាញ Quorum ជាមួយ Raft consensus នៅលើ Google Cloud Platform៖

តោះបន្ថែមថ្នាំងពីរទៀតទៅថ្នាំងដែលបានបង្កើតរួចហើយតាមលំនាំដើម៖

ថ្នាំងដែលកំពុងដំណើរការបី៖

ទំព័រពត៌មានលំអិតរបស់ថ្នាំងបង្ហាញចំណុចបញ្ចប់ RPC សោសាធារណៈ។ល។

បណ្តាញត្រូវបានដាក់ពង្រាយ។ ឥឡូវនេះ ចូរយើងដាក់ពង្រាយកិច្ចសន្យាឆ្លាតវៃ និងធ្វើប្រតិបត្តិការដោយប្រើ គេហទំព័រ 3.js.

ប្រតិបត្តិការសាធារណៈ

បរិបទ

សីតុណ្ហភាពក្នុងឃ្លាំងមានសារៈសំខាន់ខ្លាំងក្នុងការកាត់បន្ថយការចំណាយ ជាពិសេសសម្រាប់ផលិតផលដែលមានបំណងរក្សាទុកនៅសីតុណ្ហភាពរងសូន្យ។

ដោយអនុញ្ញាតឱ្យក្រុមហ៊ុនចែករំលែកសីតុណ្ហភាពខាងក្រៅនៃទីតាំងភូមិសាស្រ្តរបស់ពួកគេក្នុងពេលវេលាជាក់ស្តែង ហើយកត់ត្រាវានៅក្នុងសៀវភៅកត់ត្រាដែលមិនអាចផ្លាស់ប្តូរបាន អ្នកចូលរួមបណ្តាញកាត់បន្ថយការចំណាយ និងពេលវេលា។

យើង​នឹង​អនុវត្ត​កិច្ចការ​បី​ដែល​បង្ហាញ​ក្នុង​ដ្យាក្រាម៖

1. យើងនឹងដាក់ពង្រាយកិច្ចសន្យាតាមរយៈ ថ្នាំង 1:

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

2. កំណត់សីតុណ្ហភាពតាមរយៈ ថ្នាំង 2 ដោយ 3 ដឺក្រេ:

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

3. ថ្នាំង 3 នឹងទទួលបានព័ត៌មានពីកិច្ចសន្យាឆ្លាតវៃ។ កិច្ចសន្យានឹងត្រឡប់តម្លៃ 3 ដឺក្រេ៖

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

   បន្ទាប់ យើងនឹងពិនិត្យមើលរបៀបប្រតិបត្តិប្រតិបត្តិការសាធារណៈនៅលើបណ្តាញកូរ៉ុមដោយប្រើ គេហទំព័រ 3.js.

យើងចាប់ផ្តើមឧទាហរណ៍តាមរយៈ RPC សម្រាប់ថ្នាំងបី៖

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

តោះដាក់ពង្រាយកិច្ចសន្យាឆ្លាតវៃ៖

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

គេហទំព័រ 3.js ផ្តល់វិធីសាស្រ្តពីរសម្រាប់អន្តរកម្មជាមួយកិច្ចសន្យា៖ call и send.

តោះធ្វើបច្ចុប្បន្នភាពសីតុណ្ហភាពកិច្ចសន្យាដោយប្រតិបត្តិ set ដោយប្រើវិធីសាស្ត្រ 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;
  });
}

បន្ទាប់យើងប្រើវិធីសាស្ត្រ web3 call ដើម្បីទទួលបានសីតុណ្ហភាពកិច្ចសន្យា។ សូមចំណាំថាវិធីសាស្រ្ត call ត្រូវបានប្រតិបត្តិនៅលើថ្នាំងមូលដ្ឋាន ហើយប្រតិបត្តិការនឹងមិនត្រូវបានបង្កើតនៅលើ 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);
}

ឥឡូវនេះអ្នកអាចរត់បាន។ public.js ដើម្បីទទួលបានលទ្ធផលដូចខាងក្រោម៖

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

បន្ទាប់មក យើងអាចមើលធាតុនៅក្នុង Quorum explorer នៅក្នុងបន្ទះ Chainstack ដូចដែលបានបង្ហាញខាងក្រោម។

ថ្នាំងទាំងបីបានធ្វើអន្តរកម្ម ហើយប្រតិបត្តិការត្រូវបានធ្វើបច្ចុប្បន្នភាព៖

1. ប្រតិបត្តិការដំបូងបានដាក់ពង្រាយកិច្ចសន្យា។
2. ប្រតិបត្តិការទីពីរកំណត់សីតុណ្ហភាពកិច្ចសន្យាដល់ 3 ដឺក្រេ។
3. សីតុណ្ហភាពត្រូវបានទទួលតាមរយៈថ្នាំងមូលដ្ឋាន ដូច្នេះគ្មានប្រតិបត្តិការណាមួយត្រូវបានបង្កើតទេ។

ប្រតិបត្តិការឯកជន

បរិបទ

តម្រូវការទូទៅរបស់អង្គការគឺការការពារទិន្នន័យ។ ជាឧទាហរណ៍ សូមពិចារណាសេណារីយ៉ូមួយក្នុងនោះ។ ផ្សារទំនើប ជួលឃ្លាំងសម្រាប់រក្សាទុកអាហារសមុទ្រដាច់ដោយឡែកពីគ្នា។ អ្នកលក់:

• អ្នកលក់ ដោយប្រើឧបករណ៍ចាប់សញ្ញា IoT អានតម្លៃសីតុណ្ហភាពរៀងរាល់ 30 វិនាទី ហើយបញ្ជូនពួកគេ។ ទៅផ្សារទំនើប;
• តម្លៃទាំងនេះគួរតែអាចប្រើបាន ដល់អ្នកលក់ и ទៅផ្សារទំនើបបណ្តាញដោយសម្ព័ន្ធមួយ។

យើងនឹងបំពេញកិច្ចការទាំងបួនដែលបានបង្ហាញនៅក្នុងដ្យាក្រាមខាងលើ។

• យើងប្រើថ្នាំងបីដូចគ្នាពីសេណារីយ៉ូមុន ដើម្បីបង្ហាញពីប្រតិបត្តិការឯកជន៖
• ផ្សារទំនើប ដាក់ពង្រាយកិច្ចសន្យាឆ្លាតវៃដែលមានលក្ខណៈឯកជន ផ្សារទំនើប и អ្នកលក់.
• ភាគីទីបី មិនមានសិទ្ធិចូលប្រើកិច្ចសន្យាឆ្លាតវៃទេ។

យើងនឹងហៅវិធីសាស្រ្ត get и set ក្នុងនាម ផ្សារទំនើប и អ្នកលក់ ដើម្បីបង្ហាញពីប្រតិបត្តិការនៃកូរ៉ុមឯកជន។

1. យើងនឹងដាក់ពង្រាយកិច្ចសន្យាឯកជនសម្រាប់អ្នកចូលរួម ផ្សារទំនើប и អ្នកលក់ តាមរយៈអ្នកចូលរួម ផ្សារទំនើប:

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

2. តោះកំណត់សីតុណ្ហភាពពី ភាគី​ទីបី (ថ្នាំងខាងក្រៅ) និងទទួលបានតម្លៃសីតុណ្ហភាព៖

   // 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. តោះកំណត់សីតុណ្ហភាពពី អ្នកលក់ (ថ្នាំងខាងក្នុង) និងទទួលបានតម្លៃសីតុណ្ហភាព៖

   សីតុណ្ហភាពនៅក្នុងសេណារីយ៉ូនេះគួរតែត្រឡប់តម្លៃ 12 ពីកិច្ចសន្យាឆ្លាតវៃ។ សូមចំណាំ អ្នកលក់ នៅទីនេះមានសិទ្ធិចូលប្រើកិច្ចសន្យាឆ្លាតវៃ។

   // 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. យើងទទួលបានសីតុណ្ហភាពពី ភាគី​ទីបី (ថ្នាំងខាងក្រៅ)៖

   នៅក្នុងជំហានទី 3 សីតុណ្ហភាពត្រូវបានកំណត់ទៅ 12 ប៉ុន្តែ ភាគីទីបី មិនមានសិទ្ធិចូលប្រើកិច្ចសន្យាឆ្លាតវៃទេ។ ដូច្នេះតម្លៃត្រឡប់ត្រូវតែទទេ។

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

   បន្ទាប់ យើងនឹងពិនិត្យមើលកាន់តែដិតដល់ក្នុងការអនុវត្តប្រតិបត្តិការឯកជននៅលើបណ្តាញកូរ៉ុមជាមួយ គេហទំព័រ 3.js. ដោយសារលេខកូដភាគច្រើនគឺដូចគ្នាសម្រាប់ប្រតិបត្តិការសាធារណៈ យើងនឹងរំលេចតែផ្នែកទាំងនោះដែលខុសគ្នាសម្រាប់ប្រតិបត្តិការឯកជន។

សូមចំណាំថាកិច្ចសន្យាដែលបានផ្ទុកឡើងទៅកាន់បណ្តាញគឺមិនអាចផ្លាស់ប្តូរបាន ដូច្នេះការចូលប្រើដែលត្រូវបានអនុញ្ញាតត្រូវតែត្រូវបានផ្តល់ទៅឱ្យថ្នាំងដែលសមស្របដោយបើកកិច្ចសន្យាសាធារណៈនៅពេលកិច្ចសន្យាត្រូវបានដាក់ឱ្យប្រើប្រាស់ មិនមែនបន្ទាប់ពីនោះទេ។

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

ប្រតិបត្តិការឯកជនត្រូវបានអនុវត្តតាមរបៀបស្រដៀងគ្នា - ដោយបញ្ចូលសោសាធារណៈរបស់អ្នកចូលរួមនៅពេលប្រតិបត្តិ។

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

ឥឡូវនេះយើងអាចរត់បាន។ private.js ជាមួយនឹងលទ្ធផលដូចខាងក្រោម៖

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 នឹងបង្ហាញដូចខាងក្រោម៖

• ការដាក់ពង្រាយកិច្ចសន្យាពីអ្នកចូលរួម ផ្សារទំនើប;
• ការសម្តែង SetTemperature ពី ភាគី​ទីបី;
• ការសម្តែង SetTemperature ពីអ្នកចូលរួម អ្នកលក់.

ដូចដែលអ្នកអាចឃើញប្រតិបត្តិការទាំងពីរត្រូវបានបញ្ចប់ ប៉ុន្តែមានតែប្រតិបត្តិការពីអ្នកចូលរួមប៉ុណ្ណោះ។ អ្នកលក់ ធ្វើបច្ចុប្បន្នភាពសីតុណ្ហភាពក្នុងកិច្ចសន្យា។ ដូច្នេះ ប្រតិបត្តិការឯកជនផ្តល់នូវភាពមិនអាចផ្លាស់ប្តូរបាន ប៉ុន្តែក្នុងពេលតែមួយមិនត្រូវបង្ហាញទិន្នន័យដល់ភាគីទីបីឡើយ។

សេចក្តីសន្និដ្ឋាន

យើងបានពិនិត្យមើលករណីប្រើប្រាស់ពាណិជ្ជកម្មសម្រាប់កូរ៉ុមដើម្បីផ្តល់ព័ត៌មានអំពីសីតុណ្ហភាពទាន់សម័យនៅក្នុងឃ្លាំងដោយដាក់ពង្រាយបណ្តាញរវាងភាគីពីរ - ផ្សារទំនើប និងម្ចាស់ឃ្លាំង។

យើងបានបង្ហាញពីរបៀបដែលព័ត៌មានសីតុណ្ហភាពទាន់សម័យអាចត្រូវបានរក្សាទុកតាមរយៈប្រតិបត្តិការទាំងសាធារណៈ និងឯកជន។

វាអាចមានសេណារីយ៉ូនៃកម្មវិធីជាច្រើន ហើយដូចដែលអ្នកបានឃើញ វាមិនពិបាកទាល់តែសោះ។

សាកល្បង ព្យាយាមពង្រីកស្គ្រីបរបស់អ្នក។ លើសពីនេះទៅទៀតឧស្សាហកម្មបច្ចេកវិទ្យា blockchain អាចកើនឡើងជិតដប់ដងនៅឆ្នាំ 2024.

ប្រភព: www.habr.com