Web3 નો ઉપયોગ કરીને JPMorgan Quorum બ્લોકચેન પર જાહેર અને ખાનગી વ્યવહારો કરો

કોરમ જેપીમોર્ગન દ્વારા વિકસાવવામાં આવેલ ઇથેરિયમ-આધારિત બ્લોકચેન છે અને તાજેતરમાં માઇક્રોસોફ્ટ એઝ્યુર દ્વારા ઓફર કરવામાં આવતું પ્રથમ વિતરિત લેજર પ્લેટફોર્મ બન્યું છે.

કોરમ ખાનગી અને જાહેર વ્યવહારોને સમર્થન આપે છે અને તેમાં ઘણા વ્યવસાયિક ઉપયોગના કેસ છે.

આ લેખમાં, અમે આવા એક દૃશ્યની તપાસ કરીશું - વેરહાઉસના તાપમાન વિશે અપ-ટૂ-ડેટ માહિતી પ્રદાન કરવા માટે સુપરમાર્કેટ અને વેરહાઉસ માલિક વચ્ચે વિતરિત ખાતાવહી નેટવર્કની જમાવટ.

આ ટ્યુટોરીયલમાં વપરાયેલ કોડ છે 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;
  });
}

હવે આપણે દોડી શકીએ છીએ ખાનગી.જેએસ નીચેના પરિણામો સાથે:

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