🥇Exécution de transactions publiques et privées dans la blockchain JPMorgan Quorum en utilisant Web3

Quorum — une blockchain basée sur Ethereum, développée par JPMorgan et récemment devenue la première plateforme de registre distribué proposée par Microsoft Azure.

Quorum prend en charge les transactions privées et publiques et possède de nombreux scénarios commerciaux d'utilisation.

Dans cet article, nous examinerons 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 garantir des informations actualisées sur la température de l'entrepôt.

Le code utilisé dans ce guide se trouve dans répertoire sur GitHub.

L'article couvre :

la création d'un contrat intelligent ;
le déploiement d'un réseau Quorum à l'aide de Chainstack;
les transactions publiques de Quorum ;
les transactions privées de Quorum.

Pour illustrer, nous utilisons un scénario de surveillance de la température dans les entrepôts des membres du réseau Quorum dans le cadre de l'Internet des Objets (IoT).

Contexte

Un groupe d'entreprises de stockage se regroupe en consortium pour partager des informations et automatiser 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 soit un contrat, soit appelle une fonction dans le contrat pour 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 sont accessibles à tous les membres du consortium. En revanche, les transactions privées ajoutent une couche de confidentialité et ne sont accessibles qu'aux participants ayant les droits appropriés.

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

Contrat intelligent

Voici un simple contrat intelligent créé pour notre scénario. Il contient une variable publique temperature, que l'on peut modifier avec la méthode set et obtenir avec la méthode obtenir.

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 en format ABI et 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 final ressemble à ceci :

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

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

Déploiement de nœuds

Le déploiement d'un nœud peut être assez laborieux et ce processus peut être remplacé par l'utilisation d'un service Chainstack.

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

Pour commencer, créons un projet et nommons-le Projet Quorum :

Créons un réseau Quorum avec le consensus Raft sur Google Cloud Platform :

Nous ajouterons deux nœuds supplémentaires au nœud par défaut déjà créé :

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

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

Le réseau est déployé. Passons maintenant au déploiement des contrats intelligents et à l'exécution des transactions avec web3.js.

Transactions publiques

Contexte

La température de l'entrepôt est essentielle pour réduire les coûts, en particulier pour les produits devant être conservés à des températures inférieures à zéro.

En permettant aux entreprises de partager les valeurs de température externe de leur localisation géographique en temps réel et de les enregistrer dans un registre immuable, les participants au réseau réduisent les coûts et le temps.

Nous allons accomplir trois tâches illustrées sur le diagramme :

Nous déploierons le contrat via Nœud 1:

const contractAddress = await deployContract(raft1Node);
console.log(`Adresse du contrat après déploiement : ${contractAddress}`);

Nous établirons la température via Nœud 2 à 3 degrés :

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

Nœud 3 obtiendra des informations du contrat intelligent. Le contrat renverra la valeur de 3 degrés :
```
const temp = await getTemperature(raft3Node, contractAddress);
console.log('Température récupérée du contrat', temp);
```
Voyons maintenant comment exécuter une transaction publique sur le réseau Quorum en utilisant web3.js.

Nous initierons 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éployons le smart contract :

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

Nous mettrons à jour la température du contrat en exécutant set en utilisant la méthode 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;
  });
}

Ensuite, nous utiliserons la méthode web3 call pour obtenir la température du contrat. Notez que la méthode call s'exécute sur le nœud local et qu'aucune transaction ne sera 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

Nous pouvons ensuite examiner les enregistrements dans l'explorateur Quorum sur le panneau Chainstack, comme indiqué ci-dessous.

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

La première transaction a déployé le contrat.
La deuxième transaction a défini la température du contrat à 3 degrés.
La récupération de la température se fait via le nœud local, donc aucune transaction n'est créée.

Transactions privées

Contexte

Une demande fréquente des organisations est la protection des données. Prenons comme exemple un scénario où un supermarché loue un espace d'entrepôt pour stocker des fruits de mer auprès d'un fournisseur:

Nombre de blocs/enregistrements qui, à l'aide de capteurs IoT, lit les valeurs de température toutes les 30 secondes et les transmet au supermarché.;
Ces valeurs doivent être accessibles uniquement au fournisseur. et au supermarché,qui est regroupé en un consortium.

