Saiba como implantar um contrato inteligente do Solidity na rede de teste Avalanche, Fuji, usando o HardHat e, em seguida, crie e implante seu subgrafo no Subgraph Studio.
Introdução
Neste tutorial, você aprenderá como implantar um contrato inteligente do Solidity na rede de teste da Avalanche, Fuji, usando o HardHat e, em seguida, criar e implantar seu subgrafo no Subgraph Studio.
O Subgraph Studio é onde você pode construir e criar subgrafos. Você pode adicionar metadados aos seus grafos (mesmo depois de implantar seus subgrafos), implantar várias versões de seus subgrafos, bem como publicá-los no Explorador Graph descentralizado. Observe que publicar um subgrafo é diferente de implantar um subgrafo. Quando você implanta um subgrafo, só você pode acessá-lo. Mas quando você o publica, ele é criado na cadeia e todos podem acessá-lo.
Você também pode testar seus subgrafos no Playground, onde pode executar consultas graphql sem incorrer em nenhuma taxa de consulta. Neste tutorial, você também aprenderá como criar e implantar seu subgrafo no Subgraph Studio usando um contrato inteligente da Avalanche.
Quando você conhece o endereço de um contrato inteligente, supondo que o contrato seja verificado no Etherscan, você pode criar facilmente um esquema de subgrafo para ele. Caso contrário, você pode fornecer o caminho local da Interface Binária de Aplicativo (Application Binary Interface ou ABI) para a Interface de Linha de Comando (CLI) do The Graph, para criar um esquema de subgrafo. Por padrão, o HardHat não exporta a ABI após a compilação do contrato inteligente. No entanto, é possível usar um plug-in HardHat para exportar automaticamente a ABI quando um contrato inteligente é compilado.
Pré-requisitos
Para concluir este tutorial com sucesso, você precisará ter uma compreensão básica da rede Avalanche, do Solidity e do ecossistema NodeJS.
Requisitos
- Você precisará da Metamask instalada em seu navegador. Você pode instalá-la em https://metamask.io/
- Você precisa ter uma versão recente do Node.js instalada. Recomendamos usar a versão v14.17.6 LTS para compatibilidade.
Configuração do projeto
Execute o seguinte comando para instalar o gerenciador de pacotes yarn e a CLI do The Graph Protocol globalmente. Eles são necessários para criar e implantar seu subgrafo.
npm i -g yarn @graphprotocol/graph-cli
Em seguida, execute os seguintes comandos para criar um novo diretório chamado vendinge altere para o diretório:
mkdir vending
cd vending
Em seguida, execute os comandos abaixo para criar um novo pacote yarn dentro dele e, em seguida, instale o Hardhat como uma dependência de desenvolvimento do projeto (o que significa que é um pacote necessário apenas para desenvolvimento e teste local).
yarn init --yes
yarn add --dev hardhat
Em seguida, execute npx hardhat para inicializar o projeto Hardhat. Isso produzirá:
888 888 888 888 888
888 888 888 888 888
888 888 888 888 888
8888888888 8888b. 888d888 .d88888 88888b. 8888b. 888888
888 888 "88b 888P" d88" 888 888 "88b "88b 888
888 888 .d888888 888 888 888 888 888 .d888888 888
888 888 888 888 888 Y88b 888 888 888 888 888 Y88b.
888 888 "Y888888 888 "Y88888 888 888 "Y888888 "Y888
Welcome to Hardhat v2.6.4
? What do you want to do? ...
▸ Create a basic sample project
Create an advanced sample project
Create an empty hardhat.config.js
Quit
Selecione "Create an empty hardhat.config.js" (Crie um hardhat.config.js vazio) rolando o menu com as setas do teclado e pressione Enter. Isso criará um arquivo hardhat.config.js na raiz do diretório vending, com o seguinte conteúdo:
/**
* @type import('hardhat/config').HardhatUserConfig
*/
module.exports = {
solidity: "0.7.3",
};
Como a rede Avalanche é compatível com a Máquina Virtual da Ethereum (EVM), você pode usar qualquer plug-in do HardHat disponível para compilar e implantar seu contrato:
yarn add --dev @nomiclabs/hardhat-ethers ethers @nomiclabs/hardhat-waffle
Escrevendo o contrato inteligente
Crie um novo diretório chamado contracts dentro do diretório vending e crie um arquivo dentro do diretório contracts chamado vending.sol.
Cole este código do Solidity nesse arquivo:
// SPDX-License-Identifier: MIT
pragma solidity 0.7.3;
contract VendingMachine {
// Armazenar o proprietário desse contrato inteligente
address owner;
// Um mapeamento é um armazenamento de chave/valor. Aqui armazenamos o saldo de cupcake desse contrato inteligente.
mapping (address => uint) cupcakeBalances;
// Os eventos são necessários para que o The Graph crie entidades
event Refill(address owner, uint amount, uint remaining, uint timestamp, uint blockNumber);
event Purchase(address buyer, uint amount, uint remaining, uint timestamp, uint blockNumber);
// Quando o contrato "VendingMachine" é implantado:
// 1. definir o endereço de implementação como o proprietário do contrato
// 2. definir o saldo de cupcake do contrato inteligente implantado como 100
constructor() {
owner = msg.sender;
cupcakeBalances[address(this)] = 100;
}
// Permitir que o proprietário aumente o saldo de cupcakes do contrato inteligente
function refill(uint amount) public onlyOwner {
cupcakeBalances[address(this)] += amount;
emit Refill(owner, amount, cupcakeBalances[address(this)], block.timestamp, block.number);
}
// Permitir que qualquer pessoa compre cupcakes
function purchase(uint amount) public payable {
require(msg.value >= amount * 0.01 ether, "Você deve pagar pelo menos 0,01 ETH por cupcake");
require(cupcakeBalances[address(this)] >= amount, "Não há cupcakes suficientes em estoque para concluir esta compra");
cupcakeBalances[address(this)] -= amount;
cupcakeBalances[msg.sender] += amount;
emit Purchase(msg.sender, amount, cupcakeBalances[address(this)], block.timestamp, block.number);
}
// Os modificadores de função são usados para modificar o comportamento de uma função.
// Quando o modificador "onlyOwner" é adicionado a uma função, somente o proprietário desse contrato inteligente pode executar essa função.
modifier onlyOwner {
// Verificar se o proprietário é o mesmo que chamou a função.
require(msg.sender == owner, "Somente o proprietário pode ser chamado");
// Esse caractere sublinhado é chamado de "coringa de mesclagem".
// Ele será substituído pelo corpo da função (ao qual adicionamos o modificador),
_;
}
}
Compilando o contrato inteligente
Instalaremos o plug-in hardhat-abi-exporter para que o HardHat exporte a ABI do contrato inteligente após a compilação:
yarn add --dev hardhat-abi-exporter
Atualize seu arquivo hardhat.config.js para usar o exportador da abi:
require('@nomiclabs/hardhat-waffle');
require('hardhat-abi-exporter');
module.exports = {
solidity: '0.7.3',
abiExporter: {
path: './abi/',
clear: true,
},
};
- path: O caminho para o diretório da exportação da ABI (relativo à raiz do projeto HardHat). O diretório será criado se não existir.
- clear: Um valor booleano que determina se arquivos antigos devem ser excluídos do caminho especificado na compilação.
O HardHat usará a versão especificada do solc (v0.7.3) para compilar seu contrato inteligente. Execute:
npx hardhat compile
Supondo que não haja erros ou avisos, isso produzirá:
Compiling 1 file with 0.7.3
Compilation finished successfully
O contrato inteligente vending.sol agora foi compilado com sucesso. A ABI será armazenada em abi/contracts/vending.sol/VendingMachine.json.
Implantando o contrato inteligente
Embora esta etapa não seja necessária para criar o seu subgrafo, você ainda pode implantar seu contrato inteligente para aprender sobre a rede Avalanche e o DataHub.
Adicione as constantes FUJI_PRIVATE_KEYe DATAHUB_API_KEY,bem como uma entrada para redes em seu arquivo hardhat.config.js:
require('@nomiclabs/hardhat-waffle');
require('hardhat-abi-exporter');
// Substitua essa chave privada pela chave privada de sua carteira Fuji
const FUJI_PRIVATE_KEY = 'YOUR_FUJI_PRIVATE_KEY';
// Substitua isso por sua chave de API do Datahub
const DATAHUB_API_KEY = 'YOUR_DATAHUB_API_KEY';
module.exports = {
solidity: '0.7.3',
abiExporter: {
path: './abi/',
clear: true,
},
networks: {
fuji: {
url: `https://avalanche--fuji--rpc.datahub.figment.io/apikey/${DATAHUB_API_KEY}/ext/bc/C/rpc`,
accounts: [`0x${FUJI_PRIVATE_KEY}`],
},
},
};
Obtendo sua chave de API do Datahub
Para obter a sua DATAHUB_API_KEY, acesse !(https://datahub.figment.io/sign_up) e crie uma conta gratuita.
Clique no link de verificação que você receberá em seu e-mail. Após a verificação do e-mail, você será redirecionado para https://datahub.figment.io/.
Clique no botão Avalanchepara visualizar o Painel de Serviços da Avalanche em https://datahub.figment.io/services/avalanche. Você pode copiar sua chave de API para a área de transferência clicando no botão copiar.
Obtendo sua chave privada da Metamask
Você precisa adicionar uma conexão com a rede de testes da Avalanche, Fuji, na sua Metamask seguindo as instruções abaixo (lembre-se de substituir <YOUR DATAHUB_API_KEY> no URL RPC pela sua chave de API do DataHub real):
- Entrar na Metamask
- Clique no menu suspenso
Network - Selecione
Custom RPC - Preencha os detalhes:
- Nome da Rede: Avalanche FUJI C-Chain
-
Novo URL de RPC (New RPC URL):
https://avalanche--fuji--rpc.datahub.figment.io/apikey/<YOUR DATAHUB_API_KEY>/ext/bc/C/rpc -
ID da Cadeia (ChainID):
43113 -
Símbolo (Symbol):
AVAX -
Explorador (Explorer):
https://cchain.explorer.avax-test.network
Você também precisará de alguns tokens Fuji AVAX em sua carteira Metamask. Siga as instruções abaixo:
- Acesse https://faucet.avax-test.network/ e cole o endereço da sua carteira Metamask.
- Preencha o captcha e clique no botão Request (Solicitar).
- Você receberá 10 Fuji AVAX assim que sua transação for minerada.
Para obter sua FUJI_PRIVATE_KEY, abra seu navegador e abra a Metamask. Selecione a rede Avalanche FUJI C-Chain. Clique em Account details (Detalhes da conta) e clique em Export Private Key.
Nunca compartilhe sua chave privada com ninguém!
Crie um subdiretório dentro do projeto HardHat chamado scripts e cole o seguinte código em um novo arquivo deploy.js dentro do diretório scripts:
async function main() {
const [deployer] = await ethers.getSigners();
console.log("Implantando contratos com a conta:", deployer.address);
console.log("Saldo da conta:", (await deployer.getBalance()).toString());
const VendingMachine = await ethers.getContractFactory("VendingMachine");
const vendingMachine = await VendingMachine.deploy();
console.log("Endereço do contrato:", vendingMachine.address);
}
main()
.then(() => process.exit(0))
.catch((error) => {
console.error(error);
process.exit(1);
});
Para implantar o contrato inteligente na rede de testes Fuji usando o HardHat, execute o comando:
npx hardhat run scripts/deploy.js --network fuji
Isso produzirá:
Deploying contracts with the account: <YOUR FUJI WALLET ADDRESS>
Account balance: <YOUR FUJI WALLET BALANCE>
Contract address: <YOUR FUJI SMART CONTRACT ADDRESS>
Parabéns! Você acabou de implantar seu contrato inteligente com sucesso na rede de testes Fuji! Vamos precisar do endereço do contrato para criar o subgrafo, então lembre-se de copiá-lo.
Criando o subgrafo
Execute o seguinte comando para criar o subgrafo baixando a ABI do contrato da rede de testes Fuji. Um novo diretório chamado vending será criado e todas as dependências do nó serão instaladas automaticamente.
graph init \
--contract-name VendingMachine \
--index-events \
--studio \
--from-contract <YOUR FUJI SMART CONTRACT ADDRESS> \
--abi abi/contracts/vending.sol/VendingMachine.json \
--network fuji \
vending
Substitua <YOUR FUJI SMART CONTRACT ADDRESS>pelo endereço de contrato inteligente da VendingMachine implantado acima.
Se você estiver usando o Windows, substitua os caracteres \ no comando acima por ^.
Isso produzirá:
✔ Subgraph slug · vending
✔ Directory to create the subgraph in · vending
✔ Ethereum network · fuji
✔ Contract address · <YOUR FUJI SMART CONTRACT ADDRESS>
✔ ABI file (path) · abi/contracts/vending.sol/VendingMachine.json
✔ Contract Name · VendingMachine
------
Generate subgraph from ABI
Write subgraph to directory
✔ Create subgraph scaffold
✔ Initialize subgraph repository
✔ Install dependencies with yarn
✔ Generate ABI and schema types with yarn codegen
Subgraph vending created in vending
Next steps:
1. Run `graph auth` to authenticate with your deploy key.
2. Type `cd vending` to enter the subgraph.
3. Run `yarn deploy` to deploy the subgraph.
Make sure to visit the documentation on https://thegraph.com/docs/ for further information.
Ele deve criar três arquivos:
-
subgraph.yaml: É aqui que o manifesto do subgrafo é armazenado. -
schema.graphql: Isso define os dados a serem armazenados e como eles podem ser consultados usando o GraphQL. -
src/mapping.ts: Este arquivo AssemblyScript define o mapeamento entre eventos da blockchain para as entidades de esquema.
Criando o projeto no Subgraph Studio
Primeiro, você deve ir ao Subgraph Studio em https://thegraph.com/studio/.
Clique no botão Connect Wallet (Conectar Carteira). Escolha uma carteira Metamask para fazer login. Uma vez autenticado, você verá a tela abaixo, onde poderá criar seu primeiro subgrafo.
Em seguida, você precisa dar um nome ao seu subgrafo. Dê o nome como vending. Feito isso, você verá esta tela:
Nesta tela, você pode ver detalhes sobre o subgrafo, como sua chave de implantação, o slug do subgrafo e o status.
Implantando o subgrafo
Antes de poder implantar seu subgrafo, você precisa obter sua chave de implantação em https://thegraph.com/studio/subgraph/vending/. Isso é usado para autenticar sua conta no Subgraph Studio.
Execute os seguintes comandos para definir sua chave de implantação.
cd vending
graph auth --studio <DEPLOY_KEY>
Você deve ver a seguinte saída:
Deploy key set for https://api.studio.thegraph.com/deploy/
Feito isso, você pode executar yarn deploy para implantar o subgrafo no Subgraph Studio. Quando for solicitado um rótulo de versão, você pode escolher v1.0.0. Você deve ver a seguinte saída:
yarn run v1.22.11
$ graph deploy --node https://api.studio.thegraph.com/deploy/ vending
✔ Version Label (e.g. v0.0.1) · 1.0.0
Skip migration: Bump mapping apiVersion from 0.0.1 to 0.0.2
Skip migration: Bump mapping apiVersion from 0.0.2 to 0.0.3
Skip migration: Bump mapping apiVersion from 0.0.3 to 0.0.4
Skip migration: Bump mapping apiVersion from 0.0.4 to 0.0.5
Skip migration: Bump mapping specVersion from 0.0.1 to 0.0.2
✔ Apply migrations
✔ Load subgraph from subgraph.yaml
Compile data source: VendingMachine => build/VendingMachine/VendingMachine.wasm
✔ Compile subgraph
Copy schema file build/schema.graphql
Write subgraph file build/VendingMachine/abis/VendingMachine.json
Write subgraph manifest build/subgraph.yaml
✔ Write compiled subgraph to build/
Add file to IPFS build/schema.graphql
.. QmeSYhiAZ4m7wa5KHnyUGdTDLfha5Lknp3LhpJwbecRVGw
Add file to IPFS build/VendingMachine/abis/VendingMachine.json
.. QmbSWXTRVwvi9umMqhfMFT2EGUF4JPcuBfPUhMLAMpLkXn
Add file to IPFS build/VendingMachine/VendingMachine.wasm
.. QmYjyCCaJdrhEqc8gHPVrWPgcgsfPoULkhzcGLwXZMovCQ
✔ Upload subgraph to IPFS
Build completed: QmZMq8pfqkxvZufKKSeUYKwuNRyAbb2aGxogHPPUxBZ3XA
Deployed to https://thegraph.com/studio/subgraph/vending
Subgraph endpoints:
Queries (HTTP): https://api.studio.thegraph.com/query/8676/vending/1.0.0
Subscriptions (WS): https://api.studio.thegraph.com/query/8676/vending/1.0.0
Done in 13.39s.
Agora você implantou o subgrafo em sua conta do Subgraph Studio!
Conclusão
Parabéns por terminar este tutorial! Você aprendeu como implantar um contrato inteligente na rede de teste da Avalanche, Fuji, usando o HardHat. Você também aprendeu como criar e implantar um subgrafo para o contrato inteligente no Subgraph Studio.
Sobre o autor
Sou Robin Thomas, um entusiasta da blockchain, com alguns anos de experiência, trabalhando com vários protocolos blockchain. Sinta-se à vontade para se conectar comigo no GitHub.
Artigo escrito por Robin Thomas. Traduzido por Marcelo Panegali
Top comments (0)