🥇 Genomförande av offentliga och privata transaktioner i JPMorgan Quorums blockchain med Web3

Quorum — en blockchain baserad på Ethereum, utvecklad av JPMorgan och nyligen blivit den första plattformen för distribuerad ledger som erbjuds av Microsoft Azure.

Quorum stödjer både privata och offentliga transaktioner och har många kommersiella användningsscenarier.

I denna artikel kommer vi att granska ett sådant scenario — att implementera ett distribuerat ledger-nätverk mellan en stormarknad och en lagerägare för att säkerställa aktuell information om temperaturen i lagret.

Koden som används i denna guide finns i förrådet på GitHub.

Artikeln omfattar:

skapande av ett smart kontrakt;
implementering av ett Quorum-nätverk med hjälp av Chainstack;
offentliga transaktioner i Quorum;
privata transaktioner i Quorum.

För att illustrera används ett scenario för temperaturövervakning i lagerutrymmen hos deltagarna i Quorum-nätverket inom ramen för Internet of Things (IoT).

Kontext

Gruppen av lagerföretag går samman i ett konsortium för att gemensamt lagra information och automatisera processer på blockchain. För detta har företagen beslutat att använda Quorum. I denna artikel kommer vi att täcka två scenarier: offentliga transaktioner och privata transaktioner.

Transaktioner skapas av olika deltagare för att interagera med det konsortium de tillhör. Varje transaktion antingen deployar ett kontrakt eller anropar en funktion i kontraktet för att ladda upp data till nätverket. Dessa åtgärder repliceras på alla noder i nätverket.

Offentliga transaktioner är tillgängliga för visning av alla medlemmar i konsortiet. Privata transaktioner lägger till ett lager av sekretess och är endast tillgängliga för dem deltagare som har rättighet till det.

För båda scenarierna använder vi samma kontrakt för tydlighetens skull.

Smart kontrakt

Nedan finns ett enkelt smart kontrakt, skapad för vårt scenario. Det innehåller en offentlig variabel temperature, som kan ändras med metoden set och hämtas med metoden hämta.

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

För att kontraktet ska kunna fungera med web3.js, måste det översättas till ABI- och bytekodformat. Användningen av funktionen formatContract, som beskrivs nedan, kompilerar kontraktet med hjälp av solc-js.

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

Det färdiga kontraktet ser ut på följande sätt:

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

Nu när kontraktet är klart kommer vi att distribuera nätverket och implementera kontraktet.

Utplacering av noder

Att distribuera en nod kan vara ganska arbetskrävande och denna process kan ersättas genom att använda en tjänst. Chainstack.

Nedan visas processen för att distribuera ett Quorum-nätverk med Raft-konsensus och tre noder.

Först skapar vi ett projekt och döper det till Quorum Project:

Vi skapar ett Quorum-nätverk med Raft-konsensus på Google Cloud Platform:

Till den redan skapade noden lägger vi till ytterligare två noder:

Tre körande noder:

Nodens detaljsida visar RPC-endpoint, publik nyckel osv.

Nätverket är distribuerat. Nu går vi vidare med att implementera smarta kontrakt och utföra transaktioner med hjälp av web3.js.

Offentliga transaktioner

Kontext

Lagringstemperaturen är mycket viktig för att minska kostnader, särskilt för produkter som är avsedda att lagras vid minusgrader.

Genom att ge företag möjlighet att dela värden av den externa temperaturen vid deras geografiska läge i realtid och registrera dem i ett oföränderligt register, minskar nätverksdeltagarna kostnader och tid.

Vi kommer att utföra tre uppgifter som illustreras i diagrammet:

Vi implementerar kontraktet via Nod 1:

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

Vi ställer in temperaturen via Nod 2 till 3 grader:

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

Nod 3 kommer att hämta information från det smarta kontraktet. Kontraktet kommer att returnera värdet 3 grader:
```
const temp = await getTemperature(raft3Node, contractAddress);
console.log(‘Retrieved contract Temperature’, temp);
```
Därefter tittar vi på hur man utför en offentlig transaktion i Quorum-nätverket med hjälp av web3.js.

Vi initierar en instans via RPC för tre noder:

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

Vi implementerar det smarta kontraktet:

// 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 tillhandahåller två metoder för att interagera med kontraktet: call och send.

