🥇Utföra offentliga och privata transaktioner på JPMorgan Quorum blockchain med hjälp av Web3

Quorum är en Ethereum-baserad blockkedja utvecklad av JPMorgan och blev senast den första distribuerade ledger-plattformen som erbjuds av Microsoft Azure.

Quorum stöder privata och offentliga transaktioner och har många kommersiella användningsfall.

I den här artikeln kommer vi att undersöka ett sådant scenario - distributionen av ett distribuerat reskontranät mellan en stormarknad och en lagerägare för att tillhandahålla uppdaterad information om temperaturen på lagret.

Koden som används i denna handledning finns i repositories på GitHub.

Artikeln omfattar:

skapande av ett smart kontrakt;
distribution av Quorum-nätverket med hjälp av Kedjestack;
Offentliga transaktioner i kvorum;
Quorum privata transaktioner.

För att illustrera använder vi ett scenario för att övervaka temperaturen i lager hos medlemmar i Quorum-nätverket inom Internet of Things (IoT).

sammanhang

En grupp lagerföretag går samman i ett konsortium för att gemensamt lagra information och automatisera processer i blockkedjan. För detta beslutade företag att använda Quorum. I den här artikeln kommer vi att täcka två scenarier: offentliga transaktioner och privata transaktioner.

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

Offentliga transaktioner är tillgängliga för alla konsortiets deltagare. Privata transaktioner lägger till ett lager av konfidentialitet och är endast tillgängliga för de deltagare som har rättigheter att göra det.

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

Smart kontrakt

Nedan är ett enkelt smart kontrakt skapat för vårt scenario. Den har en publik variabel temperature, som kan ändras med set och ta emot med 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;
  }
}

För att kontraktet ska fungera med web3.jsmåste den översättas till ABI-format och bytekod. Använder funktionen formatContractnedan sammanställer 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 så här:

// 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 distribuera kontraktet.

Noddistribution

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

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

Låt oss först skapa ett projekt och kalla det Quorum Project:

Låt oss skapa ett kvorumnätverk med Raft-konsensus på Google Cloud Platform:

Låt oss lägga till ytterligare två noder till noden som redan skapats som standard:

Tre löpande noder:

Sidan med noddetaljer visar RPC-slutpunkten, offentlig nyckel, etc.

Nätverket är utplacerat. Låt oss nu distribuera smarta kontrakt och utföra transaktioner med hjälp av web3.js.

Offentliga transaktioner

sammanhang

Lagertemperaturen har stor betydelse för att sänka kostnaderna, särskilt för produkter som är avsedda att förvaras vid minusgrader.

Genom att tillåta företag att dela utomhustemperaturen på sin geografiska plats i realtid och registrera den i en oföränderlig reskontra, minskar nätverksdeltagare kostnader och tid.

Vi kommer att utföra tre uppgifter, illustrerade i diagrammet:

Vi kommer att distribuera kontraktet via Node 1:

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

Ställ in temperaturen via Node 2 med 3 grader:

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

Node 3 kommer att få 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 ska vi titta på hur man utför en offentlig transaktion på 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,
 },
);

Låt oss implementera det smarta avtalet:

// 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 и send.

Låt oss uppdatera kontraktstemperaturen genom att utföra set använder web3-metoden 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 web3-metoden call för att få kontraktstemperaturen. Observera att metoden call exekveras på en lokal nod och transaktionen kommer inte 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 du springa 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

Därefter kan vi se inläggen i Quorum explorer i Chainstack-panelen, som visas nedan.

Alla tre noder interagerade och transaktionerna uppdaterades:

Den första transaktionen implementerade kontraktet.
Den andra transaktionen satte kontraktstemperaturen till 3 grader.
Temperaturen tas emot via en lokal nod, så ingen transaktion skapas.

Privata transaktioner

sammanhang

Ett vanligt krav för organisationer är dataskydd. Som ett exempel, överväg ett scenario där Mataffär hyr en lagerplats för förvaring av skaldjur från en separat Säljare:

Säljare använder IoT-sensorer, läser temperaturvärden var 30:e sekund och sänder dem Till snabbköpet;
dessa värden bör endast vara tillgängliga Till säljaren и Till snabbköpet, nätverkande av ett konsortium.

Vi kommer att slutföra de fyra uppgifterna som illustreras i diagrammet ovan.

Vi använder samma tre noder från föregående scenario för att demonstrera privata transaktioner:
Mataffär distribuerar ett smart kontrakt som är privat för Mataffär и Säljare.
Den tredje sidan har inte rätt att få tillgång till det smarta kontraktet.

Vi kommer att kalla metoderna get и set på uppdrag av Mataffär и Säljare för att demonstrera en privat kvorumtransaktion.

Vi kommer att distribuera ett privat kontrakt för deltagare Mataffär и Säljare genom en deltagare Mataffär:

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

Låt oss ställa in temperaturen från Tredje part (extern nod) och få 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}`);

Låt oss ställa in temperaturen från Säljare (intern nod) och få temperaturvärdet:

Temperaturen i detta scenario bör returnera värdet 12 från det smarta kontraktet. Observera att Säljare här har auktoriserad 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}`);

Temperaturen får vi från Tredje part (extern nod):

I steg 3 sattes temperaturen till 12, men Den tredje sidan har inte tillgång till det smarta kontraktet. Därför måste returvärdet vara null.
```
// This returns null
const temp3 = await getTemperature(raft3Node, contractAddress);
console.log(`[Node3] temp retrieved from external nodes after update ${temp}`);
```
Därefter kommer vi att titta närmare på att utföra privata transaktioner på Quorum-nätverket med web3.js. Eftersom det mesta av koden är densamma för offentliga transaktioner, kommer vi endast att markera de delar som är olika för privata transaktioner.

Observera att kontraktet som laddas upp till nätverket är oföränderligt, så behörig åtkomst måste beviljas till lämpliga noder genom att aktivera det offentliga kontraktet vid den tidpunkt då kontraktet distribueras, inte efter.

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

Privata transaktioner utförs på liknande sätt - genom att inkludera deltagarnas publika nyckel vid tidpunkten för genomfö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 springa 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 explorer i Chainstack kommer att visa följande:

utplacering av kontraktet från deltagaren Mataffär;
utförande SetTemperature från Tredje part;
utförande SetTemperature från en deltagare Säljare.

Som du kan se är båda transaktionerna genomförda, men endast transaktionen från deltagaren Säljare uppdaterade temperaturen i kontraktet. Privata transaktioner ger alltså oföränderlighet, men avslöjar samtidigt inte data för en tredje part.

Slutsats

Vi tittade på ett kommersiellt användningsfall för Quorum för att tillhandahålla uppdaterad temperaturinformation i ett lager genom att distribuera ett nätverk mellan två parter - en stormarknad och en lagerägare.

Vi visade hur uppdaterad temperaturinformation kan upprätthållas genom både offentliga och privata transaktioner.

Det kan finnas många applikationsscenarier och som du kan se är det inte alls svårt.

Experimentera, försök utöka ditt skript. Dessutom blockchain-teknikindustrin kan växa nästan tiofaldigt till 2024.

Källa: will.com

Utför offentliga och privata transaktioner på JPMorgan Quorum blockchain med hjälp av Web3

sammanhang

Smart kontrakt

Noddistribution

Offentliga transaktioner

sammanhang

Privata transaktioner

sammanhang

Slutsats

Lägg en kommentar Avbryt svar