> 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/pl/tworzenie/zaawansowane/sledzenie-transferow-fan-tokena.md).

# Śledzenie transferów Fan Tokena

Śledzenie ruchów Fan Tokens na Chiliz Chain to świetny sposób na monitorowanie aktywności ulubionych tokenów. Używając tego jako bloku budulcowego dla potencjalnego dashboardu, możesz organizować dane, aby dostarczać wgląd w to, co jest popularne, a co nie.

Podczas śledzenia ruchów Fan Tokens szybko napotkasz wyzwanie: odczytywanie danych bezpośrednio z blockchaina jest wydajne dla aktualnego stanu ("*Jakie jest saldo portfela X?*"), ale nieefektywne dla danych historycznych ("*Pokaż mi każdy transfer dotyczący portfela X w ciągu ostatniego roku*").

Aby rozwiązać ten problem, możemy użyć subgrafów.

## O subgrafach

Subgraf to niestandardowe API, które wyodrębnia dane z blockchaina, przetwarza je i przechowuje, aby można je było łatwo wyszukiwać.\
Zamiast prosić blockchain o skanowanie milionów bloków za każdym razem, gdy potrzebujesz danych, subgraf indeksuje konkretne zdarzenia w miarę ich wystąpienia i przechowuje je w bazie danych.

Chiliz Chain obsługuje standardowe protokoły indeksowania branżowego. Możesz wybrać dostawcę najlepiej pasującego do potrzeb projektu:

