Web3 ഉപയോഗിച്ച് JP Morgan Quorum ബ്ലോക്ക്ചെയിനിൽ പൊതു, സ്വകാര്യ ഇടപാടുകൾ നടത്തുക

Quorum ജെപി മോർഗൻ വികസിപ്പിച്ച Ethereum അധിഷ്‌ഠിത ബ്ലോക്ക്‌ചെയിൻ ആണ്, അടുത്തിടെ മൈക്രോസോഫ്റ്റ് അസൂർ വാഗ്ദാനം ചെയ്യുന്ന ആദ്യത്തെ വിതരണം ചെയ്ത ലെഡ്ജർ പ്ലാറ്റ്‌ഫോമായി മാറി.

കോറം സ്വകാര്യവും പൊതുവുമായ ഇടപാടുകളെ പിന്തുണയ്ക്കുന്നു കൂടാതെ നിരവധി വാണിജ്യ ഉപയോഗ കേസുകളുമുണ്ട്.

ഈ ലേഖനത്തിൽ, അത്തരത്തിലുള്ള ഒരു സാഹചര്യം ഞങ്ങൾ പരിശോധിക്കും - ഒരു സൂപ്പർമാർക്കറ്റിനും വെയർഹൗസ് ഉടമയ്ക്കും ഇടയിൽ വിതരണം ചെയ്ത ലെഡ്ജർ നെറ്റ്‌വർക്കിന്റെ വിന്യാസം, വെയർഹൗസിന്റെ താപനിലയെക്കുറിച്ചുള്ള കാലികമായ വിവരങ്ങൾ നൽകുന്നതിന്.

ഈ ട്യൂട്ടോറിയലിൽ ഉപയോഗിച്ചിരിക്കുന്ന കോഡ് ആണ് GitHub-ലെ റിപ്പോസിറ്ററികൾ.

ലേഖനം ഉൾക്കൊള്ളുന്നു:

• ഒരു സ്മാർട്ട് കരാർ സൃഷ്ടിക്കൽ;
• ഉപയോഗിക്കുന്ന കോറം നെറ്റ്‌വർക്കിന്റെ വിന്യാസം ചെയിൻസ്റ്റാക്ക്;
• കോറം പൊതു ഇടപാടുകൾ;
• ക്വാറം സ്വകാര്യ ഇടപാടുകൾ.

ദൃഷ്ടാന്തീകരിക്കുന്നതിന്, ഇന്റർനെറ്റ് ഓഫ് തിംഗ്‌സിലെ (IoT) കോറം നെറ്റ്‌വർക്കിലെ അംഗങ്ങളുടെ വെയർഹൗസുകളിലെ താപനില നിരീക്ഷിക്കുന്നതിന് ഞങ്ങൾ ഒരു സാഹചര്യം ഉപയോഗിക്കുന്നു.

സന്ദർഭം

ബ്ലോക്ക്ചെയിനിൽ വിവരങ്ങൾ സംഭരിക്കാനും പ്രക്രിയകൾ ഓട്ടോമേറ്റ് ചെയ്യാനും ഒരു കൂട്ടം വെയർഹൗസ് കമ്പനികൾ ഒരു കൺസോർഷ്യത്തിൽ ഒന്നിക്കുന്നു. ഇതിനായി കമ്പനികൾ ക്വാറം ഉപയോഗിക്കാൻ തീരുമാനിച്ചു. ഈ ലേഖനത്തിൽ ഞങ്ങൾ രണ്ട് സാഹചര്യങ്ങൾ ഉൾക്കൊള്ളുന്നു: പൊതു ഇടപാടുകളും സ്വകാര്യ ഇടപാടുകളും.

