Web3 ಬಳಸಿಕೊಂಡು JPMorgan Quorum blockchain ನಲ್ಲಿ ಸಾರ್ವಜನಿಕ ಮತ್ತು ಖಾಸಗಿ ವಹಿವಾಟುಗಳನ್ನು ನಿರ್ವಹಿಸಿ

ಕೋರಮ್ ಜೆಪಿ ಮೋರ್ಗಾನ್ ಅಭಿವೃದ್ಧಿಪಡಿಸಿದ ಎಥೆರಿಯಮ್-ಆಧಾರಿತ ಬ್ಲಾಕ್‌ಚೈನ್ ಆಗಿದೆ ಮತ್ತು ಇತ್ತೀಚೆಗೆ ಮೈಕ್ರೋಸಾಫ್ಟ್ ಅಜುರೆ ನೀಡುವ ಮೊದಲ ವಿತರಿಸಿದ ಲೆಡ್ಜರ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಆಗಿದೆ.

ಕೋರಂ ಖಾಸಗಿ ಮತ್ತು ಸಾರ್ವಜನಿಕ ವಹಿವಾಟುಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ ಮತ್ತು ಅನೇಕ ವಾಣಿಜ್ಯ ಬಳಕೆಯ ಪ್ರಕರಣಗಳನ್ನು ಹೊಂದಿದೆ.

ಈ ಲೇಖನದಲ್ಲಿ, ನಾವು ಅಂತಹ ಒಂದು ಸನ್ನಿವೇಶವನ್ನು ಪರಿಶೀಲಿಸುತ್ತೇವೆ - ಗೋದಾಮಿನ ತಾಪಮಾನದ ಬಗ್ಗೆ ನವೀಕೃತ ಮಾಹಿತಿಯನ್ನು ಒದಗಿಸಲು ಸೂಪರ್ಮಾರ್ಕೆಟ್ ಮತ್ತು ಗೋದಾಮಿನ ಮಾಲೀಕರ ನಡುವೆ ವಿತರಿಸಲಾದ ಲೆಡ್ಜರ್ ನೆಟ್ವರ್ಕ್ನ ನಿಯೋಜನೆ.

ಈ ಟ್ಯುಟೋರಿಯಲ್ ನಲ್ಲಿ ಬಳಸಲಾದ ಕೋಡ್ ನಲ್ಲಿದೆ 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, ಇದನ್ನು ABI ಫಾರ್ಮ್ಯಾಟ್ ಮತ್ತು ಬೈಟ್‌ಕೋಡ್‌ಗೆ ಅನುವಾದಿಸಬೇಕು. ಕಾರ್ಯವನ್ನು ಬಳಸುವುದು 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

ಈಗ ಒಪ್ಪಂದವು ಸಿದ್ಧವಾಗಿದೆ, ನಾವು ನೆಟ್ವರ್ಕ್ ಅನ್ನು ನಿಯೋಜಿಸುತ್ತೇವೆ ಮತ್ತು ಒಪ್ಪಂದವನ್ನು ನಿಯೋಜಿಸುತ್ತೇವೆ.

ನೋಡ್ ನಿಯೋಜನೆ

ನೋಡ್ ಅನ್ನು ನಿಯೋಜಿಸುವುದು ಸಾಕಷ್ಟು ಕಾರ್ಮಿಕ-ತೀವ್ರವಾಗಿರುತ್ತದೆ ಮತ್ತು ಸೇವೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಈ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಬದಲಾಯಿಸಬಹುದು ಚೈನ್ಸ್ಟಾಕ್.

ರಾಫ್ಟ್ ಒಮ್ಮತ ಮತ್ತು ಮೂರು ನೋಡ್‌ಗಳೊಂದಿಗೆ ಕೋರಮ್ ನೆಟ್‌ವರ್ಕ್ ಅನ್ನು ನಿಯೋಜಿಸುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಕೆಳಗೆ ನೀಡಲಾಗಿದೆ.

ಮೊದಲಿಗೆ, ನಾವು ಯೋಜನೆಯನ್ನು ರಚಿಸೋಣ ಮತ್ತು ಅದನ್ನು ಕೋರಮ್ ಪ್ರಾಜೆಕ್ಟ್ ಎಂದು ಕರೆಯೋಣ:

