ເຮັດທຸລະກໍາສາທາລະນະແລະເອກະຊົນໃນ JPMorgan Quorum blockchain ໂດຍໃຊ້ Web3

ກຸ່ມ ເປັນ blockchain ທີ່ອີງໃສ່ Ethereum ພັດທະນາໂດຍ JPMorgan ແລະບໍ່ດົນມານີ້ໄດ້ກາຍເປັນແພລະຕະຟອມບັນຊີລາຍການທໍາອິດທີ່ແຈກຢາຍໂດຍ Microsoft Azure.

Quorum ສະຫນັບສະຫນູນການເຮັດທຸລະກໍາເອກະຊົນແລະສາທາລະນະແລະມີກໍລະນີການນໍາໃຊ້ທາງການຄ້າຫຼາຍ.

ໃນບົດຄວາມນີ້, ພວກເຮົາຈະພິຈາລະນາສະຖານະການດັ່ງກ່າວ - ການໃຊ້ເຄືອຂ່າຍບັນຊີລາຍການທີ່ແຈກຢາຍລະຫວ່າງຮ້ານສັບພະສິນຄ້າແລະເຈົ້າຂອງສາງເພື່ອໃຫ້ຂໍ້ມູນທີ່ທັນສະໄຫມກ່ຽວກັບອຸນຫະພູມຂອງສາງ.

ລະຫັດທີ່ໃຊ້ໃນການສອນນີ້ແມ່ນຢູ່ໃນ repositories ໃນ GitHub.

ບົດຄວາມກວມເອົາ:

• ການສ້າງສັນຍາສະຫມາດ;
• ການນຳໃຊ້ເຄືອຂ່າຍຂອງກຸ່ມໂຄຣຳໂດຍໃຊ້ ຕ່ອງໂສ້;
• ການເຮັດທຸລະກໍາສາທາລະນະຂອງກຸ່ມ;
• ທຸລະກຳສ່ວນຕົວຂອງກຸ່ມ.

ເພື່ອສະແດງໃຫ້ເຫັນ, ພວກເຮົາໃຊ້ສະຖານະການຕິດຕາມອຸນຫະພູມໃນສາງຂອງສະມາຊິກຂອງເຄືອຂ່າຍ Quorum ພາຍໃນອິນເຕີເນັດຂອງສິ່ງຕ່າງໆ (IoT).

ສະພາບການ

ກຸ່ມບໍລິສັດສາງສິນຄ້າກຳລັງຮວມຕົວກັນຢູ່ໃນກຸ່ມບໍລິສັດເພື່ອຮ່ວມກັນເກັບຂໍ້ມູນ ແລະຂະບວນການອັດຕະໂນມັດໃນ blockchain. ສໍາລັບການນີ້, ບໍລິສັດໄດ້ຕັດສິນໃຈໃຊ້ Quorum. ໃນບົດຄວາມນີ້ພວກເຮົາຈະກວມເອົາສອງສະຖານະການ: ການເຮັດທຸລະກໍາສາທາລະນະແລະການເຮັດທຸລະກໍາສ່ວນຕົວ.

ທຸລະກໍາແມ່ນສ້າງຂຶ້ນໂດຍຜູ້ເຂົ້າຮ່ວມທີ່ແຕກຕ່າງກັນເພື່ອພົວພັນກັບກຸ່ມທີ່ເຂົາເຈົ້າຂຶ້ນກັບ. ແຕ່ລະທຸລະກໍາຈະປະຕິບັດສັນຍາຫຼືໂທຫາຫນ້າທີ່ໃນສັນຍາເພື່ອອັບໂຫລດຂໍ້ມູນໃສ່ເຄືອຂ່າຍ. ການກະທຳເຫຼົ່ານີ້ຖືກຈຳລອງກັບທຸກ nodes ໃນເຄືອຂ່າຍ.