വിവിധ പങ്കാളികൾ അവർ ഉൾപ്പെടുന്ന കൺസോർഷ്യവുമായി സംവദിക്കാൻ ഇടപാടുകൾ സൃഷ്ടിക്കുന്നു. ഓരോ ഇടപാടും ഒന്നുകിൽ ഒരു കരാർ വിന്യസിക്കുന്നു അല്ലെങ്കിൽ നെറ്റ്‌വർക്കിലേക്ക് ഡാറ്റ അപ്‌ലോഡ് ചെയ്യുന്നതിന് കരാറിലെ ഒരു ഫംഗ്‌ഷൻ വിളിക്കുന്നു. ഈ പ്രവർത്തനങ്ങൾ നെറ്റ്‌വർക്കിലെ എല്ലാ നോഡുകളിലേക്കും ആവർത്തിക്കുന്നു.

എല്ലാ കൺസോർഷ്യം പങ്കാളികൾക്കും കാണുന്നതിന് പൊതു ഇടപാടുകൾ ലഭ്യമാണ്. സ്വകാര്യ ഇടപാടുകൾ രഹസ്യാത്മകതയുടെ ഒരു പാളി ചേർക്കുന്നു, അങ്ങനെ ചെയ്യാൻ അവകാശമുള്ള പങ്കാളികൾക്ക് മാത്രമേ അത് ലഭ്യമാകൂ.

രണ്ട് സാഹചര്യങ്ങൾക്കും, വ്യക്തതയ്ക്കായി ഞങ്ങൾ ഒരേ കരാർ ഉപയോഗിക്കുന്നു.

സ്മാർട്ട് കരാർ

ഞങ്ങളുടെ സാഹചര്യത്തിനായി സൃഷ്‌ടിച്ച ഒരു ലളിതമായ സ്‌മാർട്ട് കരാർ ചുവടെയുണ്ട്. ഇതിന് ഒരു പൊതു വേരിയബിൾ ഉണ്ട് 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, ഇത് എബിഐ ഫോർമാറ്റിലേക്കും ബൈറ്റ്കോഡിലേക്കും വിവർത്തനം ചെയ്യണം. ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു 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

ഇപ്പോൾ കരാർ തയ്യാറാണ്, ഞങ്ങൾ നെറ്റ്‌വർക്ക് വിന്യസിക്കുകയും കരാർ വിന്യസിക്കുകയും ചെയ്യും.

നോഡ് വിന്യാസം

ഒരു നോഡ് വിന്യസിക്കുന്നത് തികച്ചും അധ്വാനമാണ്, ഒരു സേവനം ഉപയോഗിച്ച് ഈ പ്രക്രിയ മാറ്റിസ്ഥാപിക്കാനാകും ചെയിൻസ്റ്റാക്ക്.

റാഫ്റ്റ് സമവായവും മൂന്ന് നോഡുകളും ഉപയോഗിച്ച് കോറം നെറ്റ്‌വർക്ക് വിന്യസിക്കുന്നതിനുള്ള പ്രക്രിയ ചുവടെയുണ്ട്.

ആദ്യം, നമുക്ക് ഒരു പ്രോജക്റ്റ് സൃഷ്ടിച്ച് അതിനെ കോറം പ്രോജക്റ്റ് എന്ന് വിളിക്കാം:

ഗൂഗിൾ ക്ലൗഡ് പ്ലാറ്റ്‌ഫോമിൽ റാഫ്റ്റ് സമവായത്തോടെ നമുക്ക് ഒരു ക്വാറം നെറ്റ്‌വർക്ക് സൃഷ്‌ടിക്കാം:

സ്ഥിരസ്ഥിതിയായി ഇതിനകം സൃഷ്ടിച്ച നോഡിലേക്ക് രണ്ട് നോഡുകൾ കൂടി ചേർക്കാം:

മൂന്ന് പ്രവർത്തിക്കുന്ന നോഡുകൾ:

നോഡ് വിശദാംശങ്ങളുടെ പേജ് RPC എൻഡ് പോയിന്റ്, പബ്ലിക് കീ മുതലായവ കാണിക്കുന്നു.

