🥇Izvajanje javnih in zasebnih transakcij v verigi blokov JPMorgan Quorum z uporabo Web3

Sklepčnost je veriga blokov, ki temelji na Ethereumu, ki jo je razvil JPMorgan in je nedavno postala prva platforma za porazdeljeno knjigo, ki jo ponuja Microsoft Azure.

Quorum podpira zasebne in javne transakcije in ima veliko primerov komercialne uporabe.

V tem članku bomo preučili enega od takih scenarijev – uvedbo omrežja porazdeljene knjige med supermarketom in lastnikom skladišča za zagotavljanje posodobljenih informacij o temperaturi v skladišču.

Koda, uporabljena v tej vadnici, je v repozitorije na GitHubu.

Članek zajema:

izdelava pametne pogodbe;
postavitev omrežja Quorum z uporabo Verižni nabor;
Sklepčne javne transakcije;
Kvorumske zasebne transakcije.

Za ponazoritev uporabimo scenarij za spremljanje temperature v skladiščih članov omrežja Quorum znotraj interneta stvari (IoT).

Kontekst

Skupina skladiščnih podjetij se združuje v konzorcij za skupno shranjevanje informacij in avtomatizacijo procesov v blockchainu. Za to so se podjetja odločila uporabiti Quorum. V tem članku bomo obravnavali dva scenarija: javne transakcije in zasebne transakcije.

Transakcije ustvarijo različni udeleženci za interakcijo s konzorcijem, ki mu pripadajo. Vsaka transakcija bodisi uvede pogodbo bodisi pokliče funkcijo v pogodbi za nalaganje podatkov v omrežje. Ta dejanja se ponovijo na vsa vozlišča v omrežju.

Javni posli so na vpogled vsem udeležencem konzorcija. Zasebne transakcije dodajo raven zaupnosti in so na voljo samo tistim udeležencem, ki imajo za to pravico.

Za oba scenarija uporabljamo isto pogodbo zaradi jasnosti.

Pametna pogodba

Spodaj je preprosta pametna pogodba, ustvarjena za naš scenarij. Ima javno spremenljivko temperature, ki ga lahko spremenite z uporabo set in prejemanje po metodi 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;
  }
}

Da bi pogodba delovala s web3.js, mora biti preveden v format ABI in bajtno kodo. Uporaba funkcije formatContractspodaj sestavi pogodbo z uporabo solc-js.

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

Izpolnjena pogodba izgleda takole:

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

Zdaj, ko je pogodba pripravljena, bomo postavili omrežje in postavili pogodbo.

Razmestitev vozlišča

Namestitev vozlišča je lahko precej delovno intenzivna in ta postopek je mogoče nadomestiti z uporabo storitve Verižni nabor.

Spodaj je postopek za uvajanje omrežja Quorum s soglasjem Raft in tremi vozlišči.

Najprej ustvarimo projekt in ga poimenujmo Quorum Project:

Ustvarimo omrežje Quorum s soglasjem Raft na Google Cloud Platform:

Dodajmo še dve vozlišči vozlišču, ki je že privzeto ustvarjeno:

Tri tekoča vozlišča:

Stran s podrobnostmi o vozlišču prikazuje končno točko RPC, javni ključ itd.

Omrežje je razporejeno. Zdaj pa uvedimo pametne pogodbe in izvajajmo transakcije z uporabo web3.js.

Javne transakcije

Kontekst

Skladiščna temperatura je zelo pomembna pri zniževanju stroškov, še posebej pri izdelkih, namenjenih skladiščenju pri temperaturah pod ničlo.

Z omogočanjem podjetjem, da izmenjujejo zunanjo temperaturo svoje geografske lokacije v realnem času in jo beležijo v nespremenljivi knjigi, udeleženci omrežja zmanjšajo stroške in čas.

Opravili bomo tri naloge, prikazane v diagramu:

Pogodbo bomo uvedli prek Vozlišče 1:

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

Nastavite temperaturo prek Vozlišče 2 za 3 stopinje:

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

Vozlišče 3 bo prejel informacije iz pametne pogodbe. Pogodba bo vrnila vrednost 3 stopinje:
```
const temp = await getTemperature(raft3Node, contractAddress);
console.log(‘Retrieved contract Temperature’, temp);
```
Nato si bomo ogledali, kako izvesti javno transakcijo v omrežju Quorum z uporabo web3.js.

Zaženemo instanco prek RPC za tri vozlišča:

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

Razmestimo pametno pogodbo:

// 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 ponuja dva načina za interakcijo s pogodbo: call и send.

Posodobimo pogodbeno temperaturo z izvedbo set z uporabo metode 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;
  });
}

