feat: USD pricing via Curve-native tricrypto oracle + Python schema alignment

Replace the Swap entity with PoolPrice, add Token/PoolPair/Registry to
mirror the target Python schema. Compute usd_main_volume /
usd_reference_volume / usd_fee from on-chain data only: seed hardcoded
stablecoins at \$1, then propagate usdPrice to WBTC/WETH (and anything
else) via cryptoswap swap ratios — no external price API.

Also adds tricrypto2 (0xd51a44d3fae010294c616388b506acda1bfaae46) as a
static LegacyTricryptoPool on mainnet so its USDT/WBTC/WETH swaps seed
prices for WBTC and WETH from block one of its activity.

Author: DenhamPreen

config.yaml

@@ -5,14 +5,23 @@ contracts:
   - name: TricryptoFactoryNG
     events:
       - event: TricryptoPoolDeployed(address pool, string name, string symbol, address weth, address[3] coins, address math, bytes32 salt, uint256 packed_precisions, uint256 packed_A_gamma, uint256 packed_fee_params, uint256 packed_rebalancing_params, uint256 packed_prices, address deployer)
+        field_selection:
+          transaction_fields:
+            - hash
 
   - name: TwocryptoFactoryNG
     events:
       - event: TwocryptoPoolDeployed(address pool, string name, string symbol, address[2] coins, address math, bytes32 salt, uint256[2] precisions, uint256 packed_A_gamma, uint256 packed_fee_params, uint256 packed_rebalancing_params, uint256 packed_prices, address deployer)
+        field_selection:
+          transaction_fields:
+            - hash
 
   - name: TwocryptoFactoryV1
     events:
       - event: CryptoPoolDeployed(address token, address[2] coins, uint256 A, uint256 gamma, uint256 mid_fee, uint256 out_fee, uint256 allowed_extra_profit, uint256 fee_gamma, uint256 adjustment_step, uint256 admin_fee, uint256 ma_half_time, uint256 initial_price, address deployer)
+        field_selection:
+          transaction_fields:
+            - hash
 
   - name: CryptoPool
     events:
@@ -21,6 +30,16 @@ contracts:
           transaction_fields:
             - hash
 
+  # Legacy tricrypto pool (e.g. tricrypto2 on mainnet) that was deployed
+  # manually rather than via a factory. Older TokenExchange event signature:
+  # no `fee`, no `packed_price_scale` fields. 3-coin pool.
+  - name: LegacyTricryptoPool
+    events:
+      - event: TokenExchange(address indexed buyer, uint256 sold_id, uint256 tokens_sold, uint256 bought_id, uint256 tokens_bought)
+        field_selection:
+          transaction_fields:
+            - hash
+
   # Standalone 2-coin Curve crypto pool with donation features. Not deployed
   # by any of the tracked factories above, so it is registered statically by
   # address per chain. Pool entity is initialized lazily on the first event.
@@ -68,6 +87,9 @@ chains:
       - name: TwocryptoPool
         address:
           - 0x83f24023d15d835a213df24fd309c47dab5beb32
+      - name: LegacyTricryptoPool
+        address:
+          - 0xd51a44d3fae010294c616388b506acda1bfaae46
       - name: CryptoPool
 
   # Arbitrum

schema.graphql

@@ -7,8 +7,53 @@ type GlobalState {
   lastUpdatedTimestamp: BigInt!
 }
 