ທຸລະກໍາສາທາລະນະແມ່ນມີໃຫ້ສໍາລັບການເບິ່ງໂດຍຜູ້ເຂົ້າຮ່ວມສະມາຄົມທັງຫມົດ. ການເຮັດທຸລະກໍາສ່ວນຕົວເພີ່ມຊັ້ນຂອງຄວາມລັບແລະມີໃຫ້ພຽງແຕ່ຜູ້ເຂົ້າຮ່ວມຜູ້ທີ່ມີສິດທີ່ຈະເຮັດແນວນັ້ນ.

ສໍາລັບທັງສອງສະຖານະການ, ພວກເຮົາໃຊ້ສັນຍາດຽວກັນເພື່ອຄວາມຊັດເຈນ.

ສັນຍາສະຫມາດ

ຂ້າງລຸ່ມນີ້ແມ່ນສັນຍາສະຫມາດທີ່ງ່າຍດາຍທີ່ສ້າງຂຶ້ນສໍາລັບສະຖານະການຂອງພວກເຮົາ. ມັນມີຕົວແປສາທາລະນະ 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;
  }
}

ເພື່ອໃຫ້ສັນຍາເຮັດວຽກກັບ web3.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

ໃນປັດຈຸບັນສັນຍາແມ່ນກຽມພ້ອມ, ພວກເຮົາຈະນໍາໃຊ້ເຄືອຂ່າຍແລະປະຕິບັດສັນຍາ.

ການນຳໃຊ້ໂນດ

ການຕິດຕັ້ງ node ສາມາດຂ້ອນຂ້າງໃຊ້ແຮງງານຫຼາຍແລະຂະບວນການນີ້ສາມາດຖືກທົດແທນໂດຍການບໍລິການ ຕ່ອງໂສ້.

ຂ້າງລຸ່ມນີ້ແມ່ນຂະບວນການສໍາລັບການນໍາໃຊ້ເຄືອຂ່າຍ Quorum ທີ່ມີ Raft consensus ແລະສາມ nodes.

ກ່ອນອື່ນ, ໃຫ້ພວກເຮົາສ້າງໂຄງການແລະໂທຫາມັນໂຄງການ Quorum:

ມາສ້າງເຄືອຂ່າຍ Quorum ກັບ Raft consensus ໃນ Google Cloud Platform:

ຂໍໃຫ້ເພີ່ມສອງໂຫນດເພີ່ມເຕີມໃສ່ໂຫນດທີ່ສ້າງແລ້ວໂດຍຄ່າເລີ່ມຕົ້ນ:

ສາມ nodes ແລ່ນ:

ຫນ້າລາຍລະອຽດຂອງ node ສະແດງໃຫ້ເຫັນຈຸດສິ້ນສຸດ RPC, ລະຫັດສາທາລະນະ, ແລະອື່ນໆ.

ເຄືອຂ່າຍຖືກນຳໃຊ້. ຕອນນີ້ໃຫ້ນຳໃຊ້ສັນຍາສະຫມາດ ແລະເຮັດທຸລະກຳໂດຍໃຊ້ web3.js.

ທຸລະກໍາສາທາລະນະ

ສະພາບການ

ອຸນຫະພູມໃນສາງແມ່ນມີຄວາມສໍາຄັນຫຼາຍໃນການຫຼຸດຜ່ອນຄ່າໃຊ້ຈ່າຍ, ໂດຍສະເພາະແມ່ນຜະລິດຕະພັນທີ່ມີຈຸດປະສົງເພື່ອເກັບຮັກສາໄວ້ໃນອຸນຫະພູມຍ່ອຍສູນ.

ໂດຍການອະນຸຍາດໃຫ້ບໍລິສັດແບ່ງປັນອຸນຫະພູມພາຍນອກຂອງສະຖານທີ່ຕັ້ງພູມສາດຂອງເຂົາເຈົ້າໃນເວລາທີ່ແທ້ຈິງແລະບັນທຶກມັນຢູ່ໃນບັນຊີລາຍການທີ່ບໍ່ປ່ຽນແປງໄດ້, ຜູ້ເຂົ້າຮ່ວມເຄືອຂ່າຍຫຼຸດຜ່ອນຄ່າໃຊ້ຈ່າຍແລະເວລາ.