Nous allons accomplir quatre tâches, illustrées dans le diagramme ci-dessus.

Nous utiliserons les mêmes trois nœuds que dans le scénario précédent pour démontrer les transactions privées :
Le supermarché déploie un contrat intelligent, qui est privé pour le supermarché. et fournisseur.
Une tierce partie n'a pas accès au contrat intelligent.

Nous appellerons des méthodes obtenir et set au nom de le supermarché. et fournisseur pour démontrer une transaction privée Quorum.

Nous allons déployer un contrat privé pour les participants Le supermarché et Nombre de blocs/enregistrements via le participant Le supermarché:

const contractAddress = await deployContract(
raft1Node,
process.env.PK2,
);
console.log(`Adresse du contrat après le déploiement : ${contractAddress}`);

Nous définirons la température de la tierce partie (nœud externe) et obtiendrons 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}`);

Nous définirons la température de fournisseur (nœud interne) et obtiendrons la valeur de température :

La température dans ce scénario devrait retourner une valeur de 12 du contrat intelligent. Notez que Nombre de blocs/enregistrements ici a un accès autorisé 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}`);

Nous obtiendrons la température de la tierce partie (nœud externe) :
À l'étape 3, la température a été définie à 12, mais Une tierce partie n'a pas accès au contrat intelligent. Par conséquent, la valeur retournée doit être null.
```
// This returns null
const temp3 = await getTemperature(raft3Node, contractAddress);
console.log(`[Node3] temp retrieved from external nodes after update ${temp}`);
```
Nous examinerons plus en détail l'exécution des transactions privées sur le réseau Quorum avec web3.js. Comme la majeure partie du code correspond aux transactions publiques, mettons en évidence uniquement les parties qui diffèrent pour les transactions privées.

Veuillez noter que le contrat téléchargé sur la chaîne est immuable, de sorte que l'accès avec autorisation (permissioned) 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', 
    // Accorder l'autorisation au contrat en incluant les clés publiques des nœuds
    privateFor: [publicKey],
  })
  .then((contract) => {
    return contract.options.address;
  });
}

De la même manière, les transactions privées sont exécutées — 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,
    // Accorder l'autorisation en incluant les clés publiques des nœuds
    privateFor: [publicKey],
  }).then((receipt) => {
    return receipt.status;
  });
}

Nous pouvons maintenant démarrer private.js avec les résultats suivants :

node private.js
Adresse du contrat après déploiement : 0x85dBF88B4dfa47e73608b33454E4e3BA2812B21D
[Nœud3] temp récupérée après mise à jour du contrat depuis des nœuds externes : null
[Nœud2] temp récupérée après mise à jour du contrat depuis des nœuds internes : 12
[Nœud3] temp récupérée depuis des nœuds externes après mise à jour null

L'explorateur Quorum dans Chainstack affichera ce qui suit :

déploiement du contrat par un participant Le supermarché;
Exécution SetTemperature à partir de la tierce partie;
Exécution SetTemperature par un participant Nombre de blocs/enregistrements.

Comme vous pouvez le voir, les deux transactions ont été exécutées, mais seule la transaction d'un participant Nombre de blocs/enregistrements a mis à jour la température dans le contrat. Ainsi, les transactions privées garantissent l'immutabilité, mais ne divulguent pas les données à un tiers.

Conclusion

Nous avons examiné un scénario commercial d'utilisation de Quorum pour garantir des informations actualisées sur la température dans un entrepôt en déployant un réseau entre deux parties — un supermarché et un propriétaire d'entrepôt.

Nous avons montré comment des informations actualisées sur la température peuvent être maintenues à la fois par des transactions publiques et privées.

Il peut y avoir de nombreux scénarios d'application et, comme vous pouvez le voir, ce n'est pas si compliqué.

Expérimentez, essayez de déployer votre scénario. D'autant plus que l'industrie des technologies blockchain pourrait croître presque dix fois d'ici 2024.

Source : habr.com

Réalisation de transactions publiques et privées sur la blockchain JPMorgan Quorum en utilisant Web3

Contexte

Contrat intelligent

Déploiement de nœuds

Transactions publiques

Contexte

Transactions privées

Contexte

Conclusion