* [The Graph](https://thegraph.com/): Branżowy standard zdecentralizowanego indeksowania. Pozwala wdrażać subgraf w zdecentralizowanej sieci indekserów.
* [Goldsky](https://goldsky.com/): Wydajna, hostowana usługa indeksowania. Jest w pełni kompatybilna z kodem The Graph (często możesz użyć dokładnie tego samego kodu), ale oferuje szybsze indeksowanie i funkcje strumieniowania danych w czasie rzeczywistym.

Oba narzędzia używają tego samego frameworka developerskiego, więc większość kroków na tej stronie dotyczy obu.

Zobaczmy, jak możemy śledzić transfery Fan Tokena PSG...

## 0. Wybierz narzędzie

Możesz wdrożyć subgraf na Chiliz Chain używając **The Graph** (zdecentralizowana sieć) lub **Goldsky** (hostowany indekser). Struktura kodu jest identyczna; różnią się tylko polecenia wdrożenia.

Oczywiście możesz korzystać z ich własnych dokumentacji:

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

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

## 1. Zainicjuj projekt subgrafu

Zarówno The Graph, jak i Goldsky oferują metody CLI do tworzenia grafu.

{% hint style="info" %}
The Graph posiada [Subgraph Studio](https://thegraph.com/studio/), z którym możesz połączyć się swoim portfelem Web3, a następnie tworzyć subgrafy przez interfejs.

Goldsky daje Ci [dashboard](https://app.goldsky.com/) po utworzeniu konta, z którego możesz tworzyć subgrafy.
{% endhint %}

### Zainstaluj Graph CLI

Na lokalnym komputerze uruchom:

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

{% hint style="info" %}
Możesz tworzyć subgrafy używając narzędzia CLI z The Graph dla subgrafów zdecentralizowanych The Graph lub subgrafów hostowanych Goldsky.

Goldsky ma własne narzędzie CLI, którego będziesz potrzebować do wdrożenia na Goldsky (patrz poniżej).
{% endhint %}

### Zainicjuj swój subgraf

Możesz skopiować to bezpośrednio ze strony subgrafu, aby uwzględnić swój konkretny slug subgrafu:

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

Tag `--studio` jest opcjonalny.

W naszym przykładzie Fan Tokena PSG możemy użyć:

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

Zostaniesz poproszony o podanie informacji o subgrafie:

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

Kontrakt musi być zweryfikowany w block explorerze, a CLI automatycznie pobierze ABI i skonfiguruje subgraf. Domyślne ustawienia wygenerują encję dla każdego zdarzenia.

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

* Jeśli kontrakt używa proxy, jak Fan Token PSG, użyj adresu kontraktu implementacji zamiast tego. Znajdziesz go w zakładce "Read/write contract" na stronie kontraktu w block explorerze. Na przykład [patrz tutaj dla kontraktu Fan Tokena PSG na Chiliz Block Explorer](https://scan.chiliz.com/token/0xc2661815C69c2B3924D3dd0c2C1358A1E38A3105?tab=read_write_contract).
  * Jeśli musiałeś wpisać adres kontraktu implementacji proxy, po skonfigurowaniu projektu przejdź do pliku manifestu (`subgraph.yaml`) i zmień adres kontraktu na adres proxy.
* Jeśli Blok Startowy nie został automatycznie pobrany, możesz ręcznie wpisać numer bloku, w którym kontrakt został stworzony. Możesz go uzyskać z block explorera.
  {% endhint %}

{% hint style="info" %}
Podczas wprowadzania zmian w subgrafie, będziesz głównie pracować z trzema plikami:

* Manifest (`subgraph.yaml`): Definiuje źródła danych, które subgraf będzie indeksował.
* Schemat (`schema.graphql`): Definiuje dane, które chcesz pobierać z subgrafu.
* Mapowania AssemblyScript (`mapping.ts`): Tłumaczy dane ze źródeł danych na encje zdefiniowane w schemacie.
  {% endhint %}

Otwórz `subgraph.yaml` i upewnij się, że plik manifestu wskazuje na prawidłową sieć:

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

### Skompiluj swój subgraf

Na koniec skompiluj subgraf, aby upewnić się, że nie ma błędów:

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

## 2. Wdróż i opublikuj

Gdy subgraf jest zbudowany, wybierz dostawcę do jego wdrożenia.

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

1. Połącz się z [Subgraph Studio](https://thegraph.com/studio/), utwórz subgraf i skopiuj klucz wdrożenia.
2. Uwierzytelnij się przez CLI:\
   `graph auth --studio <DEPLOY_KEY>`
3. Wdróż subgraf do Subgraph Studio:\
   `graph deploy --studio <SUBGRAPH_SLUG>`
4. Przejdź do Studio, otwórz swój subgraf i kliknij "Publish", aby zmintować subgraf do zdecentralizowanej sieci.\
   Spowoduje to transakcję przez portfel, aby opublikować subgraf jako NFT w sieci Arbitrum One.
   {% endcolumn %}

{% column %}
**Goldsky**

1. Przejdź do [Goldsky](https://app.goldsky.com/), utwórz klucz API w "Project Settings" i zaloguj się przez CLI.
2. Zainstaluj polecenie `goldsky`:\
   `curl https://goldsky.com | sh`\
   Następnie uwierzytelnij się przez CLI:\
   `goldsky login`
3. Prześlij subgraf do Goldsky:\
   `goldsky subgraph deploy / --path`

Subgrafy Goldsky są aktywne natychmiast po wdrożeniu. Nie jest potrzebny żaden dodatkowy krok publikacji.
{% endcolumn %}
{% endcolumns %}

{% hint style="info" %}
Zostaniesz poproszony o etykietę wersji. Możesz wpisać coś w stylu `v0.0.1`, ale format jest dowolny. Po tym zobaczysz, jak subgraf zaczyna synchronizować się na stronie Studio.
{% endhint %}

{% hint style="info" %}
Smart kontrakty The Graph są wszystkie na [Arbitrum One](https://arbitrum.io/arbitrum-101), mimo że Twój subgraf indeksuje dane z Chiliz Chain.
{% endhint %}

## 3. Zapytaj swój subgraf

Gratulacje! Możesz teraz zacząć wysyłać zapytania, przekazując zapytanie GraphQL do URL zapytań subgrafu, który można znaleźć w panelu wybranej usługi.

Przykład:

{% 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 %}

Teraz wystarczy uzupełnić szczegóły, aby zacząć wysyłać zapytania GraphQL do tego endpointu.

## Dodatki

### Przykładowe zapytanie

To zapytanie pokazuje wszystkie transakcje Fan Tokena 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);
  });
```

### Przykładowy kod

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

## Dodatkowe zasoby

Więcej informacji o wysyłaniu zapytań do subgrafu przez 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/pl/tworzenie/zaawansowane/sledzenie-transferow-fan-tokena.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.