ພວກເຮົາຈະປະຕິບັດວຽກງານສາມຢ່າງ, ສະແດງຢູ່ໃນແຜນວາດ:

1. ພວກເຮົາຈະປະຕິບັດສັນຍາໂດຍຜ່ານ Node 1:

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

2. ຕັ້ງອຸນຫະພູມຜ່ານ Node 2 ໂດຍ 3 ອົງສາ:

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

3. Node 3 ຈະໄດ້ຮັບຂໍ້ມູນຈາກສັນຍາສະຫມາດ. ສັນຍາຈະສົ່ງຄືນຄ່າ 3 ອົງສາ:

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

   ຕໍ່ໄປ, ພວກເຮົາຈະເບິ່ງວິທີການດໍາເນີນທຸລະກໍາສາທາລະນະໃນເຄືອຂ່າຍ Quorum ໂດຍໃຊ້ web3.js.

ພວກເຮົາເລີ່ມຕົ້ນຕົວຢ່າງຜ່ານ RPC ສໍາລັບສາມ nodes:

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

web3.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 ຖືກປະຕິບັດຢູ່ໃນ node ທ້ອງຖິ່ນແລະທຸລະກໍາຈະບໍ່ຖືກສ້າງຂື້ນໃນ 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, ດັ່ງທີ່ສະແດງຂ້າງລຸ່ມນີ້.

ທັງສາມ nodes ໂຕ້ຕອບກັນແລະທຸລະກໍາໄດ້ຖືກປັບປຸງ:

1. ທຸລະກໍາທໍາອິດໄດ້ນໍາໃຊ້ສັນຍາ.
2. ການເຮັດທຸລະກໍາທີສອງກໍານົດອຸນຫະພູມສັນຍາເປັນ 3 ອົງສາ.
3. ອຸນຫະພູມແມ່ນໄດ້ຮັບໂດຍຜ່ານ node ທ້ອງຖິ່ນ, ດັ່ງນັ້ນບໍ່ມີການສ້າງທຸລະກໍາ.

ທຸລະກໍາສ່ວນຕົວ

ສະພາບການ

ຄວາມຕ້ອງການທົ່ວໄປຂອງອົງການຈັດຕັ້ງແມ່ນການປົກປ້ອງຂໍ້ມູນ. ສໍາລັບຕົວຢ່າງ, ພິຈາລະນາສະຖານະການໃດຫນຶ່ງ ສັບພະສິນຄ້າ ເຊົ່າພື້ນທີ່ສາງສໍາລັບການເກັບຮັກສາອາຫານທະເລຈາກແຍກຕ່າງຫາກ ຜູ້ຂາຍ:

• ຜູ້ຂາຍ ການນໍາໃຊ້ເຊັນເຊີ 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, ແຕ່ ດ້ານທີສາມ ບໍ່ມີການເຂົ້າເຖິງສັນຍາສະຫມາດ. ດັ່ງນັ້ນຄ່າກັບຄືນຕ້ອງເປັນ null.

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

   ຕໍ່ໄປ, ພວກເຮົາຈະພິຈາລະນາຢ່າງໃກ້ຊິດໃນການປະຕິບັດທຸລະກໍາສ່ວນຕົວໃນເຄືອຂ່າຍ Quorum ກັບ web3.js. ເນື່ອງຈາກລະຫັດສ່ວນໃຫຍ່ແມ່ນຄືກັນສໍາລັບການເຮັດທຸລະກໍາສາທາລະນະ, ພວກເຮົາຈະເນັ້ນໃສ່ພຽງແຕ່ສ່ວນທີ່ແຕກຕ່າງສໍາລັບການເຮັດທຸລະກໍາສ່ວນຕົວ.