+enum PoolType {
+  TRICRYPTO_NG
+  TWOCRYPTO_NG
+  CRYPTO_V1
+  TRICRYPTO_LEGACY
+  TWOCRYPTO_STANDALONE
+}
+
+enum PriceSource {
+  STABLECOIN
+  DERIVED
+}
+
+enum PriceType {
+  TOKEN_EXCHANGE
+  LAST_PRICES
+}
+
+type Registry {
+  id: ID!
+  chainId: Int!
+  address: String!
+  registryType: String!
+}
+
+type Token {
+  id: ID!
+  chainId: Int!
+  address: String!
+  symbol: String!
+  decimals: Int!
+  isStablecoin: Boolean!
+  usdPrice: BigDecimal
+  priceSource: PriceSource
+  lastPricedBlock: Int
+  lastPricedTimestamp: BigInt
+}
+
 type Pool {
   id: ID!
+  chainId: Int!
+  address: String!
+  lpTokenAddress: String!
+  symbol: String!
+  name: String!
+  poolType: PoolType!
+  registry: Registry
   nCoins: Int!
   coinAddresses: [String!]!
   coinSymbols: [String!]!
@@ -17,10 +62,51 @@ type Pool {
   priceScales: [BigInt!]!
   balances: [BigInt!]!
   totalSwapCount: BigInt!
+  tvlUsd: BigDecimal
+  hasDonations: Boolean!
+  isActive: Boolean!
+  deploymentBlock: Int!
+  deploymentTimestamp: BigInt!
+  deploymentTxHash: String!
   lastUpdatedBlock: Int!
   lastUpdatedTimestamp: BigInt!
-  swaps: [Swap!]! @derivedFrom(field: "pool")
   liquidityEvents: [LiquidityEvent!]! @derivedFrom(field: "pool")
+  poolPairs: [PoolPair!]! @derivedFrom(field: "pool")
+  poolPrices: [PoolPrice!]! @derivedFrom(field: "pool")
+}
+
+type PoolPair {
+  id: ID!
+  pool: Pool! @index
+  mainTokenIndex: Int!
+  referenceTokenIndex: Int!
+  mainToken: Token!
+  referenceToken: Token!
+}
+
+type PoolPrice {
+  id: ID!
+  chainId: Int!
+  pool: Pool! @index
+  poolPair: PoolPair! @index
+  priceType: PriceType!
+  soldId: Int!
+  boughtId: Int!
+  tokensSold: BigDecimal!
+  tokensBought: BigDecimal!
+  price: BigDecimal!
+  blockNumber: Int! @index
+  timestamp: BigInt! @index
+  txHash: String!
+  logIndex: Int
+  isRelevant: Boolean!
+  buyer: String! @index
+  fee: BigDecimal
+  usdMainPrice: BigDecimal
+  usdMainVolume: BigDecimal
+  usdReferencePrice: BigDecimal
+  usdReferenceVolume: BigDecimal
+  usdFee: BigDecimal
 }
 
 enum LiquidityEventKind {
@@ -45,23 +131,3 @@ type LiquidityEvent {
   blockNumber: Int!
   txHash: String!
 }
-
-type Swap {
-  id: ID!
-  pool: Pool! @index
-  buyer: String! @index
-  soldTokenIndex: Int!
-  soldTokenSymbol: String!
-  soldAmount: BigInt!
-  soldDecimals: Int!
-  boughtTokenIndex: Int!
-  boughtTokenSymbol: String!
-  boughtAmount: BigInt!
-  boughtDecimals: Int!
-  fee: BigInt!
-  timestamp: BigInt! @index
-  blockNumber: Int!
-  txHash: String!
-  lastPrices: [BigInt!]!
-  priceScales: [BigInt!]!
-}

src/constants.ts

@@ -0,0 +1,47 @@
+// Hardcoded stablecoins treated as $1. Used to bootstrap the USD pricing
+// graph: any token paired with one of these in a Curve cryptoswap pool gets
+// its usdPrice derived from the swap ratio. WETH/WBTC aren't listed here —
+// they get priced via tricrypto pools where coin 0 is a stablecoin.
+//
+// Addresses are lower-cased for membership checks.
+
+export const STABLECOINS: Record<number, Set<string>> = {
+  // Ethereum mainnet
+  1: new Set(
+    [
+      "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
+      "0xdAC17F958D2ee523a2206206994597C13D831ec7", // USDT
+      "0x6B175474E89094C44Da98b954EedeAC495271d0F", // DAI
+      "0x853d955aCEf822Db058eb8505911ED77F175b99e", // FRAX
+      "0xf939E0A03FB07F59A73314E73794Be0E57ac1b4E", // crvUSD
+      "0x0000000000085d4780B73119b644AE5ecd22b376", // TUSD
+      "0x4c9EDD5852cd905f086C759E8383e09bff1E68B3", // USDe
+      "0x8E870D67F660D95d5be530380D0eC0bd388289E1", // USDP (Pax Dollar)
+      "0x6c3ea9036406852006290770BEdFcAbA0e23A0e8", // PYUSD
+      "0x056Fd409E1d7A124BD7017459dFEa2F387b6d5Cd", // GUSD
+      "0x99D8a9C45b2ecA8864373A26D1459e3Dff1e17F3", // MIM
+      "0x57Ab1ec28D129707052df4dF418D58a2D46d5f51", // sUSD
+    ].map((a) => a.toLowerCase()),
+  ),
+  // Arbitrum
+  42161: new Set(
+    [
+      "0xaf88d065e77c8cC2239327C5EDb3A432268e5831", // USDC (native)
+      "0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8", // USDC.e (bridged)
+      "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9", // USDT
+      "0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1", // DAI
+      "0x17FC002b466eEc40DaE837Fc4bE5c67993ddBd6F", // FRAX
+      "0x498Bf2B1e120FeD3ad3D42EA2165E9b73f99C1e5", // crvUSD
+      "0x5d3a1Ff2b6BAb83b63cd9AD0787074081a52ef34", // USDe
+      "0x4D15a3A2286D883AF0AA1B3f21367843FAc63E07", // TUSD
+    ].map((a) => a.toLowerCase()),
+  ),
+};
+
+export function isStablecoin(chainId: number, address: string): boolean {
+  return STABLECOINS[chainId]?.has(address.toLowerCase()) ?? false;
+}
+
+export function tokenId(chainId: number, address: string): string {
+  return `${chainId}_${address.toLowerCase()}`;
+}

src/handlers/CryptoPool.ts

@@ -1,18 +1,22 @@
-import { CryptoPool, type EvmChainId } from "generated";
+import { CryptoPool, type EvmChainId, type PoolPrice } from "generated";
 import { getPoolState } from "../effects.js";
+import { tokenId } from "../constants.js";
+import {
+  computePricing,
+  computeTvlUsd,
+  pairIdForSwap,
+} from "../pricing.js";
 
 CryptoPool.TokenExchange.handler(async ({ event, context }) => {
   const chainId = event.chainId;
-  const poolId = `${chainId}_${event.srcAddress}`;
+  const poolId = `${chainId}_${event.srcAddress.toLowerCase()}`;
   const pool = await context.Pool.get(poolId);
   if (!pool) {
     context.log.warn(`Pool ${poolId} not found — skipping swap`);
     return;
   }
 
   const address = event.srcAddress;
-
-  // Single effect fetches balances, last_prices, and price_scale for all coins
   const { balances, lastPrices, priceScales } = await getPoolState(context, {
     chainId: chainId as EvmChainId,
     address,
@@ -23,38 +27,107 @@ CryptoPool.TokenExchange.handler(async ({ event, context }) => {
   const soldIdx = Number(event.params.sold_id);
   const boughtIdx = Number(event.params.bought_id);
 
-  context.Swap.set({
+  const pairId = pairIdForSwap(pool, soldIdx, boughtIdx);
+  const pair = await context.PoolPair.get(pairId);
+  if (!pair) {
+    context.log.warn(`PoolPair ${pairId} not found — skipping pricing`);
+    return;
+  }
+
+  const [mainToken, referenceToken] = await Promise.all([
+    context.Token.get(pair.mainToken_id),
+    context.Token.get(pair.referenceToken_id),
+  ]);
+  if (!mainToken || !referenceToken) {
+    context.log.warn(`Missing Token entity for pair ${pairId} — skipping`);
+    return;
+  }
+
+  const soldAddr = pool.coinAddresses[soldIdx]!;
+  const boughtAddr = pool.coinAddresses[boughtIdx]!;
+  const soldToken =
+    soldAddr === mainToken.address
+      ? mainToken
+      : soldAddr === referenceToken.address
+        ? referenceToken
+        : await context.Token.get(tokenId(chainId, soldAddr));
+  const boughtToken =
+    boughtAddr === mainToken.address
+      ? mainToken
+      : boughtAddr === referenceToken.address
+        ? referenceToken
+        : await context.Token.get(tokenId(chainId, boughtAddr));
+  if (!soldToken || !boughtToken) {
+    context.log.warn(`Missing sold/bought Token for pool ${poolId}`);
+    return;
+  }
+
+  const pricing = computePricing(
+    chainId,
+    pair,
+    { main: mainToken, reference: referenceToken, sold: soldToken, bought: boughtToken },
+    soldIdx,
+    boughtIdx,
+    event.params.tokens_sold,
+    event.params.tokens_bought,
+    event.params.fee,
+    event.block,
+  );
+
+  for (const updated of pricing.tokenUpdates) {
+    context.Token.set(updated);
+  }
+
+  const isRelevant =
+    pricing.usdMainVolume !== undefined ||
+    pricing.usdReferenceVolume !== undefined;
+
+  const poolPrice: PoolPrice = {
     id: `${chainId}_${event.block.number}_${event.logIndex}`,
+    chainId,
     pool_id: poolId,
-    buyer: event.params.buyer,
-    soldTokenIndex: soldIdx,
-    soldTokenSymbol: pool.coinSymbols[soldIdx] ?? "???",
-    soldAmount: event.params.tokens_sold,
-    soldDecimals: pool.coinDecimals[soldIdx] ?? 18,
-    boughtTokenIndex: boughtIdx,
-    boughtTokenSymbol: pool.coinSymbols[boughtIdx] ?? "???",
-    boughtAmount: event.params.tokens_bought,
-    boughtDecimals: pool.coinDecimals[boughtIdx] ?? 18,
-    fee: event.params.fee,
-    timestamp: BigInt(event.block.timestamp),
+    poolPair_id: pair.id,
+    priceType: "TOKEN_EXCHANGE",
+    soldId: soldIdx,
+    boughtId: boughtIdx,
+    tokensSold: pricing.tokensSoldDecimal,
+    tokensBought: pricing.tokensBoughtDecimal,
+    price: pricing.price,
     blockNumber: event.block.number,
+    timestamp: BigInt(event.block.timestamp),
     txHash: event.transaction.hash,
-    lastPrices,
-    priceScales,
-  });
+    logIndex: event.logIndex,
+    isRelevant,
+    buyer: event.params.buyer,
+    fee: pricing.feeDecimal,
+    usdMainPrice: pricing.usdMainPrice,
+    usdMainVolume: pricing.usdMainVolume,
+    usdReferencePrice: pricing.usdReferencePrice,
+    usdReferenceVolume: pricing.usdReferenceVolume,
+    usdFee: pricing.usdFee,
+  };
+  context.PoolPrice.set(poolPrice);
+
+  // Refresh Pool with new balances / price state and recompute TVL.
+  const allTokens = await Promise.all(
+    pool.coinAddresses.map((addr) => context.Token.get(tokenId(chainId, addr))),
+  );
+  const tvlUsd = computeTvlUsd(
+    { ...pool, balances },
+    allTokens,
+  );
 
-  // Update Pool state
   context.Pool.set({
     ...pool,
     lastPrices,
     priceScales,
     balances,
     totalSwapCount: pool.totalSwapCount + 1n,
+    tvlUsd,
     lastUpdatedBlock: event.block.number,
     lastUpdatedTimestamp: BigInt(event.block.timestamp),
   });
 
-  // Update GlobalState swap count
   const globalId = `${chainId}`;
   const global = await context.GlobalState.get(globalId);
   if (global) {