> For the complete documentation index, see [llms.txt](https://docs.chiliz.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.chiliz.com/pt-br/desenvolver/avancado/acompanhar-transferencias-fan-token.md).

# Acompanhar transferências de um Fan Token

Rastrear movimentações de Fan Tokens na Chiliz Chain é uma ótima forma de monitorar a atividade dos seus tokens favoritos. Ao usá-lo como base para um potencial dashboard, você pode organizar dados para fornecer insights sobre o que está em alta e o que não está.

Ao rastrear movimentações de Fan Tokens™, você rapidamente se depara com um desafio: ler dados diretamente do blockchain é eficiente para o status atual ("*Qual é o saldo da carteira X?*"), mas ineficiente para dados históricos ("*Mostre-me todas as transferências envolvendo a carteira X no último ano*").

Para resolver isso, podemos usar subgraphs.

## Sobre subgraphs

Um Subgraph é uma API personalizada que extrai dados de um blockchain, os processa e os armazena para que possam ser facilmente consultados.\
Em vez de pedir ao blockchain para escanear milhões de blocos cada vez que você precisa de dados, um subgraph indexa eventos específicos conforme acontecem e os armazena em um banco de dados.

A Chiliz Chain suporta protocolos de indexação padrão da indústria. Você pode escolher o provedor que melhor atende às necessidades do seu projeto:

* [The Graph](https://thegraph.com/): O padrão da indústria para indexação descentralizada. Permite implantar seu subgraph em uma rede descentralizada de indexadores.
* [Goldsky](https://goldsky.com/): Um serviço de indexação hospedado de alto desempenho. É totalmente compatível com o código do The Graph (muitas vezes você pode usar exatamente o mesmo código), mas oferece velocidades de indexação mais rápidas e recursos de streaming de dados em tempo real.

Ambas as ferramentas usam o mesmo framework de desenvolvimento, então a maioria dos passos nesta página se aplica a ambas.

Vamos ver, por exemplo, como poderíamos acompanhar transferências do Fan Token PSG...

## 0. Escolha uma ferramenta

Você pode implantar um subgraph na Chiliz Chain usando **The Graph** (rede descentralizada) ou **Goldsky** (indexador hospedado). A estrutura de código é idêntica; apenas os comandos de implantação diferem.

Naturalmente, você pode consultar as próprias documentações deles:

{% embed url="<https://thegraph.com/docs/en/subgraphs/quick-start/>" %}

{% embed url="<https://docs.goldsky.com/subgraphs/deploying-subgraphs>" %}

## 1. Inicializar um projeto de subgraph

Tanto The Graph quanto Goldsky oferecem métodos baseados em CLI para criar seu graph.

{% hint style="info" %}
O The Graph tem o [Subgraph Studio](https://thegraph.com/studio/), ao qual você pode se conectar usando sua carteira Web3, e então criar um subgraph pela interface.

O Goldsky oferece um [dashboard](https://app.goldsky.com/) quando você cria uma conta, a partir do qual pode criar um subgraph.
{% endhint %}

### Instalar a Graph CLI

No seu computador local, execute:

```bash
npm install -g @graphprotocol/graph-cli
```

{% hint style="info" %}
Você pode criar um subgraph usando a ferramenta CLI do The Graph tanto para subgraphs descentralizados do The Graph quanto para subgraphs hospedados pelo Goldsky.

O Goldsky tem sua própria ferramenta CLI, que você precisará se quiser implantar no Goldsky (veja abaixo).
{% endhint %}

### Inicializar seu subgraph

Você pode copiar isso diretamente da sua página de subgraph para incluir seu slug específico:

```bash
graph init --studio <SUBGRAPH_SLUG>
```

A tag `--studio` é opcional.

No nosso exemplo do Fan Token PSG, podemos usar:

```bash
graph init chiliz-psg-fantoken-followup
```

Você será solicitado a fornecer algumas informações sobre seu subgraph, assim:

<figure><img src="/files/kWlhbAVSF1eGS2ExYQb8" alt=""><figcaption></figcaption></figure>

Você precisa ter seu contrato verificado no block explorer, e a CLI obterá automaticamente a ABI e configurará seu subgraph. As configurações padrão gerarão uma entidade para cada evento.

{% hint style="warning" %}
Nota:

* Se o contrato usa um proxy, como o Fan Token PSG usa, então use o endereço do contrato de implementação. Você o verá na aba "Read/write contract" na página do contrato no block explorer. Por exemplo, [veja aqui o contrato do Fan Token PSG no Chiliz Block Explorer](https://scan.chiliz.com/token/0xc2661815C69c2B3924D3dd0c2C1358A1E38A3105?tab=read_write_contract).
  * Se você teve que inserir o endereço do contrato de implementação de um proxy, após o projeto estar configurado, vá para o arquivo de manifesto (`subgraph.yaml`) e altere o endereço do contrato para o endereço do proxy.
* Se o Start Block não for obtido automaticamente, você pode inserir manualmente o número do bloco onde o contrato foi criado. Isso pode ser obtido no block explorer.
  {% endhint %}

{% hint style="info" %}
Ao fazer alterações no seu subgraph, você trabalhará principalmente com três arquivos:

* O Manifesto (`subgraph.yaml`): Define quais fontes de dados seu subgraph indexará.
* O Schema (`schema.graphql`): Define quais dados você deseja recuperar do subgraph.
* Mapeamentos AssemblyScript (`mapping.ts`): Traduz dados das suas fontes de dados para as entidades definidas no schema.
  {% endhint %}

Abra o `subgraph.yaml` e certifique-se de que o arquivo de manifesto aponta para a rede correta:

```yaml
dataSources:
  - kind: ethereum
    name: FanToken
    network: chiliz  # Use 'chiliz' para Mainnet, chiliz-testnet para Spicy
    source:
      address: "0x..." 
      abi: FanToken
```

### Compile seu subgraph

Por fim, compile seu subgraph para garantir que não há erros:

```bash
graph codegen && graph build
```

## 2. Implantar e Publicar

Com seu subgraph construído, escolha seu provedor para implantá-lo.

{% columns %}
{% column %}
**The Graph**

1. Conecte-se ao [Subgraph Studio](https://thegraph.com/studio/), crie um subgraph e copie sua chave de implantação.
2. Autentique pela CLI:\
   `graph auth --studio <DEPLOY_KEY>`
3. Implante seu subgraph no Subgraph Studio:\
   `graph deploy --studio <SUBGRAPH_SLUG>`
4. Vá ao Studio, abra seu subgraph e clique em "Publish" para mintar seu subgraph na rede descentralizada.\
   Isso acionará uma transação pela sua carteira para publicar seu subgraph como um NFT na rede Arbitrum One.
   {% endcolumn %}

{% column %}
**Goldsky**

1. Vá ao [Goldsky](https://app.goldsky.com/), crie uma chave de API em "Project Settings" e faça login pela CLI.
2. Instale o comando `goldsky`:\
   `curl https://goldsky.com | sh`\
   Em seguida, autentique pela CLI:\
   `goldsky login`
3. Faça upload do seu subgraph para o Goldsky:\
   `goldsky subgraph deploy / --path`

Os subgraphs do Goldsky ficam ativos imediatamente após a implantação. Nenhuma etapa extra de publicação é necessária.
{% endcolumn %}
{% endcolumns %}

{% hint style="info" %}
Você será solicitado a fornecer um rótulo de versão. Você pode inserir algo como `v0.0.1`, mas pode escolher o formato que quiser. Feito isso, você verá o subgraph começar a sincronizar na página do Studio.
{% endhint %}

{% hint style="info" %}
Os smart contracts do The Graph estão todos no [Arbitrum One](https://arbitrum.io/arbitrum-101), mesmo que seu subgraph esteja indexando dados da Chiliz Chain.
{% endhint %}

## 3. Consultar seu Subgraph

Parabéns! Você agora pode começar a consultá-lo passando uma consulta GraphQL para a URL de consulta do subgraph, que pode ser encontrada no dashboard do serviço escolhido.

Exemplo:

{% columns %}
{% column %}
**The Graph**

`https://gateway-arbitrum.network.thegraph.com/api/[APIKEY]/subgraphs/id/[ID]`
{% endcolumn %}

{% column %}
**Goldsky**

`https://api.goldsky.com/api/public/project_[KEY]/subgraphs/[SLUG]/1.0.0/gn`
{% endcolumn %}
{% endcolumns %}

Agora, você só precisa preencher seus detalhes para começar a enviar consultas GraphQL para esse endpoint.

## Apêndices

### Consulta de Exemplo

Esta consulta mostra todas as transações do Fan Token PSG.

```typescript
const axios = require('axios');

// The GraphQL query (Identical for both providers)
const graphqlQuery = `{
  transfers {
    from
    to
    value
    transactionHash
  }
}`;

// Choose the right URL format depending on the provider:
// const queryUrl = 'https://gateway-arbitrum.network.thegraph.com/api/[api-key]/subgraphs/id/[id]'
// const queryUrl = 'https://api.goldsky.com/api/public/project_[key]/subgraphs/[slug]/1.0.0/gn';

const graphQLRequest = {
  method: 'post',
  url: queryUrl,
  data: {
    query: graphqlQuery,
  },
};

// Send the GraphQL query
axios(graphQLRequest)
  .then((response) => {
    // Handle the response here
    const data = response.data.data
    console.log(data)

  })
  .catch((error) => {
    // Handle any errors
    console.error(error);
  });
```

### Código de Exemplo

```json
{
  "data": {
    "transfers": [
      {
        "from": "0x26a3e78fa4d2cbebf6b59b2f84b8fb7c61b52d28",
        "to": "0xdca23d02923d01779fb22959bd2575d64eab4535",
        "value": "1500",
        "transactionHash": "0x000309e9cd3f550e8965381bbd83a35c5cee18f26c33a357f9dbb57450d594ea"
      },
//      ...
  }
}
```

## Recursos adicionais

Para mais informações sobre como consultar dados do seu subgraph com GraphQL:

{% embed url="<https://thegraph.com/docs/en/subgraphs/querying/best-practices/>" %}


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.chiliz.com/pt-br/desenvolver/avancado/acompanhar-transferencias-fan-token.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.