🥇Nyilvános és privát tranzakciók végrehajtása a JPMorgan Quorum blokkláncon Web3 használatával

Quorum — egy Ethereum-alapú blockchain, amelyet a JPMorgan fejlesztett ki, és amely nemrégiben az első elosztott főkönyvet kínálta a Microsoft Azure-on.

A Quorum támogatja a privát és nyilvános tranzakciókat, és számos kereskedelmi alkalmazási lehetőséggel rendelkezik.

Ebben a cikkben egy ilyen alkalmazási lehetőséget vizsgálunk meg — elosztott főkönyvi hálózat kiépítése egy szupermarket és egy raktár tulajdonosa között a raktári hőmérséklet aktuális információinak biztosítása érdekében.

A jelen útmutatóhoz használt kód található itt: tároló a GitHubon.

A cikk a következő témákat fedi:

okosszerződés létrehozása;
a Quorum hálózat kiépítése Chainstack;
nyilvános tranzakciók Quorumban;
privát tranzakciók Quorumban.

A példában a Quorum hálózat résztvevőinek raktáraiban a hőmérséklet monitorozásának szcenárióját alkalmazzuk az Internet of Things (IoT) keretein belül.

Környezet

A raktározási cégek konzorciumba tömörülnek, hogy közösen tárolják az információkat és automatizálják a folyamatokat a blokkláncon. Ehhez a vállalatok a Quorumot választották. Ebben a cikkben két szcenáriót fogunk megvizsgálni: nyilvános tranzakciókat és privát tranzakciókat.

A tranzakciókat különböző résztvevők hozzák létre a konzorciummal való interakció céljából, amelyhez tartoznak. Minden tranzakció vagy okosszerződést telepít, vagy egy funkciót hív meg a szerződésben az adatok hálózatra juttatása érdekében. Ezek a műveletek replikálódnak a hálózat összes csomópontján.

A nyilvános tranzakciók minden konzoriumi tag számára láthatóak. A privát tranzakciók azonban egy adatvédelmi réteget adnak, és csak azok a résztvevők férhetnek hozzá, akiknek van ehhez jogosultságuk.

Mindkét szcenárióhoz az áttekinthetőség kedvéért ugyanazt a szerződést használjuk.

smart-contract

Az alábbiakban egy egyszerű okosszerződést mutatunk be, amelyet a szcenáriónkhoz készítettek. Tartalmaz egy nyilvános változót temperature, amelyet a következő metódussal lehet módosítani set és lekérdezni a következő metódussal 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;
  }
}

Ahhoz, hogy a szerződés működjön a web3.js, át kell alakítani ABI és bytecode formátumra. Az alábbi "formatContract" függvény használatával a szerződés fordítása történik a formatContract, alább bemutatott, a "solc-js" segítségével történik. function formatContract() { const path = '.\/contracts\/temperatureMonitor.sol'; const source = fs.readFileSync(path,'UTF8'); return solc.compile(source, 1).contracts[':TemperatureMonitor']; }.

A kész szerződés a következőképpen néz ki:

A kész szerződés a következőképpen néz ki:

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

Most már, hogy a szerződés elkészült, kiépítjük a hálózatot és telepítjük a szerződést.

Csomópontok telepítése

A csomópont telepítése meglehetősen időigényes lehet, és ezt a folyamatot egy szolgáltatás használatával helyettesíthetjük. Chainstack.

Íme a Quorum hálózat telepítési folyamata Raft konszenzussal és három csomóponttal.

Első lépésként hozzunk létre egy projektet, amelynek a neve Quorum Project:

Hozzuk létre a Quorum hálózatot Raft konszenzussal a Google Cloud Platformon:

A már létrehozott alapértelmezett csomóponthoz adjunk hozzá még két csomópontot:

Három futó csomópont:

A csomópont részleteit mutató oldal bemutatja az RPC végpontot, a nyilvános kulcsot stb.

A hálózat telepítve van. Most nekilátunk a okos szerződések telepítésének és a tranzakciók végrehajtásának a segítségével web3.js.

