Indexing Uniswap data with subgraphs

npm install -g @graphprotocol/graph-cli

graph -v

.
├── abis
│   └── UniswapV3Factory.json
├── networks.json
├── package.json
├── schema.graphql
├── src
│   └── uniswap-v-3-factory.ts
├── subgraph.yaml
├── tests
│   ├── uniswap-v-3-factory.test.ts
│   └── uniswap-v-3-factory-utils.ts
└── tsconfig.json

type Pool @entity {
  id: ID! #id
  token0: Token! #first token in the pair
  token1: Token! #second token in the pair
  feeAmount: BigInt! #The desired fee for the pool
  timestamp: BigInt! #the block timestamp
  blockNumber: BigInt! #block number

}

type Token @entity {
  id: ID!
  symbol: String! #token symbol
  name: String! #token name
}

├── abis
│   ├── ERCToken.json
│   └── UniswapV3Factory.json
├── networks.json
├── package.json
├── schema.graphql
├── src
│   └── uniswap-v-3-factory.ts
├── subgraph.yaml
├── tests
│   ├── uniswap-v-3-factory.test.ts
│   └── uniswap-v-3-factory-utils.ts
└── tsconfig.json

specVersion: 0.0.5
schema:
  file: ./schema.graphql
dataSources:
  - kind: ethereum
    name: UniswapV3Factory
    network: mainnet
    source:
      address: "0x1F98431c8aD98523631AE4a59f267346ea31F984"
      abi: UniswapV3Factory
      startBlock: 14974589
    mapping:
      kind: ethereum/events
      apiVersion: 0.0.7
      language: wasm/assemblyscript
      entities:
        - Pool
        - Token
      abis:
        - name: UniswapV3Factory
          file: ./abis/UniswapV3Factory.json
        - name: ERCToken
          file: ./abis/ERCToken.json
      eventHandlers:
        - event: PoolCreated(indexed address,indexed address,indexed uint24,int24,address)
          handler: handlePoolCreated
      file: ./src/uniswap-v-3-factory.ts

graph codegen

├── schema.ts
└── UniswapV3Factory
    ├── ERCToken.ts
    └── UniswapV3Factory.ts

      eventHandlers:
        - event: PoolCreated(indexed address,indexed address,indexed uint24,int24,address)
          handler: handlePoolCreated

//fetch class from generated file
import { ERCToken } from "../generated/UniswapV3Factory/ERCToken"
//import datatype
import { Address } from '@graphprotocol/graph-ts'

/*
function to get the token name
parameter: Address of the token
returns: token name (type: string)
*/
export function getTokenName(tokenAddress: Address): string {
	//binding the address
  let contract = ERCToken.bind(tokenAddress)
  let tokenName = 'unknown'

	// calling the try_name() function to retrieve the name
	// the function definition can be found in:
	// ../generated/UniswapV3Factory/ERCToken
  let name = contract.try_name()
  if (!name.reverted) {
    tokenName = name.value
  }
	//return token name
  return tokenName
}
/*
function to get the token symbol
parameter: Address of the token
returns: token symbol (type: string)
*/
export function getTokenSymbol(tokenAddress: Address): string {
	//binding the address
  let contract = ERCToken.bind(tokenAddress)
  let tokenSymbol = 'unknown'
	// calling the try_symbol() function to retrieve the name
	// the function definition can be found in:
	// ../generated/UniswapV3Factory/ERCToken
  let symbol = contract.try_symbol()
  if (!symbol.reverted) {
    tokenSymbol = symbol.value
  }
	//return token symbol
  return tokenSymbol
}

//import event class from generated files
import {
  PoolCreated as PoolCreatedEvent
} from "../generated/UniswapV3Factory/UniswapV3Factory"
//import entity classes from generated files
import {
  Pool,Token
} from "../generated/schema"
//import functions from tokenUtils
import {
  getTokenName,getTokenSymbol
} from "./tokenUtils"
//import type
import { BigInt } from '@graphprotocol/graph-ts'

//function for handling PoolCreatedEvent
export function handlePoolCreated(event: PoolCreatedEvent): void {
  // loading the entities
  // Here, the id of the token is essentially its address
  // converted to string. While loading, we use the id to see
  // if an entity with that id exists
  let token0 = Token.load(event.params.token0.toHexString())
  let token1 = Token.load(event.params.token1.toHexString())
    // check if entity is empty null
  if (token0 === null) { //if empty
		// create new entity
		// while creating new Token entity, the address of the token is
    // converted to string and it is passed as the id
    token0 = new Token(event.params.token0.toHexString())
    token0.name = getTokenName(event.params.token0) //get name
    token0.symbol = getTokenSymbol(event.params.token0) //get symbol
  }
  if (token1 === null) {
    token1 = new Token(event.params.token1.toHexString())
    token1.name = getTokenName(event.params.token1)
    token1.symbol = getTokenSymbol(event.params.token1)

  }
	//create new entity
	// here, the address of the pool is converted to string
  // and passed as the id
  let pool = new Pool(event.params.pool.toHexString()) as Pool
  pool.token0 = token0.id //set token id
  pool.token1 = token1.id
  pool.timestamp = event.block.timestamp //set timestamp
  pool.blockNumber = event.block.number //set block number
  pool.feeAmount = BigInt.fromI32(event.params.fee) //set fee

	//save entities
  token0.save()
  token1.save()
  pool.save()
}

graph codegen &&  graph build

{
  pools(first: 10){
    id
    token0{
      name
      id
      symbol
    }
    token1{
      name
      id
      symbol
    }
    blockNumber
    timestamp
  }
}

{
  tokens(first: 10){
    id
    name
    symbol
  }
}

curl -g \-X POST \-H "Content-Type: application/json" \-d '{"query":"{pools(first:10){id token0{id name symbol} token1{id name symbol} timestamp blockNumber}}"}' \<Chainstack-Query-URL>