🥇Wykonywanie transakcji publicznych i prywatnych na blockchainie JPMorgan Quorum przy użyciu Web3

Kworum to blockchain oparty na Ethereum opracowany przez JPMorgan i ostatnio stał się pierwszą platformą rozproszonej księgi głównej oferowaną przez Microsoft Azure.

Quorum obsługuje transakcje prywatne i publiczne i ma wiele zastosowań komercyjnych.

W tym artykule przeanalizujemy jeden z takich scenariuszy – wdrożenie rozproszonej sieci księgi głównej pomiędzy supermarketem a właścicielem magazynu w celu dostarczania aktualnych informacji o temperaturze w magazynie.

Kod użyty w tym samouczku znajduje się w repozytoria na GitHubie.

Artykuł obejmuje:

stworzenie inteligentnego kontraktu;
wdrożenie sieci Quorum przy użyciu Stojak łańcuchowy;
Transakcje publiczne z kworum;
Prywatne transakcje kworum.

Dla ilustracji posłużmy się scenariuszem monitorowania temperatury w magazynach członków sieci Quorum w ramach Internetu Rzeczy (IoT).

Kontekst

Grupa firm magazynowych łączy się w konsorcjum, aby wspólnie przechowywać informacje i automatyzować procesy na blockchainie. W tym celu firmy zdecydowały się wykorzystać Quorum. W tym artykule omówimy dwa scenariusze: transakcje publiczne i transakcje prywatne.

Transakcje są tworzone przez różnych uczestników w celu interakcji z konsorcjum, do którego należą. Każda transakcja wdraża kontrakt lub wywołuje funkcję w kontrakcie w celu przesłania danych do sieci. Działania te są replikowane do wszystkich węzłów w sieci.

Transakcje publiczne są dostępne do wglądu dla wszystkich uczestników konsorcjum. Transakcje prywatne dodają warstwę poufności i są dostępne tylko dla tych uczestników, którzy mają do tego uprawnienia.

Dla obu scenariuszy używamy tej samej umowy dla przejrzystości.

Inteligentna umowa

Poniżej znajduje się prosty inteligentny kontrakt stworzony dla naszego scenariusza. Posiada zmienną publiczną temperature, które można zmienić za pomocą set i odbieraj metodą 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;
  }
}

Aby umowa działała web3.js, należy go przetłumaczyć na format ABI i kod bajtowy. Korzystanie z funkcji formatContractponiżej kompiluje umowę za pomocą Solc-js.

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

Gotowa umowa wygląda następująco:

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

Teraz, gdy umowa jest już gotowa, wdrożymy sieć i wdrożymy umowę.

Wdrożenie węzła

Wdrożenie węzła może być dość pracochłonne i proces ten można zastąpić skorzystaniem z usługi Stojak łańcuchowy.

Poniżej znajduje się proces wdrażania sieci Quorum z konsensusem Raft i trzema węzłami.

Najpierw utwórzmy projekt i nazwijmy go Quorum Project:

Stwórzmy sieć Quorum w oparciu o konsensus Raft na Google Cloud Platform:

Dodajmy jeszcze dwa węzły do już utworzonego domyślnie węzła:

Trzy działające węzły:

Strona szczegółów węzła pokazuje punkt końcowy RPC, klucz publiczny itp.

Sieć jest wdrożona. Teraz wdróżmy inteligentne kontrakty i przeprowadzajmy transakcje za pomocą web3.js.

Transakcje publiczne

Kontekst

Temperatura magazynu ma ogromne znaczenie w obniżaniu kosztów, szczególnie w przypadku produktów przeznaczonych do przechowywania w ujemnych temperaturach.

Umożliwiając firmom udostępnianie w czasie rzeczywistym temperatury zewnętrznej ich lokalizacji geograficznej i zapisywanie jej w niezmiennym rejestrze, uczestnicy sieci redukują koszty i czas.

Wykonamy trzy zadania, które przedstawiono na schemacie:

Wdrożymy umowę za pośrednictwem Węzeł 1:

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

Ustawić temperaturę za pomocą Węzeł 2 o 3 stopnie:

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

Węzeł 3 otrzyma informacje z inteligentnego kontraktu. Kontrakt zwróci wartość 3 stopnie:
```
const temp = await getTemperature(raft3Node, contractAddress);
console.log(‘Retrieved contract Temperature’, temp);
```
Następnie przyjrzymy się, jak przeprowadzić transakcję publiczną w sieci Quorum za pomocą web3.js.

Inicjujemy instancję poprzez RPC dla trzech węzłów:

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

Wdróżmy inteligentny kontrakt:

// 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 udostępnia dwie metody interakcji z umową: call и send.

Zaktualizujmy temperaturę kontraktu, wykonując set przy użyciu metody 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;
  });
}

Następnie używamy metody web3 call do uzyskania temperatury kontraktowej. Należy pamiętać, że metoda call jest wykonywana w węźle lokalnym i transakcja nie zostanie utworzona na blockchainie.

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