Nato uporabimo metodo web3 call za pridobitev pogodbene temperature. Upoštevajte, da metoda call se izvede na lokalnem vozlišču in transakcija ne bo ustvarjena v verigi blokov.

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

Zdaj lahko tečeš public.js da dobite naslednji rezultat:

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

Nato si lahko ogledamo vnose v raziskovalcu Quorum na plošči Chainstack, kot je prikazano spodaj.

Vsa tri vozlišča so sodelovala in transakcije so bile posodobljene:

Prva transakcija je razveljavila pogodbo.
Druga transakcija je pogodbeno temperaturo nastavila na 3 stopinje.
Temperatura se prejme prek lokalnega vozlišča, tako da se transakcija ne ustvari.

Zasebne transakcije

Kontekst

Pogosta zahteva organizacij je varstvo podatkov. Kot primer razmislite o scenariju, v katerem Supermarket najame skladiščni prostor za skladiščenje morskih sadežev iz ločen Prodajalec:

Prodajalec s senzorji IoT vsakih 30 sekund odčita vrednosti temperature in jih posreduje V supermarket;
te vrednosti bi morale biti na voljo samo Do prodajalca и V supermarket, ki jih povezuje konzorcij.

Opravili bomo štiri naloge, prikazane v zgornjem diagramu.

Za prikaz zasebnih transakcij uporabljamo ista tri vozlišča iz prejšnjega scenarija:
Supermarket uvede pametno pogodbo, ki je zasebna za Supermarket и Prodajalec.
Tretja stran nima pravice dostopa do pametne pogodbe.

Poklicali bomo metode get и set v imenu Supermarket и Prodajalec za prikaz zasebne transakcije kvoruma.

Za udeležence bomo sklenili zasebno pogodbo Supermarket и Prodajalec prek udeleženca Supermarket:

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

Nastavimo temperaturo od Tretja oseba (zunanje vozlišče) in dobite vrednost temperature:

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

Nastavimo temperaturo od Prodajalec (notranje vozlišče) in dobite vrednost temperature:

Temperatura v tem scenariju bi morala iz pametne pogodbe vrniti vrednost 12. Upoštevajte to Prodajalec tukaj ima pooblaščen dostop do pametne pogodbe.

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

Temperaturo dobimo iz Tretja oseba (zunanje vozlišče):

V 3. koraku je bila temperatura nastavljena na 12, vendar Tretja stran nima dostopa do pametne pogodbe. Zato mora biti vrnjena vrednost ničelna.
```
// This returns null
const temp3 = await getTemperature(raft3Node, contractAddress);
console.log(`[Node3] temp retrieved from external nodes after update ${temp}`);
```
Nato si bomo podrobneje ogledali izvajanje zasebnih transakcij v omrežju Quorum z web3.js. Ker je večina kode enaka za javne transakcije, bomo izpostavili le tiste dele, ki se razlikujejo za zasebne transakcije.

Upoštevajte, da je pogodba, naložena v omrežje, nespremenljiva, zato je treba dovoljen dostop odobriti ustreznim vozliščem, tako da omogočite javno pogodbo v času, ko je pogodba uvedena, in ne pozneje.

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

Zasebne transakcije se izvajajo na podoben način – z vključitvijo javnega ključa udeležencev v času izvedbe.

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

Zdaj lahko tečemo private.js z naslednjimi rezultati:

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

Raziskovalec Quorum v Chainstacku bo pokazal naslednje:

razporeditev pogodbe s strani udeleženca Supermarket;
Izpolnitev SetTemperature od Tretja oseba;
Izpolnitev SetTemperature od udeleženca Prodajalec.

Kot lahko vidite, sta zaključeni obe transakciji, vendar samo transakcija udeleženca Prodajalec posodobil temperaturo v pogodbi. Zasebne transakcije torej zagotavljajo nespremenljivost, a hkrati ne razkrivajo podatkov tretji osebi.

Zaključek

Preučili smo primer komercialne uporabe za Quorum za zagotavljanje posodobljenih informacij o temperaturi v skladišču z vzpostavitvijo omrežja med dvema stranema – supermarketom in lastnikom skladišča.

Pokazali smo, kako je mogoče vzdrževati posodobljene informacije o temperaturi z javnimi in zasebnimi transakcijami.

Scenarijev uporabe je lahko veliko in, kot vidite, sploh ni težko.

Eksperimentirajte, poskusite razširiti svoj scenarij. Še več, tehnološka industrija blockchain bi se lahko do leta 2024 skoraj podeseterila.

Vir: www.habr.com

Izvajajte javne in zasebne transakcije v verigi blokov JPMorgan Quorum z uporabo Web3

Kontekst

Pametna pogodba

Razmestitev vozlišča

Javne transakcije

Kontekst

Zasebne transakcije

Kontekst

Zaključek

Dodaj komentar Prekliči odgovor