0xtrails 0.6.6 → 0.7.0

package/src/aave.ts

@@ -1,6 +1,5 @@
-import { useAaveMarkets, chainId } from "@aave/react"
-import { useMemo } from "react"
-import { encodeFunctionData, type WalletClient } from "viem"
+import { useMemo, useState, useEffect } from "react"
+import { encodeFunctionData, type WalletClient, type PublicClient } from "viem"
 import { logger } from "./logger.js"
 
 // Chain ID to Aave market name mapping
@@ -29,6 +28,8 @@ export function getAaveV3WrappedTokenGatewayAddress(
   return WRAPPED_TOKEN_GATEWAY_ADDRESS[chainId] ?? null
 }
 
+const AAVE_API_ENDPOINT = "https://api.v3.aave.com/graphql"
+
 // Pool data interface
 export interface Pool {
   id: string
@@ -51,131 +52,237 @@ export interface Pool {
   wrappedTokenGatewayAddress?: string
 }
 
-export function useAavePools() {
-  const {
-    data: markets,
-    loading,
-    error,
-  } = useAaveMarkets({
-    chainIds: [
-      chainId(1),
-      chainId(8453),
-      chainId(42161),
-      chainId(137),
-      chainId(10),
-    ], // Ethereum, Base, Arbitrum, Polygon, Optimism
-  })
-
-  // logger.console.log("[trails-sdk] === AAVE HOOK DEBUG ===")
-  // logger.console.log("[trails-sdk] Aave markets data:", markets)
-  // logger.console.log("[trails-sdk] Loading:", loading)
-  // logger.console.log("[trails-sdk] Error:", error)
-  // logger.console.log("[trails-sdk] Markets type:", typeof markets)
-  // logger.console.log("[trails-sdk] Markets length:", markets?.length)
-  // logger.console.log("[trails-sdk] ========================")
-
-  // Transform Aave markets data to our Pool interface with caching
-  const pools: Pool[] = useMemo(() => {
-    if (!markets) return []
+/**
+ * Fetch all markets from Aave GraphQL API
+ */
+async function fetchAllMarkets(): Promise<any[]> {
+  const marketsQuery = {
+    query: `
+      query Markets {
+        markets(request: {
+          chainIds: [1, 8453, 42161, 137, 10, 100]
+        }) {
+          __typename
+          name
+          address
+          icon
+          chain {
+            __typename
+            name
+            chainId
+            icon
+          }
+          reserves {
+            __typename
+            underlyingToken {
+              __typename
+              address
+              chainId
+              name
+              symbol
+              decimals
+              imageUrl
+            }
+            aToken {
+              __typename
+              address
+            }
+            size {
+              __typename
+              amount {
+                __typename
+                value
+              }
+              usd
+            }
+            isFrozen
+            isPaused
+            supplyInfo {
+              __typename
+              apy {
+                __typename
+                value
+              }
+            }
+          }
+        }
+      }
+    `,
+  }
 
-    try {
-      return markets.flatMap((market) => {
-        logger.console.log("[trails-sdk] Processing market:", market)
-        logger.console.log("[trails-sdk] Market chain:", market.chain)
-        logger.console.log(
-          "[trails-sdk] Supply reserves:",
-          market.supplyReserves,
-        )
-        logger.console.log(
-          "[trails-sdk] Supply reserves type:",
-          typeof market.supplyReserves,
-        )
-        logger.console.log(
-          "[trails-sdk] Supply reserves length:",
-          market.supplyReserves?.length,
-        )
+  try {
+    const response = await fetch(AAVE_API_ENDPOINT, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(marketsQuery),
+    })
 
-        if (!market.supplyReserves || market.supplyReserves.length === 0) {
-          logger.console.log(
-            "[trails-sdk] No supply reserves found for market:",
-            market.chain.chainId,
-          )
-          return []
-        }
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => "Unknown error")
+      logger.console.error(
+        `Failed to fetch markets from GraphQL API: HTTP ${response.status} - ${errorText}`,
+      )
+      return []
+    }
 
-        return (
-          market.supplyReserves
-            ?.filter((reserve: any) => {
-              // Check if reserve has supply info and is not frozen/paused
-              const hasSupplyInfo =
-                reserve.supplyInfo && !reserve.isFrozen && !reserve.isPaused
-              const hasLiquidity = parseFloat(reserve.size?.usd || "0") > 0
-              // logger.console.log(
-              //   `[trails-sdk] Reserve ${reserve.underlyingToken?.symbol}: hasSupplyInfo=${hasSupplyInfo}, hasLiquidity=${hasLiquidity}, sizeUSD=${reserve.size?.usd}`,
-              // )
-              return hasSupplyInfo && hasLiquidity
-            })
-            .map((reserve: any) => {
-              const decimals = reserve.underlyingToken?.decimals
-              if (!decimals) {
-                logger.console.warn(
-                  "[trails-sdk] Missing decimals for reserve:",
-                  {
-                    reserve: reserve.underlyingToken,
-                    market: market.chain.chainId,
-                  },
-                )
-                return null // Return null instead of throwing
-              }
+    const marketsData = (await response.json()) as any
 
-              const tokenMetadata = {
-                symbol: reserve.underlyingToken?.symbol || "UNKNOWN",
-                name: reserve.underlyingToken?.name || "Unknown Token",
-                decimals,
-              }
+    // Check for GraphQL errors
+    if (marketsData.errors && marketsData.errors.length > 0) {
+      logger.console.error(
+        "GraphQL errors in markets query:",
+        marketsData.errors,
+      )
+      return []
+    }
 
-              const pool = {
-                id: `${reserve.underlyingToken?.address}-${market.chain.chainId}-${reserve.aToken?.address}`,
-                name: `${tokenMetadata.symbol} Market`,
-                protocol: "Aave",
-                chainId: market.chain.chainId,
-                apy: parseFloat(reserve.supplyInfo?.apy?.value || "0") * 100, // Convert to percentage
-                tvl: parseFloat(reserve.size?.usd || "0"),
-                token: {
-                  symbol: tokenMetadata.symbol,
-                  name: tokenMetadata.name,
-                  address: reserve.underlyingToken?.address,
-                  decimals: tokenMetadata.decimals,
-                  logoUrl:
-                    "logoUrl" in tokenMetadata
-                      ? tokenMetadata.logoUrl
-                      : reserve.underlyingToken?.imageUrl,
-                },
-                depositAddress: market.address,
-                isActive: !reserve.isFrozen && !reserve.isPaused,
-                protocolUrl: "https://app.aave.com/",
-                poolUrl: `https://app.aave.com/reserve-overview/?underlyingAsset=${reserve.underlyingToken?.address?.toLowerCase()}&marketName=${CHAIN_TO_MARKET_NAME[market.chain.chainId] || "proto_mainnet_v3"}`,
-                wrappedTokenGatewayAddress:
-                  getAaveV3WrappedTokenGatewayAddress(market.chain.chainId) ||
-                  undefined,
-              }
+    // Validate response structure
+    if (!marketsData.data || !Array.isArray(marketsData.data.markets)) {
+      logger.console.warn(
+        "Invalid response structure from Aave API:",
+        marketsData,
+      )
+      return []
+    }
 
-              // logger.console.log("[trails-sdk] pool object:", pool)
-              return pool
-            })
-            .filter((pool) => pool !== null) || [] // Filter out null values
-        )
+    return marketsData.data.markets
+  } catch (apiError) {
+    logger.console.error("Failed to fetch markets from GraphQL API:", apiError)
+    return []
+  }
+}
+
+/**
+ * Transform API market data to Pool interface
+ */
+function transformReserveToPool(market: any, reserve: any): Pool | null {
+  try {
+    if (!market || !reserve || !reserve.underlyingToken) {
+      return null
+    }
+
+    const chainId = market.chain?.chainId
+    if (!chainId) {
+      return null
+    }
+
+    const decimals = reserve.underlyingToken?.decimals
+    if (!decimals) {
+      logger.console.warn("[trails-sdk] Missing decimals for reserve:", {
+        reserve: reserve.underlyingToken,
+        market: chainId,
+      })
+      return null
+    }
+
+    // Validate required fields
+    if (!reserve.underlyingToken?.address || !market.address) {
+      logger.console.warn(
+        "[trails-sdk] Missing required addresses for reserve:",
+        {
+          underlyingTokenAddress: reserve.underlyingToken?.address,
+          marketAddress: market.address,
+          chainId,
+        },
+      )
+      return null
+    }
+
+    // Check if reserve has supply info and is not frozen/paused
+    const hasSupplyInfo =
+      reserve.supplyInfo && !reserve.isFrozen && !reserve.isPaused
+    const usdValue = reserve.size?.usd || "0"
+    const usdValueNum = parseFloat(usdValue)
+    const hasLiquidity = !Number.isNaN(usdValueNum) && usdValueNum > 0
+
+    if (!hasSupplyInfo || !hasLiquidity) {
+      return null
+    }
+
+    // Parse APY value safely
+    const apyValue = reserve.supplyInfo?.apy?.value || "0"
+    const apyNum = parseFloat(apyValue)
+    if (Number.isNaN(apyNum)) {
+      logger.console.warn("[trails-sdk] Invalid APY value for reserve:", {
+        symbol: reserve.underlyingToken?.symbol,
+        apyValue,
+        chainId,
       })
-    } catch (error) {
-      logger.console.error("[trails-sdk] Error processing Aave markets:", error)
-      return [] // Return empty array instead of crashing
+      return null
+    }
+
+    const tokenMetadata = {
+      symbol: reserve.underlyingToken?.symbol || "UNKNOWN",
+      name: reserve.underlyingToken?.name || "Unknown Token",
+      decimals,
+    }
+
+    const pool: Pool = {
+      id: `${reserve.underlyingToken.address}-${chainId}-${reserve.aToken?.address || ""}`,
+      name: `${tokenMetadata.symbol} Market`,
+      protocol: "Aave",
+      chainId: chainId,
+      apy: apyNum * 100, // Convert to percentage
+      tvl: usdValueNum,
+      token: {
+        symbol: tokenMetadata.symbol,
+        name: tokenMetadata.name,
+        address: reserve.underlyingToken.address,
+        decimals: tokenMetadata.decimals,
+        logoUrl: reserve.underlyingToken?.imageUrl,
+      },
+      depositAddress: market.address,
+      isActive: !reserve.isFrozen && !reserve.isPaused,
+      protocolUrl: "https://app.aave.com/",
+      poolUrl: `https://app.aave.com/reserve-overview/?underlyingAsset=${reserve.underlyingToken.address.toLowerCase()}&marketName=${CHAIN_TO_MARKET_NAME[chainId] || "proto_mainnet_v3"}`,
+      wrappedTokenGatewayAddress:
+        getAaveV3WrappedTokenGatewayAddress(chainId) || undefined,
+    }
+
+    return pool
+  } catch (error) {
+    logger.console.error(`Failed to transform reserve data:`, error)
+    return null
+  }
+}
+
+export function useAavePools() {
+  const [pools, setPools] = useState<Pool[]>([])
+  const [loading, setLoading] = useState(true)
+  const [error, setError] = useState<Error | null>(null)
+
+  useEffect(() => {
+    async function fetchPools() {
+      try {
+        setLoading(true)
+        setError(null)
+
+        const marketsData = await fetchAllMarkets()
+        const transformedPools = marketsData.flatMap((market) => {
+          if (!market.reserves || market.reserves.length === 0) {
+            return []
+          }
+          return market.reserves
+            .map((reserve: any) => transformReserveToPool(market, reserve))
+            .filter((pool: Pool | null): pool is Pool => pool !== null)
+        })
+
+        setPools(transformedPools)
+      } catch (err) {
+        setError(
+          err instanceof Error ? err : new Error("Failed to fetch Aave pools"),
+        )
+      } finally {
+        setLoading(false)
+      }
     }
-  }, [markets])
 
-  // logger.console.log("[trails-sdk] Final pools array:", pools)
-  // logger.console.log("[trails-sdk] Final pools length:", pools.length)
+    fetchPools()
+  }, [])
 
-  // Sort by APY descending with caching
+  // Sort by APY descending
   const sortedPools = useMemo(() => {
     return pools.sort((a: Pool, b: Pool) => b.apy - a.apy)
   }, [pools])
@@ -187,6 +294,88 @@ export function useAavePools() {
   }
 }
 
+/**
+ * Get all pools for a specific chain
+ */
+export async function getAavePoolsForChain(
+  chainId: number,
+  _publicClient: PublicClient,
+): Promise<Pool[]> {
+  try {
+    if (!chainId || chainId <= 0) {
+      logger.console.warn(
+        "[trails-sdk] Invalid chainId provided to getAavePoolsForChain:",
+        chainId,
+      )
+      return []
+    }
+
+    const marketsData = await fetchAllMarkets()
+    if (!marketsData || marketsData.length === 0) {
+      logger.console.warn(
+        "[trails-sdk] No markets data returned for chain:",
+        chainId,
+      )
+      return []
+    }
+
+    const chainMarkets = marketsData.filter(
+      (market) => market.chain?.chainId === chainId,
+    )
+
+    if (chainMarkets.length === 0) {
+      logger.console.warn("[trails-sdk] No markets found for chain:", chainId)
+      return []
+    }
+
+    const transformedPools = chainMarkets.flatMap((market) => {
+      if (!market.reserves || market.reserves.length === 0) {
+        return []
+      }
+      return market.reserves
+        .map((reserve: any) => transformReserveToPool(market, reserve))
+        .filter((pool: Pool | null): pool is Pool => pool !== null)
+    })
+
+    return transformedPools
+  } catch (error) {
+    logger.console.error(
+      `Failed to get Aave pools for chain ${chainId}:`,
+      error,
+    )
+    return []
+  }
+}
+
+/**
+ * Get all pools across all chains
+ */
+export async function getAllAavePools(
+  _publicClient: PublicClient,
+): Promise<Pool[]> {
+  try {
+    const marketsData = await fetchAllMarkets()
+    if (!marketsData || marketsData.length === 0) {
+      logger.console.warn("[trails-sdk] No markets data returned")
+      return []
+    }
+
+    const transformedPools = marketsData.flatMap((market) => {
+      if (!market.reserves || market.reserves.length === 0) {
+        return []
+      }
+      return market.reserves
+        .map((reserve: any) => transformReserveToPool(market, reserve))
+        .filter((pool: Pool | null): pool is Pool => pool !== null)
+    })
+
+    return transformedPools
+  } catch (error) {
+    logger.console.error("Failed to get all Aave pools:", error)
+    return []
+  }
+}
+
 /**
  * Generate Aave withdraw calldata
  * @param asset - The address of the underlying asset to withdraw
@@ -199,23 +388,45 @@ export function generateAaveWithdrawCalldata(
   amount: bigint,
   to: string,
 ): `0x${string}` {
-  return encodeFunctionData({
-    abi: [
-      {
-        name: "withdraw",
-        type: "function",
-        stateMutability: "nonpayable",
-        inputs: [
-          { name: "asset", type: "address" },
-          { name: "amount", type: "uint256" },
-          { name: "to", type: "address" },
-        ],
-        outputs: [{ type: "uint256" }],
-      },
-    ],
-    functionName: "withdraw",
-    args: [asset as `0x${string}`, amount, to as `0x${string}`],
-  })
+  try {
+    if (!asset || !to) {
+      throw new Error("Asset and recipient addresses are required")
+    }
+
+    if (amount <= 0n) {
+      throw new Error("Amount must be greater than 0")
+    }
+
+    // Basic address validation (should start with 0x and be 42 chars)
+    if (!asset.startsWith("0x") || asset.length !== 42) {
+      throw new Error(`Invalid asset address: ${asset}`)
+    }
+
+    if (!to.startsWith("0x") || to.length !== 42) {
+      throw new Error(`Invalid recipient address: ${to}`)
+    }
+
+    return encodeFunctionData({
+      abi: [
+        {
+          name: "withdraw",
+          type: "function",
+          stateMutability: "nonpayable",
+          inputs: [
+            { name: "asset", type: "address" },
+            { name: "amount", type: "uint256" },
+            { name: "to", type: "address" },
+          ],
+          outputs: [{ type: "uint256" }],
+        },
+      ],
+      functionName: "withdraw",
+      args: [asset as `0x${string}`, amount, to as `0x${string}`],
+    })
+  } catch (error) {
+    logger.console.error("Error generating Aave withdraw calldata:", error)
+    throw error
+  }
 }
 
 // Generate deposit calldata for Aave pool
@@ -225,11 +436,38 @@ export const generateAaveDepositCalldata = (
   amount: string,
 ) => {
   try {
+    if (!walletClient) {
+      throw new Error("Wallet client is required")
+    }
+
+    if (!pool) {
+      throw new Error("Pool is required")
+    }
+
+    if (!pool.token || !pool.token.address) {
+      throw new Error("Pool token address is required")
+    }
+
+    // Validate pool token address
+    if (
+      !pool.token.address.startsWith("0x") ||
+      pool.token.address.length !== 42
+    ) {
+      throw new Error(`Invalid pool token address: ${pool.token.address}`)
+    }
+
     const userAddress = walletClient?.account?.address || walletClient?.account
     if (!userAddress) {
       throw new Error("User address not found")
     }
 
+    // Validate user address format
+    const addressStr =
+      typeof userAddress === "string" ? userAddress : String(userAddress)
+    if (!addressStr.startsWith("0x") || addressStr.length !== 42) {
+      throw new Error(`Invalid user address: ${addressStr}`)
+    }
+
     // Validate amount
     if (
       !amount ||
@@ -237,7 +475,18 @@ export const generateAaveDepositCalldata = (
       Number.isNaN(Number(amount)) ||
       Number(amount) <= 0
     ) {
-      throw new Error("Invalid amount")
+      throw new Error(`Invalid amount: ${amount}`)
+    }
+
+    // Validate amount can be converted to BigInt
+    let amountBigInt: bigint
+    try {
+      amountBigInt = BigInt(amount)
+      if (amountBigInt <= 0n) {
+        throw new Error("Amount must be greater than 0")
+      }
+    } catch {
+      throw new Error(`Invalid amount format: ${amount}`)
     }
 
     // Aave V3 Pool contract deposit function
@@ -259,8 +508,8 @@ export const generateAaveDepositCalldata = (
       ],
       args: [
         pool.token.address as `0x${string}`, // asset address
-        BigInt(amount), // amount to deposit
-        userAddress as `0x${string}`, // onBehalfOf (user's address)
+        amountBigInt, // amount to deposit
+        addressStr as `0x${string}`, // onBehalfOf (user's address)
         0, // referralCode (0 for no referral)
       ],
     })