Subgraphs

specVersion: 0.0.4
schema:
  file: ./schema.graphql
dataSources:
  - kind: ethereum/contract
    name: MyContract
    network: mainnet
    source:
      address: "0x1234..."
      abi: MyContract
      startBlock: 12345678
    mapping:
      kind: ethereum/events
      apiVersion: 0.0.7
      language: wasm/assemblyscript
      entities:
        - User
        - Transaction
      abis:
        - name: MyContract
          file: ./abis/MyContract.json
      eventHandlers:
        - event: Transfer(indexed address,indexed address,uint256)
          handler: handleTransfer
      file: ./src/mapping.ts

type User @entity {
  id: ID!
  address: Bytes!
  balance: BigInt!
  transactions: [Transaction!]! @derivedFrom(field: "user")
  createdAt: BigInt!
  updatedAt: BigInt!
}

type Transaction @entity {
  id: ID!
  hash: Bytes!
  from: User!
  to: User!
  value: BigInt!
  timestamp: BigInt!
  blockNumber: BigInt!
}

import { Transfer } from "../generated/MyContract/MyContract"
import { User, Transaction } from "../generated/schema"
import { BigInt } from "@graphprotocol/graph-ts"

export function handleTransfer(event: Transfer): void {
  // Load or create sender
  let sender = User.load(event.params.from.toHex())
  if (sender == null) {
    sender = new User(event.params.from.toHex())
    sender.address = event.params.from
    sender.balance = BigInt.fromI32(0)
    sender.createdAt = event.block.timestamp
  }
  
  // Update sender balance
  sender.balance = sender.balance.minus(event.params.value)
  sender.updatedAt = event.block.timestamp
  sender.save()
  
  // Load or create receiver
  let receiver = User.load(event.params.to.toHex())
  if (receiver == null) {
    receiver = new User(event.params.to.toHex())
    receiver.address = event.params.to
    receiver.balance = BigInt.fromI32(0)
    receiver.createdAt = event.block.timestamp
  }
  
  // Update receiver balance
  receiver.balance = receiver.balance.plus(event.params.value)
  receiver.updatedAt = event.block.timestamp
  receiver.save()
  
  // Create transaction record
  let transaction = new Transaction(event.transaction.hash.toHex())
  transaction.hash = event.transaction.hash
  transaction.from = sender.id
  transaction.to = receiver.id
  transaction.value = event.params.value
  transaction.timestamp = event.block.timestamp
  transaction.blockNumber = event.block.number
  transaction.save()
}

# Initialize subgraph
graph init --from-contract 0x1234...

# Generate types from schema and ABIs
graph codegen

# Build WASM module
graph build

# Deploy to local Graph Node
graph create my-subgraph --node http://localhost:8020
graph deploy my-subgraph --ipfs http://localhost:5001 --node http://localhost:8020

{
  users(first: 10, orderBy: balance, orderDirection: desc) {
    id
    address
    balance
    transactions(first: 5) {
      hash
      value
      timestamp
    }
  }
}

graft:
  base: QmBase... # Base subgraph IPFS hash
  block: 12345678 # Block number to graft from
features:
  - grafting

eventHandlers:
  - event: Swap(indexed address,uint256,uint256)
    handler: handleSwap
    calls:
      getReserves:
        call: UniswapV2Pair[event.address].getReserves()

type Article @entity {
  id: ID!
  title: String! @fulltext(name: "articleSearch", algorithm: rank, language: en)
  content: String! @fulltext(name: "articleSearch")
}

{
  articleSearch(text: "blockchain") {
    id
    title
  }
}