Effectuer des transactions publiques et privées sur la blockchain JPMorgan Quorum à l'aide de Web3

Quorum est une blockchain basée sur Ethereum développée par JPMorgan et est récemment devenue la première plate-forme de registre distribuée offerte par Microsoft Azure.

Quorum prend en charge les transactions privées et publiques et dispose de nombreux cas d'utilisation commerciale.

Dans cet article, nous analyserons l'un de ces scénarios - le déploiement d'un réseau de registre distribué entre un supermarché et un propriétaire d'entrepôt pour fournir des informations pertinentes sur la température d'un entrepôt.

Le code utilisé dans ce guide se trouve dans le référentiel sur GitHub .

L'article couvre:

• créer un contrat intelligent;
• Déploiement du réseau Quorum avec Chainstack
• Transactions publiques de quorum
• Transactions privées de quorum.

Pour illustrer cela, nous utilisons le scénario de surveillance de la température dans les salles de stockage des participants au réseau Quorum dans le cadre de l'Internet des objets (IoT).

Contexte

Un groupe de sociétés d'entrepôt est uni dans un consortium pour le stockage conjoint d'informations et l'automatisation des processus sur la blockchain. Pour cela, les entreprises ont décidé d'utiliser Quorum. Dans cet article, nous couvrirons deux scénarios: les transactions publiques et les transactions privées.

Les transactions sont créées par différents participants pour interagir avec le consortium auquel ils appartiennent. Chaque transaction déploie un contrat ou appelle une fonction dans un contrat pour télécharger des données sur le réseau. Ces actions sont répliquées sur tous les nœuds du réseau.

Les transactions publiques peuvent être consultées par tous les membres du consortium. Les transactions privées ajoutent une couche de confidentialité et ne sont disponibles que pour les participants qui y ont droit.

Pour les deux scénarios, nous utilisons le même contrat pour plus de clarté.

Contrat intelligent

Vous trouverez ci-dessous un simple contrat intelligent créé pour notre scénario. Il a une temperature variable publique, qui peut être modifiée à l'aide de la méthode set et récupérée par la méthode 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; } } 

Pour que le contrat fonctionne avec web3.js , il doit être converti au format ABI et au bytecode. L'utilisation de la fonction formatContract ci-dessous compile le contrat à l'aide de solc-js .

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

Le contrat terminé est le suivant:

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

Maintenant que le contrat est prêt, nous allons déployer le réseau et déployer le contrat.

Déploiement de noeud

Le déploiement d'un nœud peut prendre beaucoup de temps et ce processus peut être remplacé à l'aide du service Chainstack .

Voici un processus de déploiement de réseau Quorum avec un consensus Raft et trois nœuds.

Pour commencer, commençons un projet et appelons-le le projet Quorum:

Créez un réseau Quorum avec le consensus Raft sur la plateforme Google Cloud:

Au nœud par défaut déjà créé, ajoutez deux nœuds supplémentaires:

Trois nœuds en cours d'exécution:

La page des détails du nœud affiche le point de terminaison RPC, la clé publique, etc.

Le réseau est déployé. Nous allons maintenant déployer des contrats intelligents et exécuter des transactions à l'aide de web3.js.

Transactions publiques

Contexte

La température de l'entrepôt est d'une grande importance pour réduire les coûts, en particulier pour les produits destinés au stockage à des températures inférieures à zéro.

En donnant aux entreprises la possibilité de partager les valeurs en temps réel de la température extérieure de leur emplacement géographique et de les enregistrer dans un registre immuable, les membres du réseau réduisent les coûts et le temps.

Nous réaliserons les trois tâches illustrées dans le schéma:

1. Nous résilierons le contrat via le nœud 1 :

   
   

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

   
   

2. Réglez la température via le nœud 2 à 3 degrés:

   
   

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

   
   

3. Le nœud 3 recevra les informations du contrat intelligent. Le contrat renverra une valeur de 3 degrés:

   
   

    const temp = await getTemperature(raft3Node, contractAddress); console.log('Retrieved contract Temperature', temp); 

   
   

   Ensuite, nous verrons comment exécuter une transaction publique sur le réseau Quorum à l'aide de web3.js.

   
   

Nous initions une instance via RPC pour trois nœuds:

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

Détruisez le contrat intelligent:

 // 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 propose deux méthodes pour interagir avec un contrat: call et send .

Mettez à jour la température du contrat en exécutant set à l'aide de la méthode d' send web3.

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

