é um blockchain baseado em Ethereum desenvolvido pelo JPMorgan e, mais recentemente, tornou-se a primeira plataforma de contabilidade distribuída oferecida pelo Microsoft Azure.
O Quorum oferece suporte a transações públicas e privadas e tem muitos casos de uso comercial.
Neste artigo, examinaremos um desses cenários: a implantação de uma rede de contabilidade distribuída entre um supermercado e o proprietário de um armazém para fornecer informações atualizadas sobre a temperatura do armazém.
O código usado neste tutorial está em .
O artigo cobre:
- criação de um contrato inteligente;
- implantação da rede Quorum usando ;
- Transações públicas de quórum;
- Transações privadas de quórum.
Para ilustrar, utilizamos um cenário de monitoramento de temperatura em armazéns de membros da rede Quorum dentro da Internet das Coisas (IoT).
Contexto
Um grupo de empresas de armazenamento está se unindo em um consórcio para armazenar informações em conjunto e automatizar processos no blockchain. Para isso, as empresas decidiram utilizar o Quorum. Neste artigo iremos cobrir dois cenários: transações públicas e transações privadas.
As transações são criadas por diferentes participantes para interagir com o consórcio ao qual pertencem. Cada transação implanta um contrato ou chama uma função no contrato para fazer upload de dados para a rede. Essas ações são replicadas para todos os nós da rede.
As transações públicas estão disponíveis para visualização por todos os participantes do consórcio. As transações privadas adicionam uma camada de confidencialidade e estão disponíveis apenas para os participantes que têm direitos para fazê-lo.
Para ambos os cenários, usamos o mesmo contrato para maior clareza.
Contrato inteligente
Abaixo está um contrato inteligente simples criado para o nosso cenário. Tem uma variável pública temperature, que pode ser alterado usando set e receba por método 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;
}
}Para que o contrato funcione com , ele deve ser traduzido para o formato ABI e bytecode. Usando a função formatContractabaixo compila o contrato usando .
function formatContract() {
const path = './contracts/temperatureMonitor.sol';
const source = fs.readFileSync(path,'UTF8');
return solc.compile(source, 1).contracts[':TemperatureMonitor'];
}O contrato concluído fica assim:
// 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
0x608060405234801561001057600080fd5b50610104806100206000396000f30060806040526004361060525763ffffffff7c01000000000000000000000000000000000000000000000000000000006000350416636d4ce63c81146057578063adccea12146082578063faee13b9146094575b600080fd5b348015606257600080fd5b50606960ae565b60408051600092830b90920b8252519081900360200190f35b348015608d57600080fd5b50606960b7565b348015609f57600080fd5b5060ac60043560000b60c0565b005b60008054900b90565b60008054900b81565b6000805491810b60ff1660ff199092169190911790555600a165627a7a72305820af0086d55a9a4e6d52cb6b3967afd764ca89df91b2f42d7bf3b30098d222e5c50029Agora que o contrato está pronto, iremos implantar a rede e implantar o contrato.
Implantação de nó
A implantação de um nó pode ser bastante trabalhosa e esse processo pode ser substituído pelo uso de um serviço .
Abaixo está o processo de implantação da rede Quorum com consenso Raft e três nós.
Primeiro, vamos criar um projeto e chamá-lo de Projeto Quorum:
Vamos criar uma rede Quorum com consenso Raft no Google Cloud Platform:
Vamos adicionar mais dois nós ao nó já criado por padrão:
Três nós em execução:
A página de detalhes do nó mostra o endpoint RPC, a chave pública, etc.
A rede está implantada. Agora vamos implantar contratos inteligentes e realizar transações usando .
Transações públicas
Contexto
A temperatura do armazém é de grande importância na redução de custos, principalmente para produtos destinados a serem armazenados em temperaturas abaixo de zero.
Ao permitir que as empresas partilhem a temperatura exterior da sua localização geográfica em tempo real e registem-na num livro imutável, os participantes da rede reduzem custos e tempo.
Realizaremos três tarefas, ilustradas no diagrama:
-
Implantaremos o contrato via Nó 1:
const contractAddress = await deployContract(raft1Node); console.log(`Contract address after deployment: ${contractAddress}`); -
Defina a temperatura através Nó 2 em 3 graus:
const status = await setTemperature(raft2Node, contractAddress, 3); console.log(`Transaction status: ${status}`); -
Nó 3 receberá informações do contrato inteligente. O contrato retornará o valor 3 graus:
const temp = await getTemperature(raft3Node, contractAddress); console.log(‘Retrieved contract Temperature’, temp);A seguir, veremos como executar uma transação pública na rede Quorum usando .
Iniciamos uma instância via RPC para três nós:
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,
},
);Vamos implantar o contrato inteligente:
// 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;
});
} fornece dois métodos para interagir com o contrato: call и send.
Vamos atualizar a temperatura do contrato executando set usando o método 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;
});
}Em seguida, usamos o método web3 call para obter a temperatura do contrato. Observe que o método call é executado em um nó local e a transação não será criada no 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);
}Agora você pode correr para obter o seguinte resultado:
// Execute public script
node public.js
Contract address after deployment: 0xf46141Ac7D6D6E986eFb2321756b5d1e8a25008F
Transaction status: true
Retrieved contract Temperature 3A seguir, podemos visualizar as entradas no Quorum Explorer no painel Chainstack, conforme mostrado abaixo.
Todos os três nós interagiram e as transações foram atualizadas:
- A primeira transação implantou o contrato.
- A segunda transação definiu a temperatura do contrato em 3 graus.
- A temperatura é recebida através de um nó local, portanto nenhuma transação é criada.
Transações privadas
Contexto
Um requisito comum das organizações é a proteção de dados. Como exemplo, considere um cenário em que Supermercado aluga um armazém para armazenar frutos do mar em um local separado Fornecedor:
- Fornecedor usando sensores IoT, lê valores de temperatura a cada 30 segundos e os transmite Para o supermercado;
- esses valores só devem estar disponíveis Para o fornecedor и Para o supermercado, interligados por um consórcio.
Concluiremos as quatro tarefas ilustradas no diagrama acima.
- Usamos os mesmos três nós do cenário anterior para demonstrar transações privadas:
- Supermercado implanta um contrato inteligente que é privado para Supermercado и Fornecedor.
- O terceiro lado não tem o direito de acessar o contrato inteligente.
Chamaremos os métodos get и set em nome de Supermercado и Fornecedor para demonstrar uma transação privada de Quorum.
-
Implantaremos um contrato privado para os participantes Supermercado и Fornecedor através de um participante Supermercado:
const contractAddress = await deployContract( raft1Node, process.env.PK2, ); console.log(`Contract address after deployment: ${contractAddress}`); -
Vamos definir a temperatura de Terceiro (nó externo) e obtenha o valor da temperatura:
// 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}`); -
Vamos definir a temperatura de Fornecedor (nó interno) e obtenha o valor da temperatura:
A temperatura neste cenário deve retornar o valor 12 do contrato inteligente. Observe que Fornecedor aqui autorizou o acesso ao contrato inteligente.
// 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}`); -
Obtemos a temperatura de Terceiro (nó externo):
No passo 3 a temperatura foi ajustada para 12, mas O terceiro lado não tem acesso ao contrato inteligente. Portanto, o valor de retorno deve ser nulo.
// This returns null const temp3 = await getTemperature(raft3Node, contractAddress); console.log(`[Node3] temp retrieved from external nodes after update ${temp}`);A seguir, examinaremos mais de perto a realização de transações privadas na rede Quorum com . Como a maior parte do código é o mesmo para transações públicas, destacaremos apenas as partes que são diferentes para transações privadas.
Observe que o contrato carregado na rede é imutável, portanto, o acesso autorizado deve ser concedido aos nós apropriados, habilitando o contrato público no momento em que o contrato é implantado, e não depois.
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;
});
}As transações privadas são realizadas de forma semelhante - incluindo a chave pública dos participantes no momento da execução.
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;
});
}Agora podemos correr com os seguintes resultados:
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 nullO Quorum Explorer em Chainstack mostrará o seguinte:
- implantação do contrato do participante Supermercado;
- Atuação
SetTemperaturede Terceiro; - Atuação
SetTemperaturede um participante Fornecedor.
Como você pode ver, ambas as transações foram concluídas, mas apenas a transação do participante Fornecedor atualizou a temperatura no contrato. Assim, as transações privadas proporcionam imutabilidade, mas ao mesmo tempo não revelam dados a terceiros.
Conclusão
Analisamos um caso de uso comercial do Quorum para fornecer informações atualizadas sobre temperatura em um armazém, implantando uma rede entre duas partes: um supermercado e o proprietário de um armazém.
Mostramos como as informações atualizadas sobre temperatura podem ser mantidas por meio de transações públicas e privadas.
Pode haver vários cenários de aplicação e, como você pode ver, não é nada difícil.
Experimente, tente expandir seu roteiro. Além disso, a indústria de tecnologia blockchain .
Fonte: habr.com