നെറ്റ്‌വർക്ക് വിന്യസിച്ചിരിക്കുന്നു. ഇപ്പോൾ നമുക്ക് സ്‌മാർട്ട് കരാറുകൾ വിന്യസിക്കുകയും ഉപയോഗിച്ച് ഇടപാടുകൾ നടത്തുകയും ചെയ്യാം web3.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);

   അടുത്തതായി, കോറം നെറ്റ്‌വർക്കിൽ ഒരു പൊതു ഇടപാട് എങ്ങനെ നടത്താമെന്ന് ഞങ്ങൾ നോക്കാം web3.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;
  });
}

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 ഒരു ലോക്കൽ നോഡിൽ എക്സിക്യൂട്ട് ചെയ്യുന്നു, ഇടപാട് ബ്ലോക്ക്ചെയിനിൽ സൃഷ്ടിക്കപ്പെടില്ല.

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

അടുത്തതായി, താഴെ കാണിച്ചിരിക്കുന്നതുപോലെ ചെയിൻസ്റ്റാക്ക് പാനലിലെ കോറം എക്സ്പ്ലോററിലെ എൻട്രികൾ നമുക്ക് കാണാൻ കഴിയും.

മൂന്ന് നോഡുകളും സംവദിക്കുകയും ഇടപാടുകൾ അപ്‌ഡേറ്റ് ചെയ്യുകയും ചെയ്തു:

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

   അടുത്തതായി, കോറം നെറ്റ്‌വർക്കിൽ സ്വകാര്യ ഇടപാടുകൾ നടത്തുന്നത് ഞങ്ങൾ സൂക്ഷ്മമായി പരിശോധിക്കും web3.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

ചെയിൻസ്റ്റാക്കിലെ കോറം എക്സ്പ്ലോറർ ഇനിപ്പറയുന്നവ കാണിക്കും:

• പങ്കാളിയിൽ നിന്നുള്ള കരാറിന്റെ വിന്യാസം സൂപ്പർമാർക്കറ്റ്;
• നിവൃത്തി SetTemperature от മൂന്നാം പാർട്ടി;
• നിവൃത്തി SetTemperature ഒരു പങ്കാളിയിൽ നിന്ന് വെണ്ടർ.

നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, രണ്ട് ഇടപാടുകളും പൂർത്തിയായി, പക്ഷേ പങ്കാളിയിൽ നിന്നുള്ള ഇടപാട് മാത്രം വെണ്ടർ കരാറിലെ താപനില പുതുക്കി. അങ്ങനെ, സ്വകാര്യ ഇടപാടുകൾ മാറ്റമില്ലാത്തത് നൽകുന്നു, എന്നാൽ അതേ സമയം ഒരു മൂന്നാം കക്ഷിക്ക് ഡാറ്റ വെളിപ്പെടുത്തരുത്.

തീരുമാനം

ഒരു സൂപ്പർമാർക്കറ്റും വെയർഹൗസ് ഉടമയും - രണ്ട് കക്ഷികൾക്കിടയിൽ ഒരു ശൃംഖല വിന്യസിച്ചുകൊണ്ട് ഒരു വെയർഹൗസിൽ കാലികമായ താപനില വിവരങ്ങൾ നൽകുന്നതിന് Quorum-ന്റെ ഒരു വാണിജ്യ ഉപയോഗ കേസ് ഞങ്ങൾ പരിശോധിച്ചു.

പൊതു-സ്വകാര്യ ഇടപാടുകളിലൂടെ താപനില വിവരങ്ങൾ എങ്ങനെ നിലനിർത്താമെന്ന് ഞങ്ങൾ കാണിച്ചുതന്നു.

ധാരാളം ആപ്ലിക്കേഷൻ സാഹചര്യങ്ങൾ ഉണ്ടാകാം, നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, ഇത് ഒട്ടും ബുദ്ധിമുട്ടുള്ള കാര്യമല്ല.

പരീക്ഷണം, നിങ്ങളുടെ സ്ക്രിപ്റ്റ് വികസിപ്പിക്കാൻ ശ്രമിക്കുക. മാത്രമല്ല, ബ്ലോക്ക്ചെയിൻ സാങ്കേതിക വ്യവസായം 2024 ആകുമ്പോഴേക്കും ഏകദേശം പത്തിരട്ടി വളരും.

അവലംബം: www.habr.com