ຈົ່ງຈື່ໄວ້ວ່າສັນຍາທີ່ອັບໂຫລດໄປຍັງເຄືອຂ່າຍແມ່ນບໍ່ສາມາດປ່ຽນແປງໄດ້, ດັ່ງນັ້ນການເຂົ້າເຖິງການອະນຸຍາດຕ້ອງໄດ້ຮັບການອະນຸຍາດໃຫ້ກັບ nodes ທີ່ເຫມາະສົມໂດຍການເປີດໃຊ້ສັນຍາສາທາລະນະໃນເວລາທີ່ສັນຍາຖືກນໍາໃຊ້, ບໍ່ແມ່ນຫຼັງຈາກນັ້ນ.

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

Quorum explorer ໃນ Chainstack ຈະສະແດງດັ່ງຕໍ່ໄປນີ້:

• ການປະຕິບັດສັນຍາຈາກຜູ້ເຂົ້າຮ່ວມ ສັບພະສິນຄ້າ;
• ການປະຕິບັດ SetTemperature ຈາກ ບຸກ​ຄົນ​ທີ່​ສາມ;
• ການປະຕິບັດ SetTemperature ຈາກ​ຜູ້​ເຂົ້າ​ຮ່ວມ ຜູ້ຂາຍ.

ດັ່ງທີ່ເຈົ້າສາມາດເຫັນໄດ້, ການເຮັດທຸລະກໍາທັງສອງແມ່ນສໍາເລັດ, ແຕ່ວ່າພຽງແຕ່ການເຮັດທຸລະກໍາຈາກຜູ້ເຂົ້າຮ່ວມ ຜູ້ຂາຍ ປັບປຸງອຸນຫະພູມໃນສັນຍາ. ດັ່ງນັ້ນ, ການເຮັດທຸລະກໍາສ່ວນຕົວສະຫນອງຄວາມບໍ່ປ່ຽນແປງ, ແຕ່ໃນເວລາດຽວກັນບໍ່ໄດ້ເປີດເຜີຍຂໍ້ມູນໃຫ້ກັບບຸກຄົນທີສາມ.

ສະຫລຸບ

ພວກເຮົາໄດ້ເບິ່ງກໍລະນີການນໍາໃຊ້ທາງການຄ້າສໍາລັບ Quorum ເພື່ອສະຫນອງຂໍ້ມູນອຸນຫະພູມທີ່ທັນສະໄຫມຢູ່ໃນສາງໂດຍການນໍາໃຊ້ເຄືອຂ່າຍລະຫວ່າງສອງພາກສ່ວນ - ສັບພະສິນຄ້າແລະເຈົ້າຂອງສາງ.

ພວກເຮົາໄດ້ສະແດງວິທີການຮັກສາຂໍ້ມູນອຸນຫະພູມທີ່ທັນສະ ໄໝ ໂດຍຜ່ານການເຮັດທຸລະ ກຳ ທັງພາກລັດແລະເອກະຊົນ.

ມັນສາມາດມີຫຼາຍສະຖານະການຄໍາຮ້ອງສະຫມັກແລະ, ຕາມທີ່ທ່ານສາມາດເບິ່ງ, ມັນບໍ່ແມ່ນມີຄວາມຫຍຸ້ງຍາກທັງຫມົດ.

ທົດລອງ, ພະຍາຍາມຂະຫຍາຍ script ຂອງທ່ານ. ຍິ່ງໄປກວ່ານັ້ນ, ອຸດສາຫະກໍາເທກໂນໂລຍີ blockchain ອາດ​ຈະ​ເພີ່ມ​ຂຶ້ນ​ເກືອບ​ສິບ​ເທົ່າ​ໃນ​ປີ 2024.

ແຫຼ່ງຂໍ້ມູນ: www.habr.com