Ir para o conteúdo
Buscar

WEB3DEV

Cover image for Implantar um Subgrafo Para um Contrato Inteligente da Avalanche
Panegali
Panegali

Posted on

Implantar um Subgrafo Para um Contrato Inteligente da Avalanche

#avalanche #subgrafo

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
Enter fullscreen mode Exit fullscreen mode

Em seguida, execute os seguintes comandos para criar um novo diretório chamado vendinge altere para o diretório:

mkdir vending
cd vending
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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",
};
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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),
        _;
    }
}
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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,
  },
};
Enter fullscreen mode Exit fullscreen mode
  • 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
Enter fullscreen mode Exit fullscreen mode

Supondo que não haja erros ou avisos, isso produzirá:

Compiling 1 file with 0.7.3
Compilation finished successfully
Enter fullscreen mode Exit fullscreen mode

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}`],
    },
  },
};
Enter fullscreen mode Exit fullscreen mode

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);
  });
Enter fullscreen mode Exit fullscreen mode

Para implantar o contrato inteligente na rede de testes Fuji usando o HardHat, execute o comando:

npx hardhat run scripts/deploy.js --network fuji
Enter fullscreen mode Exit fullscreen mode

Isso produzirá:

Deploying contracts with the account: <YOUR FUJI WALLET ADDRESS>
Account balance: <YOUR FUJI WALLET BALANCE>
Contract address: <YOUR FUJI SMART CONTRACT ADDRESS>
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

Substitua &lt;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.
Enter fullscreen mode Exit fullscreen mode

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>
Enter fullscreen mode Exit fullscreen mode

Você deve ver a seguinte saída:

Deploy key set for https://api.studio.thegraph.com/deploy/
Enter fullscreen mode Exit fullscreen mode

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.
Enter fullscreen mode Exit fullscreen mode

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)


Leia o próximo

valterlobo profile image

Desenvolvendo um Token na Blockchain Solana com JavaScript

Valter Lobo -

isabelacnehme profile image

Revisão do Erro de Arredondamento no Bugfix do Protocolo Balancer

Isabela Curado Nehme -

diogojorg3 profile image

Construindo um Contrato Inteligente para Cadeia de Suprimentos Agro com Solidity na Celo

Diogo Jorge -

diogojorg3 profile image

Nos bastidores do protocolo zkSNARK Groth16 (parte 1)

Diogo Jorge -