est une blockchain basée sur Ethereum développée par JPMorgan et est récemment devenue la première plate-forme de grand livre distribué proposée par Microsoft Azure.
Quorum prend en charge les transactions privées et publiques et propose de nombreux cas d'utilisation commerciale.
Dans cet article, nous examinerons l'un de ces scénarios : le déploiement d'un réseau de registres distribués entre un supermarché et un propriétaire d'entrepôt pour fournir des informations à jour sur la température de l'entrepôt.
Le code utilisé dans ce tutoriel est en .
L'article couvre :
- création d'un contrat intelligent ;
- déploiement du réseau Quorum à l'aide ;
- Transactions publiques avec quorum ;
- 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 au sein de l'Internet des objets (IoT).
Contexte
Un groupe de sociétés d'entrepôt s'unit au sein d'un consortium pour stocker conjointement des informations et automatiser les processus sur la blockchain. Pour cela, les entreprises ont décidé d'utiliser Quorum. Dans cet article, nous aborderons 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 le 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 participants au consortium. Les transactions privées ajoutent une couche de confidentialité et ne sont disponibles que pour les participants qui en ont le 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 variable publique temperature, qui peut être modifié en utilisant set et recevoir par 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 , il doit être traduit au format ABI et en bytecode. Utilisation de la fonction formatContractci-dessous compile le contrat en utilisant .
function formatContract() {
const path = './contracts/temperatureMonitor.sol';
const source = fs.readFileSync(path,'UTF8');
return solc.compile(source, 1).contracts[':TemperatureMonitor'];
}Le contrat complété 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
0x608060405234801561001057600080fd5b50610104806100206000396000f30060806040526004361060525763ffffffff7c01000000000000000000000000000000000000000000000000000000006000350416636d4ce63c81146057578063adccea12146082578063faee13b9146094575b600080fd5b348015606257600080fd5b50606960ae565b60408051600092830b90920b8252519081900360200190f35b348015608d57600080fd5b50606960b7565b348015609f57600080fd5b5060ac60043560000b60c0565b005b60008054900b90565b60008054900b81565b6000805491810b60ff1660ff199092169190911790555600a165627a7a72305820af0086d55a9a4e6d52cb6b3967afd764ca89df91b2f42d7bf3b30098d222e5c50029Maintenant que le contrat est prêt, nous allons déployer le réseau et déployer le contrat.
Déploiement de nœud
Le déploiement d'un nœud peut demander beaucoup de travail et ce processus peut être remplacé par l'utilisation d'un service. .
Vous trouverez ci-dessous le processus de déploiement du réseau Quorum avec le consensus Raft et trois nœuds.
Tout d'abord, créons un projet et appelons-le Quorum Project :
Créons un réseau Quorum avec le consensus Raft sur Google Cloud Platform :
Ajoutons deux nœuds supplémentaires au nœud déjà créé par défaut :
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é. Déployons maintenant des contrats intelligents et effectuons des transactions en utilisant .
Opérations 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 à être stockés à des températures inférieures à zéro.
En permettant aux entreprises de partager la température extérieure de leur emplacement géographique en temps réel et de l'enregistrer dans un registre immuable, les participants au réseau réduisent les coûts et les délais.
Nous effectuerons trois tâches, illustrées dans le schéma :
-
Nous déploierons le contrat via Nœud 1:
const contractAddress = await deployContract(raft1Node); console.log(`Contract address after deployment: ${contractAddress}`); -
Réglez la température via Nœud 2 de 3 degrés :
const status = await setTemperature(raft2Node, contractAddress, 3); console.log(`Transaction status: ${status}`); -
Nœud 3 recevra des informations du contrat intelligent. Le contrat renverra la valeur 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 en utilisant .
Nous lançons 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 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;
});
} propose deux méthodes pour interagir avec le contrat : call и send.
Mettons à 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 utilisons la méthode web3 call pour obtenir la température contractuelle. Veuillez noter que la méthode call est exécuté sur un 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);
}Maintenant tu peux courir pour obtenir le résultat suivant :
// Execute public script
node public.js
Contract address after deployment: 0xf46141Ac7D6D6E986eFb2321756b5d1e8a25008F
Transaction status: true
Retrieved contract Temperature 3Ensuite, nous pouvons afficher les entrées dans l'explorateur Quorum dans 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 fixé la température du contrat à 3 degrés.
- La température est reçue via un nœud local, aucune transaction n'est donc 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 Supermarché loue un espace d'entrepôt pour stocker les fruits de mer dans un espace séparé Fournisseur:
- Fournisseur à 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 Au vendeur и Au supermarché, mis en réseau par un consortium.
Nous réaliserons les quatre tâches illustrées dans le schéma ci-dessus.
- Nous utilisons les trois mêmes nœuds du scénario précédent pour démontrer les transactions privées :
- Supermarché déploie un contrat intelligent privé pour supermarché и Fournisseur.
- Le troisième côté n'a pas le droit d'accéder au contrat intelligent.
Nous appellerons les méthodes get и set au nom de supermarché и Fournisseur pour démontrer une transaction privée de quorum.
-
Nous déploierons un contrat privé pour les participants Supermarché и Fournisseur par l'intermédiaire d'un participant Supermarché:
const contractAddress = await deployContract( raft1Node, process.env.PK2, ); console.log(`Contract address after deployment: ${contractAddress}`); -
Réglons la température de Tierce personne (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}`); -
Réglons la température de Fournisseur (nœud interne) et obtenez la valeur de température :
La température dans ce scénario devrait renvoyer la valeur 12 du contrat intelligent. Veuillez noter que Fournisseur 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 obtenons la température de Tierce personne (nœud externe) :
À l'étape 3, la température a été réglée à 12, mais Le troisième côté n’a pas accès au contrat intelligent. La valeur de retour doit donc être nulle.
// This returns null const temp3 = await getTemperature(raft3Node, contractAddress); console.log(`[Node3] temp retrieved from external nodes after update ${temp}`);Ensuite, nous examinerons de plus près la réalisation de transactions privées sur le réseau Quorum avec . Étant donné que la majeure partie du code est la même pour les transactions publiques, nous ne mettrons en évidence que les parties différentes pour les transactions privées.
Notez que le contrat téléchargé sur le réseau est immuable, donc un accès autorisé doit être accordé aux nœuds appropriés en activant 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 courir 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 nullL'explorateur Quorum dans Chainstack affichera ce qui suit :
- déploiement du contrat du participant Supermarché;
- Exécution
SetTemperatureà partir de Tierce personne; - Exécution
SetTemperatured'un participant Fournisseur.
Comme vous pouvez le constater, les deux transactions sont terminées, mais seule celle du participant Fournisseur mis à jour la température dans le contrat. Ainsi, les transactions privées offrent l'immuabilité, mais en même temps ne révèlent pas de données à un tiers.
Conclusion
Nous avons examiné un cas d'utilisation commerciale 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 un propriétaire d'entrepôt.
Nous avons montré comment des informations à jour sur la température peuvent être maintenues grâce à des transactions publiques et privées.
Il peut y avoir de nombreux scénarios d'application et, comme vous pouvez le constater, ce n'est pas du tout difficile.
Expérimentez, essayez d'étendre votre script. De plus, l’industrie de la technologie blockchain .
Source: habr.com