Vi uppdaterar kontraktets temperatur genom att utföra set använda metoden 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;
  });
}

Därefter använder vi metoden web3 call för att hämta kontraktets temperatur. Observera att metoden call utförs på den lokala noden och att ingen transaktion kommer att skapas på blockkedjan.

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

Nu kan vi köra public.js för att få följande resultat:

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

Vi kan nu titta på poster i Quorum-explorern i Chainstack-panelen, som visas nedan.

Alla tre noder interagerade och transaktionerna uppdaterades:

Den första transaktionen deployade kontraktet.
Den andra transaktionen satte kontraktets temperatur till 3 grader.
Temperaturen erhålls genom den lokala noden, därför skapas ingen transaktion.

Privata transaktioner

Kontext

Ett vanligt krav från organisationer är dataskydd. Som ett exempel kan vi överväga ett scenario där supermarkedet hyr ett lager för lagring av skaldjur från en separat leverantör:

leverantör genom IoT-sensorer avläser temperaturvärden var 30:e sekund och överför dem till supermarkedet;
och dessa värden ska endast vara tillgängliga för leverantören och supermarkedet, som är förenade i ett konsortium.

Vi kommer att utföra fyra uppgifter, illustrerade i diagrammet ovan.

Vi använder samma tre noder som i det föregående scenariot för att demonstrera privata transaktioner:
supermarkedet deployar ett smart kontrakt som är privat för supermarkedet. och leverantör.
Tredje part har inte rätt att få tillgång till det smarta kontraktet.

Vi kommer att anropa metoder hämta och set å deras vägnar supermarkedet. och leverantör för att demonstrera en privat transaktion i Quorum.

Vi kommer att deploya ett privat kontrakt för deltagarna supermarkedet och leverantör genom deltagaren supermarkedet:

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

Vi sätter temperaturen av den tredje parten (extern nod) och får temperaturvärdet:

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

Vi sätter temperaturen av leverantör (intern nod) och får temperaturvärdet:

Temperaturen i detta scenario ska returnera värdet 12 från det smarta kontraktet. Observera att leverantör det här har tillåten tillgång till det smarta kontraktet.

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

Vi får temperaturen från den tredje parten (extern nod):
I steg 3 var temperaturen satt med värdet 12, men Tredje part har inte tillgång till det smarta kontraktet. Därför bör värdet som returneras vara null.
```
// This returns null
const temp3 = await getTemperature(raft3Node, contractAddress);
console.log(`[Node3] temp retrieved from external nodes after update ${temp}`);
```
Vi ska nu titta mer ingående på genomförandet av privata transaktioner i Quorum-nätverket med web3.js. Eftersom mycket av koden överensstämmer med offentliga transaktioner, kommer vi endast att markera de delar som skiljer sig för privata transaktioner.

Observera att kontraktet som laddades upp på nätet är oföränderligt, så åtkomst med tillstånd (permissioned) måste ges till de aktuella noderna genom att inkludera det offentliga kontraktet vid distributionen av kontraktet och inte efteråt.

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

På samma sätt utförs privata transaktioner - genom att inkludera deltagarnas offentliga nyckel vid utförandet.

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

Nu kan vi starta private.js med följande resultat:

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

Quorum-explorern i Chainstack kommer att visa följande:

distributivt kontrakt från deltagaren supermarkedet;
Genomförande SetTemperature från den tredje parten;
Genomförande SetTemperature från deltagaren leverantör.

Som ni ser, båda transaktionerna genomfördes, men endast transaktionen från deltagaren leverantör uppdaterade temperaturen i kontraktet. Således säkerställer privata transaktioner oföränderlighet, men de avslöjar inte data för tredje part.

Slutsats

Vi har granskat ett kommersiellt användningsscenario för Quorum för att säkerställa aktuell information om temperaturen i ett lager genom att distribuera ett nätverk mellan två parter - stormarknaden och lagerägaren.

Vi har visat hur aktuell information om temperaturen kan upprätthållas både genom offentliga och privata transaktioner.

Användningsscenarierna kan vara många och, som ni ser, är det inte så svårt.

Experimentera, försök att distribuera ditt scenario. Dessutom kan blockchain-teknologibranschen växa nästan tio gånger fram till 2024..

Källa: habr.com