Teraz możesz biegać public.js aby uzyskać następujący wynik:

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

Następnie możemy wyświetlić wpisy w eksploratorze Quorum w panelu Chainstack, jak pokazano poniżej.

Wszystkie trzy węzły nawiązały interakcję i transakcje zostały zaktualizowane:

Pierwsza transakcja wdrożyła kontrakt.
W drugiej transakcji temperatura kontraktu została ustalona na 3 stopnie.
Temperatura jest odbierana przez węzeł lokalny, więc nie jest tworzona żadna transakcja.

Transakcje prywatne

Kontekst

Powszechnym wymaganiem organizacji jest ochrona danych. Jako przykład rozważmy scenariusz, w którym Supermarket wynajmuje odrębną powierzchnię magazynową do przechowywania owoców morza Sprzedawca:

Sprzedawca za pomocą czujników IoT odczytuje wartości temperatury co 30 sekund i przesyła je Do supermarketu;
wartości te powinny być tylko dostępne Do sprzedawcy и Do supermarketu, połączone w sieć przez konsorcjum.

Wykonamy cztery zadania pokazane na powyższym schemacie.

Używamy tych samych trzech węzłów z poprzedniego scenariusza, aby zademonstrować transakcje prywatne:
Supermarket wdraża inteligentny kontrakt, który jest prywatny Supermarket и Sprzedawca.
Trzecia strona nie ma prawa dostępu do inteligentnej umowy.

Będziemy wywoływać metody get и set w imieniu Supermarket и Sprzedawca aby zademonstrować prywatną transakcję kworum.

Wdrożymy prywatną umowę dla uczestników Supermarket и Sprzedawca poprzez uczestnika Supermarket:

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

Ustawmy temperaturę od Strona trzecia (węzeł zewnętrzny) i uzyskaj wartość temperatury:

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

Ustawmy temperaturę od Sprzedawca (węzeł wewnętrzny) i uzyskaj wartość temperatury:

Temperatura w tym scenariuszu powinna zwrócić z inteligentnego kontraktu wartość 12. Należy o tym pamiętać Sprzedawca tutaj autoryzował dostęp do inteligentnej umowy.

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

Mamy temperaturę z Strona trzecia (węzeł zewnętrzny):

W kroku 3 temperaturę ustawiono na 12, ale Trzecia strona nie ma dostępu do inteligentnej umowy. Dlatego wartość zwracana musi mieć wartość null.
```
// This returns null
const temp3 = await getTemperature(raft3Node, contractAddress);
console.log(`[Node3] temp retrieved from external nodes after update ${temp}`);
```
Następnie przyjrzymy się bliżej wykonywaniu prywatnych transakcji w sieci Quorum web3.js. Ponieważ większość kodu jest taka sama dla transakcji publicznych, wyróżnimy tylko te części, które różnią się dla transakcji prywatnych.

Należy pamiętać, że kontrakt przesłany do sieci jest niezmienny, dlatego należy przyznać odpowiedni dostęp odpowiednim węzłom poprzez włączenie kontraktu publicznego w momencie wdrożenia kontraktu, a nie później.

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

Transakcje prywatne przeprowadza się w podobny sposób – włączając w momencie realizacji klucz publiczny uczestników.

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

Teraz możemy biegać prywatny.js z następującymi wynikami:

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

Eksplorator Quorum w Chainstack wyświetli następujące informacje:

wdrożenie kontraktu od uczestnika Supermarket;
Wydajność SetTemperature od Strona trzecia;
Wydajność SetTemperature od uczestnika Sprzedawca.

Jak widać obie transakcje zostały zrealizowane, ale tylko transakcja od uczestnika Sprzedawca zaktualizowałem temperaturę w umowie. Transakcje prywatne zapewniają zatem niezmienność, ale jednocześnie nie ujawniają danych osobom trzecim.

wniosek

Przyjrzeliśmy się komercyjnemu zastosowaniu Quorum w celu zapewnienia aktualnych informacji o temperaturze w magazynie poprzez wdrożenie sieci pomiędzy dwiema stronami – supermarketem i właścicielem magazynu.

Pokazaliśmy, jak można zachować aktualne informacje o temperaturze w drodze transakcji publicznych i prywatnych.

Scenariuszy zastosowań może być wiele i jak widać nie jest to wcale trudne.

Eksperymentuj, spróbuj rozwinąć swój skrypt. Co więcej, branża technologii blockchain może wzrosnąć prawie dziesięciokrotnie do roku 2024.

Źródło: www.habr.com

Wykonuj transakcje publiczne i prywatne na blockchainie JPMorgan Quorum za pomocą Web3

Kontekst

Inteligentna umowa

Wdrożenie węzła

Transakcje publiczne

Kontekst

Transakcje prywatne

Kontekst

wniosek

Dodaj komentarz Anuluj odpowiedź