Introduction to Indexers

# Query user's liquidity positions across multiple pools
query UserPositions($userAddress: String!) {
  liquidityPositions(where: { user: $userAddress }) {
    id
    pool {
      token0 { symbol }
      token1 { symbol }
    }
    liquidity
    token0Amount
    token1Amount
    createdAt
  }
}

# Get user's transaction history with token prices
query UserTransactions($userAddress: String!) {
  transactions(
    where: { user: $userAddress }
    orderBy: timestamp
    orderDirection: desc
  ) {
    hash
    type
    tokens {
      symbol
      amount
      priceUSD
    }
    timestamp
  }
}

# Get daily trading volume for the last 30 days
query TradingVolume {
  dailyStats(
    first: 30
    orderBy: date
    orderDirection: desc
  ) {
    date
    volumeUSD
    txCount
    uniqueUsers
  }
}

// Index oracle price updates
const oraclePrices = await api.query(
  `query {
    oraclePriceUpdates(
      where: { denom: "ATOM" }
      orderBy: blockHeight
      orderDirection: desc
      first: 100
    ) {
      blockHeight
      denom
      price
      timestamp
      validator
    }
  }`
);

// Track ICQ query results
const icqResults = await api.query(
  `query {
    interchainQueries {
      id
      connectionId
      queryType
      results(orderBy: timestamp, orderDirection: desc) {
        data
        timestamp
        blockHeight
      }
    }
  }`
);

// Monitor automated cron executions
const cronExecutions = await api.query(
  `query {
    cronExecutions(first: 50) {
      scheduleName
      executedAt
      success
      gasUsed
      contract
      message
    }
  }`
);

interface Block {
  height: number;
  hash: string;
  timestamp: Date;
  proposer: string;
  txCount: number;
}

interface Transaction {
  hash: string;
  block: Block;
  sender: string;
  gasUsed: number;
  gasWanted: number;
  success: boolean;
  messages: Message[];
}

interface Message {
  type: string;
  data: any;
  events: Event[];
}

interface Event {
  type: string;
  attributes: Attribute[];
}

interface Attribute {
  key: string;
  value: string;
}

interface OraclePriceUpdate {
  denom: string;
  price: string;
  timestamp: Date;
  validator: string;
  blockHeight: number;
}

interface InterchainQuery {
  id: number;
  connectionId: string;
  queryType: string;
  keys: string[];
  updatePeriod: number;
  lastExecutedHeight: number;
}

interface CronSchedule {
  name: string;
  period: number;
  contract: string;
  msgs: any[];
  createdAt: Date;
  lastExecuted?: Date;
}

-- Essential indexes for fast queries
CREATE INDEX idx_transactions_sender ON transactions(sender);
CREATE INDEX idx_transactions_block_height ON transactions(block_height);
CREATE INDEX idx_events_type ON events(type);
CREATE INDEX idx_oracle_prices_denom_timestamp ON oracle_prices(denom, timestamp DESC);

// Redis caching for frequently accessed data
const getCachedUserBalance = async (address) => {
  const cacheKey = `balance:${address}`;
  let balance = await redis.get(cacheKey);
  
  if (!balance) {
    balance = await database.getUserBalance(address);
    await redis.setex(cacheKey, 300, JSON.stringify(balance)); // 5min cache
  }
  
  return JSON.parse(balance);
};

// WebSocket subscriptions for live data
const subscription = api.subscribe(`
  subscription {
    newTransactions(where: { user: "${userAddress}" }) {
      hash
      type
      amount
      timestamp
    }
  }
`);

subscription.on('data', (newTransaction) => {
  updateUI(newTransaction);
});