Nyilvános tranzakciók

Környezet

A raktári helyiség hőmérséklete kulcsfontosságú a költségek csökkentésében, különösen a mínusz hőmérsékleten tárolásra szánt termékek esetében.

Lehetővé téve a vállalatok számára, hogy valós időben megosszák a fö геográfiai elhelyezkedésük külső hőmérsékletét, és rögzítsék egy megváltoztathatatlan főkönyvben, a hálózat résztvevői csökkentik a költségeket és az időt.

Három feladatot fogunk végrehajtani, amelyek a diagramon láthatóak:

Telepítsük a szerződést a következőn: Node 1:

const contractAddress = await deployContract(raft1Node);
console.log(`Szerződés címe a telepítés után: ${contractAddress}`);

Állítsuk be a hőmérsékletet a következőn: Node 2 3 fokkal:

const status = await setTemperature(raft2Node, contractAddress, 3);
console.log(`A tranzakció állapota: ${status}`);

Node 3 megkapja az információt az okos szerződéstől. A szerződés visszaadja a 3 fok értéket:
```
const temp = await getTemperature(raft3Node, contractAddress);
console.log('Lekért szerződés hőmérséklet', temp);
```
Most nézzük meg, hogyan hajthatunk végre nyilvános tranzakciót a Quorum hálózatban az alábbiak használatával: web3.js.

Hozzunk létre egy példányt RPC-n keresztül három csomóponthoz:

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

Telepítsük az okos szerződést:

// 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 két módszert biztosít a szerződéssel való interakcióhoz: call és send.

Frissítsük a szerződés hőmérsékletét a következő végrehajtással: set használva a web3 módszert 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;
  });
}

Ezután a web3 módszerrel call kaphatjuk meg a szerződés hőmérsékletét. Ne feledje, hogy a módszer call helyi csomóponton hajtódik végre, és a blokkláncon tranzakció nem jön létre.

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

Most már futtathatjuk public.js a következő eredmény megszerzéséhez:

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

Ezután megnézhetjük a Quorum explorer bejegyzéseit a Chainstack panelen, ahogy az alább látható.

Mindhárom node kölcsönhatásba lépett, és a tranzakciók frissültek:

Az első tranzakció telepítette a szerződést.
A második tranzakció a szerződés hőmérsékletét 3 fokra állította be.
A hőmérséklet lekérdezése helyi node-on keresztül történik, ezért tranzakció nem jött létre.

Privát tranzakciók

Környezet

A szervezetek gyakori igénye az adatok védelme. Példaként vegyük a következő forgatókönyvet: A szupermarket raktárbérlést végez a tengeri ételek tárolására egy különálló szolgáltatótól:

Gyártó IoT érzékelők segítségével 30 másodpercenként leolvassa a hőmérsékleti értékeket, és átadja azokat a szupermarketnek.;
Ezeket az értékeket csak a szolgáltató számára és a szupermarket számára,amely egy konzorciumba van összekapcsolva.

Négy feladatot fogunk végrehajtani, amelyek a fenti ábrán vannak ábrázolva.

Ugyanazokat a három node-ot használjuk az előző forgatókönyvből, hogy bemutassuk a privát tranzakciókat:
A szupermarket több alkalmazásnak szánt privát okos szerződést telepít a szupermarket számára. és szolgáltatótól.
A harmadik fél nem férhet hozzá az okos szerződéshez.

A módszereket fogjuk meghívni get és set a a szupermarket számára. és szolgáltatótól privát Quorum tranzakció bemutatására.

Privát szerződést telepítünk a résztvevőkért A szupermarket és Gyártó az alábbi módon: A szupermarket:

const contractAddress = await deployContract(
raft1Node,
process.env.PK2,
);
console.log(`A szerződés címe a telepítés után: ${contractAddress}`);

A harmadik féltől a (külső node) hőmérsékletet állítunk be, és megkapjuk a hőmérséklet értékét: (belső node) és megkapjuk a hőmérséklet értékét:

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