Google ಕ್ಲೌಡ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ನಲ್ಲಿ ರಾಫ್ಟ್ ಒಮ್ಮತದೊಂದಿಗೆ ಕೋರಮ್ ನೆಟ್‌ವರ್ಕ್ ಅನ್ನು ರಚಿಸೋಣ:

ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಈಗಾಗಲೇ ರಚಿಸಲಾದ ನೋಡ್‌ಗೆ ಇನ್ನೂ ಎರಡು ನೋಡ್‌ಗಳನ್ನು ಸೇರಿಸೋಣ:

ಮೂರು ಚಾಲನೆಯಲ್ಲಿರುವ ನೋಡ್‌ಗಳು:

ನೋಡ್ ವಿವರಗಳ ಪುಟವು 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 ಭಾಗವಹಿಸುವವರಿಂದ ಮಾರಾಟಗಾರ.

ನೀವು ನೋಡುವಂತೆ, ಎರಡೂ ವಹಿವಾಟುಗಳು ಪೂರ್ಣಗೊಂಡಿವೆ, ಆದರೆ ಭಾಗವಹಿಸುವವರ ವಹಿವಾಟು ಮಾತ್ರ ಮಾರಾಟಗಾರ ಒಪ್ಪಂದದಲ್ಲಿ ತಾಪಮಾನವನ್ನು ನವೀಕರಿಸಲಾಗಿದೆ. ಹೀಗಾಗಿ, ಖಾಸಗಿ ವಹಿವಾಟುಗಳು ಅಸ್ಥಿರತೆಯನ್ನು ಒದಗಿಸುತ್ತವೆ, ಆದರೆ ಅದೇ ಸಮಯದಲ್ಲಿ ಮೂರನೇ ವ್ಯಕ್ತಿಗೆ ಡೇಟಾವನ್ನು ಬಹಿರಂಗಪಡಿಸುವುದಿಲ್ಲ.

ತೀರ್ಮಾನಕ್ಕೆ

ಎರಡು ಪಕ್ಷಗಳ ನಡುವೆ ನೆಟ್‌ವರ್ಕ್ ಅನ್ನು ನಿಯೋಜಿಸುವ ಮೂಲಕ ಗೋದಾಮಿನಲ್ಲಿ ನವೀಕೃತ ತಾಪಮಾನದ ಮಾಹಿತಿಯನ್ನು ಒದಗಿಸಲು ಕೋರಮ್‌ಗಾಗಿ ನಾವು ವಾಣಿಜ್ಯ ಬಳಕೆಯ ಪ್ರಕರಣವನ್ನು ನೋಡಿದ್ದೇವೆ - ಸೂಪರ್‌ಮಾರ್ಕೆಟ್ ಮತ್ತು ಗೋದಾಮಿನ ಮಾಲೀಕರು.

ಸಾರ್ವಜನಿಕ ಮತ್ತು ಖಾಸಗಿ ವಹಿವಾಟುಗಳ ಮೂಲಕ ಹೇಗೆ ನವೀಕೃತ ತಾಪಮಾನದ ಮಾಹಿತಿಯನ್ನು ನಿರ್ವಹಿಸಬಹುದು ಎಂಬುದನ್ನು ನಾವು ತೋರಿಸಿದ್ದೇವೆ.

ಸಾಕಷ್ಟು ಅಪ್ಲಿಕೇಶನ್ ಸನ್ನಿವೇಶಗಳು ಇರಬಹುದು ಮತ್ತು, ನೀವು ನೋಡುವಂತೆ, ಇದು ಕಷ್ಟಕರವಲ್ಲ.

ಪ್ರಯೋಗ, ನಿಮ್ಮ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ವಿಸ್ತರಿಸಲು ಪ್ರಯತ್ನಿಸಿ. ಇದಲ್ಲದೆ, ಬ್ಲಾಕ್ಚೈನ್ ತಂತ್ರಜ್ಞಾನ ಉದ್ಯಮ 2024 ರ ವೇಳೆಗೆ ಸುಮಾರು ಹತ್ತು ಪಟ್ಟು ಬೆಳೆಯಬಹುದು.

ಮೂಲ: www.habr.com