Ensuite, nous utilisons la méthode d' call web3 pour obtenir la température du contrat. Veuillez noter que la méthode d' call est exécutée sur le nœud local et la transaction ne sera pas créée sur la blockchain.

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

Vous pouvez maintenant exécuter public.js pour obtenir le résultat suivant:

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

Ensuite, nous pouvons voir les entrées dans l'explorateur de quorum dans le panneau Chainstack, comme indiqué ci-dessous.

Les trois nœuds ont interagi et les transactions ont été mises à jour:

1. La première transaction a obtenu un contrat.
2. La deuxième transaction a fixé la température du contrat à 3 degrés.
3. La température est obtenue via le nœud local, la transaction n'a donc pas été créée.

Transactions privées

Contexte

Une exigence courante des organisations est la protection des données. À titre d'exemple, considérons un scénario dans lequel un supermarché loue un entrepôt pour stocker des fruits de mer auprès d'un fournisseur distinct:

• Le vendeur, à l'aide de capteurs IoT, lit les valeurs de température toutes les 30 secondes et les transmet au supermarché ;
• ces valeurs ne devraient être disponibles que pour le vendeur et le supermarché , un consortium en réseau.

Nous terminerons les quatre tâches illustrées dans le diagramme ci-dessus.

• Nous utilisons les trois mêmes nœuds du scénario précédent pour illustrer les transactions privées:
• Le supermarché déploie un contrat intelligent qui est privé au supermarché et au vendeur .
• Un tiers n'a pas accès au contrat intelligent.

Nous appellerons les méthodes get et set au nom du supermarché et du vendeur pour démontrer la transaction privée du quorum.

1. Nous résilierons le contrat privé pour les participants au supermarché et au vendeur par le biais du participant au supermarché :

   
   

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

   
   

2. Réglez la température à partir du tiers (nœud externe) et obtenez la valeur de température:

   
   

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

   
   

3. Réglez la température auprès du fournisseur (nœud interne) et obtenez la valeur de température:

   
   

   La température dans ce scénario devrait revenir du contrat intelligent à 12. Veuillez noter que le fournisseur ici a autorisé l'accès au contrat intelligent.

   
   

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

   
   

4. Obtenez la température du tiers (nœud externe):

   
   

   À l'étape 3, la température a été réglée sur 12, mais le tiers n'a pas accès au contrat intelligent. Par conséquent, la valeur de retour doit être nulle.

   
   

    // This returns null const temp3 = await getTemperature(raft3Node, contractAddress); console.log(`[Node3] temp retrieved from external nodes after update ${temp}`); 

   
   

   Ensuite, nous considérerons plus en détail l'exécution de transactions privées sur le réseau Quorum avec web3.js. Étant donné que la plupart du code coïncide avec des transactions publiques, nous sélectionnons uniquement les parties qui sont différentes pour les transactions privées.

   
   

Veuillez noter que le contrat téléchargé sur le réseau est inchangeable, donc l'accès avec autorisation doit être accordé aux nœuds correspondants en incluant le contrat public au moment du déploiement du contrat, et non après.

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

Les transactions privées sont effectuées de la même manière - en incluant la clé publique des participants au moment de l'exécution.

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

Maintenant, nous pouvons exécuter private.js avec les résultats suivants:

 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 

L'explorateur de quorum de Chainstack affichera les éléments suivants:

• Déploiement d'un contrat d'un participant dans un supermarché ;
• Exécution de SetTemperature partir d'un tiers ;
• Effectuez une SetTemperature partir d'un participant fournisseur .

Comme vous pouvez le voir, les deux transactions sont terminées, mais seule la transaction du vendeur participant a mis à jour la température dans le contrat. Ainsi, les transactions privées offrent une immuabilité, mais en même temps, elles ne fournissent pas de données à un tiers.

Conclusion

Nous avons examiné le scénario commercial d'utilisation de Quorum pour fournir des informations à jour sur la température dans un entrepôt en déployant un réseau entre deux parties - un supermarché et le propriétaire de l'entrepôt.

Nous avons montré comment les informations sur la température actuelle peuvent être conservées par le biais de transactions publiques et privées.

Il peut y avoir beaucoup de scénarios d'application et, comme vous le voyez, ce n'est pas du tout difficile.

Expérimentez, essayez de déployer votre script. De plus, l'industrie de la technologie blockchain peut croître près de dix fois d'ici 2024 .