A harmadik féltől szolgáltatótól A hőmérsékletnek ebben a forgatókönyvben a 12-es értéket kell visszaadnia az okos szerződéstől. Vegye figyelembe, hogy

itt van engedélyezett hozzáférés az okos szerződéshez. Gyártó Hőmérsékletet szerzünk a

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

(külső node): a (külső node) hőmérsékletet állítunk be, és megkapjuk a hőmérséklet értékét: A 3. lépésben a hőmérséklet 12-es értékre volt beállítva, de
nincs hozzáférése az okos szerződéshez. Ezért a visszatérő érték nullának kell lennie. A harmadik fél Ezután részletesebben megnézzük a privát tranzakciók végrehajtását a Quorum hálózaton,
```
// This returns null
const temp3 = await getTemperature(raft3Node, contractAddress);
console.log(`[Node3] temp retrieved from external nodes after update ${temp}`);
```
. Mivel a kód nagy része megegyezik a nyilvános tranzakciókkal, csak azokat a részeket emeljük ki, amelyek eltérnek a privát tranzakciókhoz. web3.js. Mivel a kód nagy része megegyezik a nyilvános tranzakciókkal, csak azokat a részeket emeljük ki, amelyek eltérnek a privát tranzakciókhoz.

Kérjük, vegye figyelembe, hogy a hálózatra feltöltött szerződés módosíthatatlan, így a hozzáférés engedélyezését (permissioned) az érintett csomópontok számára a szerződés közzétételének időpontjában kell biztosítani, nem pedig utána.

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’, 
    	 // Engedélyezés a csomópontok nyilvános kulcsainak belefoglalásával
    privateFor: [publicKey],
  })
  .then((contract) => {
    return contract.options.address;
  });
}

Hasonló módon hajtódnak végre a privát tranzakciók is — a résztvevők nyilvános kulcsának belefoglalásával a végrehajtás időpontjában.

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,
    	 // Engedélyezés a csomópontok nyilvános kulcsainak belefoglalásával
    privateFor: [publicKey],
  }).then((receipt) => {
    return receipt.status;
  });
}

Most már elindíthatjuk private.js a következő eredményekkel:

node private.js
A szerződés címe a telepítés után: 0x85dBF88B4dfa47e73608b33454E4e3BA2812B21D
[Node3] a hőmérséklet lekérdezése a szerződés frissítése után külső csomópontoktól: null
[Node2] a hőmérséklet lekérdezése a szerződés frissítése után belső csomópontoktól: 12
[Node3] a hőmérséklet lekérdezése külső csomópontoktól a frissítés után: null

A Chainstack Quorum Explorer a következőket mutatja:

szerződés telepítése a résztvevő által A szupermarket;
Végrehajtás SetTemperature tól a (külső node) hőmérsékletet állítunk be, és megkapjuk a hőmérséklet értékét:;
Végrehajtás SetTemperature a résztvevő által Gyártó.

Ahogy látja, mindkét tranzakció végrehajtódott, de csak a résztvevő tranzakciója Gyártó frissítette a hőmérsékletet a szerződésben. Így a privát tranzakciók biztosítják a módosíthatatlanságot, de nem hozzák nyilvánosságra az adatokat harmadik fél számára.

Zárás

Megvitattuk a Quorum kereskedelmi alkalmazását, hogy aktuális információkat biztosítsunk a raktár hőmérsékletéről egy két fél közötti hálózat telepítésével — egy szupermarket és a raktár tulajdonosa között.

Megmutattuk, hogyan tartható fenn az aktuális hőmérsékleti információ mind nyilvános, mind privát tranzakciókon keresztül.

Az alkalmazási forgatókönyvek nagyon változatosak lehetnek, és ahogy látja, ez egyáltalán nem nehéz.

Kísérletezzen, próbálja meg telepíteni a saját forgatókönyvét. Különösen, hogy a blokklánc-technológia ipara 2024-re majdnem tízszeresére növekedhet..

Forrás: habr.com