0xtrails 0.1.13 → 0.2.1

package/src/intentEntrypoint.ts

@@ -0,0 +1,218 @@
+import type { Account, WalletClient, Hex, Address, PublicClient } from "viem"
+import { intentEntrypoints } from "./constants.js"
+import type { TrailsAPIClient } from "@0xsequence/trails-api"
+
+// Intent Entrypoint ABI (partial - only the functions we need)
+// TODO: Uncomment and use when implementing calldata injection
+/* const INTENT_ENTRYPOINT_ABI = [
+  {
+    name: "depositToIntent",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "user", type: "address" },
+      { name: "token", type: "address" },
+      { name: "amount", type: "uint256" },
+      { name: "intentAddress", type: "address" },
+      { name: "deadline", type: "uint256" },
+      { name: "sigV", type: "uint8" },
+      { name: "sigR", type: "bytes32" },
+      { name: "sigS", type: "bytes32" },
+    ],
+    outputs: [],
+  },
+  {
+    name: "depositToIntentWithPermit",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "user", type: "address" },
+      { name: "token", type: "address" },
+      { name: "amount", type: "uint256" },
+      { name: "permitAmount", type: "uint256" },
+      { name: "intentAddress", type: "address" },
+      { name: "deadline", type: "uint256" },
+      { name: "permitV", type: "uint8" },
+      { name: "permitR", type: "bytes32" },
+      { name: "permitS", type: "bytes32" },
+      { name: "sigV", type: "uint8" },
+      { name: "sigR", type: "bytes32" },
+      { name: "sigS", type: "bytes32" },
+    ],
+    outputs: [],
+  },
+] as const */
+
+// Note: EIP-712 typed data signing has been replaced with raw message signing
+// The backend generates the EIP-712 hash and the client signs it as a raw message
+// This simplifies the flow and avoids wallet compatibility issues
+
+export type IntentEntrypointDepositParams = {
+  userAddress: Address
+  tokenAddress: Address
+  amount: bigint | string
+  intentAddress: Address
+  chainId: number
+  deadline?: number // Unix timestamp, defaults to 1 hour from now
+  usePermit?: boolean
+  permitDeadline?: number
+}
+
+export type IntentEntrypointDepositResult = {
+  depositWalletAddress: Address
+  metaTxn: {
+    id: string
+    chainId: string
+    contract: string
+    input: string
+    walletAddress: string
+  }
+  feeQuote: string
+  entrypointAddress: Address
+}
+
+export type IntentEntrypointFeeOptionsParams = {
+  userAddress: Address
+  tokenAddress: Address
+  amount: string
+  intentAddress: Address
+  chainID: number
+}
+
+export type FeeOption = {
+  tokenAddress: string
+  tokenSymbol: string
+  tokenDecimals: number
+  amount: string
+  amountUSD: number
+  feeCollector: string
+}
+
+export type GasEstimate = {
+  totalGas: number
+  gasPrice: string
+  nativeCost: string
+  nativeCostUSD: number
+}
+
+export type IntentEntrypointFeeOptionsResult = {
+  gasEstimate: GasEstimate
+  feeOptions: FeeOption[]
+  expiresAt: number
+  feeCollector: string
+}
+
+export type GaslessDepositOptions = {
+  trailsClient: TrailsAPIClient
+  walletClient: WalletClient
+  publicClient: PublicClient
+  account: Account
+  tokenAddress: Address
+  amount: bigint | string
+  intentAddress: Address
+  chainId: number
+  deadline?: number
+  usePermit?: boolean
+  onStatusUpdate?: (status: DepositStatus) => void
+}
+
+export enum DepositStatus {
+  PREPARING = "preparing",
+  SIGNING = "signing",
+  SUBMITTING = "submitting",
+  PENDING = "pending",
+  CONFIRMED = "confirmed",
+  FAILED = "failed",
+}
+
+/**
+ * Inject signatures into the meta transaction calldata
+ * This updates the placeholder signature values in the Intent Entrypoint call
+ *
+ * TODO: Implement this function to properly update nested calldata
+ * This would require:
+ * 1. Decode the guest module execdata
+ * 2. Find the Intent Entrypoint call
+ * 3. Replace its calldata with properly signed version
+ * 4. Re-encode the guest module execdata
+ *
+ * For reference, the signed calldata can be generated using:
+ * ```typescript
+ * const { v, r, s } = splitSignature(signatures.intent)
+ * const depositCalldata = encodeFunctionData({
+ *   abi: INTENT_ENTRYPOINT_ABI,
+ *   functionName: "depositToIntent",
+ *   args: [userAddress, tokenAddress, amount, intentAddress, deadline, v, r, s],
+ * })
+ * ```
+ */
+
+/**
+ * Split a signature into v, r, s components
+ * TODO: Use this when implementing calldata injection
+ */
+export function splitSignature(signature: Hex): {
+  v: number
+  r: Hex
+  s: Hex
+} {
+  // Remove 0x prefix if present
+  const sig = signature.startsWith("0x") ? signature.slice(2) : signature
+
+  if (sig.length !== 130) {
+    throw new Error(`Invalid signature length: ${sig.length}`)
+  }
+
+  const r = `0x${sig.slice(0, 64)}` as Hex
+  const s = `0x${sig.slice(64, 128)}` as Hex
+  const v = parseInt(sig.slice(128, 130), 16)
+
+  return { v, r, s }
+}
+
+/**
+ * Get the Intent Entrypoint address for a given chain
+ */
+export function getIntentEntrypointAddress(chainId: number): Address | null {
+  return (intentEntrypoints[chainId] as Address) || null
+}
+
+/**
+ * Check if Intent Entrypoint is deployed on a chain
+ */
+export function isIntentEntrypointSupported(chainId: number): boolean {
+  return chainId in intentEntrypoints
+}
+
+/**
+ * Get fee options for intent entrypoint deposits
+ */
+export async function getIntentEntrypointFeeOptions({
+  trailsClient,
+  userAddress,
+  tokenAddress,
+  amount,
+  intentAddress,
+  chainId,
+}: {
+  trailsClient: TrailsAPIClient
+  userAddress: Address
+  tokenAddress: Address
+  amount: bigint | string
+  intentAddress: Address
+  chainId: number
+}): Promise<IntentEntrypointFeeOptionsResult> {
+  const params: IntentEntrypointFeeOptionsParams = {
+    userAddress,
+    tokenAddress,
+    amount: amount.toString(),
+    intentAddress,
+    chainID: chainId,
+  }
+
+  const response = await trailsClient.getIntentEntrypointDepositFeeOptions({
+    params,
+  })
+
+  return response.result
+}

package/src/intents.ts

@@ -5,8 +5,9 @@ import type {
   GetIntentCallsPayloadsReturn,
   IntentCallsPayload,
   IntentPrecondition,
-  SequenceAPIClient,
 } from "@0xsequence/trails-api"
+import type { TrailsAPIClient } from "@0xsequence/trails-api"
+import type { TrailsClient } from "./trailsClient.js"
 import { logger } from "./logger.js"
 import { bigintReplacer } from "./utils.js"
 
@@ -35,9 +36,7 @@ import {
 import {
   ATTESATION_SIGNER_ADDRESS,
   SEQUENCE_V3_CONTRACT_ADDRESSES,
-  TRAILS_CCTP_SAPIENT_SIGNER_ADDRESS,
-  TRAILS_LIFI_SAPIENT_SIGNER_ADDRESS,
-  TRAILS_RELAY_SAPIENT_SIGNER_ADDRESS,
+  SEQUENCE_V3_CONTRACT_ADDRESSES_OVERRIDES,
 } from "./constants.js"
 import { findPreconditionAddresses } from "./preconditions.js"
 import { getChainInfo } from "./chains.js"
@@ -129,58 +128,85 @@ export type SendOriginCallTxArgs = {
   chain: Chain
 }
 
-export async function getIntentCallsPayloads(
-  apiClient: SequenceAPIClient,
-  args: GetIntentCallsPayloadsArgs,
-  additionalTrackingProps: Record<string, string> = {},
-): Promise<GetIntentCallsPayloadsReturn> {
+export async function getLocalClientIfEnabled(
+  apiClient: TrailsAPIClient,
+): Promise<TrailsAPIClient> {
   const localApiIntent = getQueryParam("localapiintent") === "true"
   if (localApiIntent) {
     // for testing local api changes
-    const { getAPIClient } = await import("./apiClient.js")
-    apiClient = getAPIClient({
-      apiUrl: "http://localhost:4422",
+    const { getTrailsClient } = await import("./trailsClient.js")
+    apiClient = getTrailsClient({
+      hostname: "http://localhost:4422",
     })
   }
+  return apiClient
+}
+
+export async function getIntentCallsPayloads(
+  apiClient: TrailsAPIClient,
+  args: GetIntentCallsPayloadsArgs,
+  additionalTrackingProps: Record<string, string> = {},
+): Promise<GetIntentCallsPayloadsReturn> {
+  apiClient = await getLocalClientIfEnabled(apiClient)
 
   // Track intent quote request
   trackIntentQuoteRequested({
-    originChainId: args.originChainId || 0,
-    destinationChainId: args.destinationChainId || 0,
-    originTokenAddress: args.originTokenAddress,
-    destinationTokenAddress: args.destinationTokenAddress,
-    userAddress: args.userAddress,
+    originChainId: args.params.originChainId || 0,
+    destinationChainId: args.params.destinationChainId || 0,
+    originTokenAddress: args.params.originTokenAddress,
+    destinationTokenAddress: args.params.destinationTokenAddress,
+    userAddress: args.params.userAddress,
     ...additionalTrackingProps,
   })
 
   try {
     logger.console.log("[trails-sdk] getIntentCallsPayloads args:", args)
-    const result = await apiClient.getIntentCallsPayloads(args)
+    const result = await apiClient.getIntentCallsPayloads({
+      params: args.params,
+    })
 
     if (!result) {
       logger.console.error("[trails-sdk] No result from getIntentCallsPayloads")
       throw new Error("No result from getIntentCallsPayloads")
     }
 
+    // Extract precondition amounts
+    const originChainId = args.params.originChainId || 0
+    const destinationChainId = args.params.destinationChainId || 0
+    const originPrecondition = result.payloads.preconditions?.find(
+      (p: IntentPrecondition) => Number(p.chainId) === Number(originChainId),
+    )
+    const destinationPrecondition = result.payloads.preconditions?.find(
+      (p: IntentPrecondition) =>
+        Number(p.chainId) === Number(destinationChainId),
+    )
+
     // Track successful intent quote received
     trackIntentQuoteReceived({
-      quoteId: result.originIntentAddress || "unknown",
-      totalFeeUSD: result.trailsFee?.totalFeeUSD,
-      trailsFixedFeeUSD: result.trailsFee?.trailsFixedFeeUSD,
-      crossChainFeeTotalUSD: result.trailsFee?.crossChainFee?.totalFeeUSD,
-      takerFeeUSD: result.trailsFee?.crossChainFee?.providerFeeUSD,
-      providerFeeUSD: result.trailsFee?.crossChainFee?.providerFeeUSD,
-      trailsSwapFeeUSD: result.trailsFee?.crossChainFee?.trailsSwapFeeUSD,
+      quoteId: result.payloads.originIntentAddress || "unknown",
+      totalFeeUSD: result.payloads.trailsFee?.totalFeeUSD,
+      crossChainFeeTotalUSD:
+        result.payloads.trailsFee?.crossChainFee?.totalFeeUSD,
+      providerFeeUSD: result.payloads.trailsFee?.crossChainFee?.providerFeeUSD,
+      trailsSwapFeeUSD:
+        result.payloads.trailsFee?.crossChainFee?.trailsSwapFeeUSD,
       gasFeesPerChainUSD:
-        result.trailsFee?.executeQuote?.chainQuotes?.map((quote: any) =>
-          parseFloat(quote.totalFeeUSD || "0"),
+        result.payloads.trailsFee?.executeQuote?.chainQuotes?.map(
+          (quote: any) => parseFloat(quote.totalFeeUSD || "0"),
         ) || [],
-      originTokenTotalAmount: result.trailsFee?.originTokenTotalAmount,
-      destinationTokenAmount: result.trailsFee?.totalFeeAmount, // Using available property
-      provider: result.trailsFee?.quoteProvider,
-      feeToken: result.trailsFee?.feeToken,
-      userAddress: args.userAddress,
-      intentAddress: result.originIntentAddress,
+      originTokenTotalAmount: result.payloads.trailsFee?.originTokenTotalAmount,
+      totalFeeAmount: result.payloads.trailsFee?.totalFeeAmount, // Using available property
+      provider: result.payloads.trailsFee?.quoteProvider,
+      feeToken: result.payloads.trailsFee?.feeToken,
+      userAddress: args.params.userAddress,
+      intentAddress: result.payloads.originIntentAddress,
+      originPreconditionAmount: originPrecondition?.data?.min?.toString(),
+      destinationPreconditionAmount:
+        destinationPrecondition?.data?.min?.toString(),
+      fromAmount: result.payloads.quote?.fromAmount,
+      fromAmountMin: result.payloads.quote?.fromAmountMin,
+      toAmount: result.payloads.quote?.toAmount,
+      toAmountMin: result.payloads.quote?.toAmountMin,
       ...additionalTrackingProps,
     })
 
@@ -190,11 +216,11 @@ export async function getIntentCallsPayloads(
     // Track intent quote error
     trackIntentQuoteError({
       error: getFullErrorMessage(error),
-      userAddress: args.userAddress,
-      originChainId: args.originChainId || 0,
-      destinationChainId: args.destinationChainId || 0,
-      originTokenAddress: args.originTokenAddress,
-      destinationTokenAddress: args.destinationTokenAddress,
+      userAddress: args.params.userAddress,
+      originChainId: args.params.originChainId || 0,
+      destinationChainId: args.params.destinationChainId || 0,
+      originTokenAddress: args.params.originTokenAddress,
+      destinationTokenAddress: args.params.destinationTokenAddress,
       ...additionalTrackingProps,
     })
     throw error
@@ -277,13 +303,15 @@ export function calculateOriginAndDestinationIntentAddresses(
 }
 
 export async function commitIntentConfig(
-  apiClient: SequenceAPIClient,
+  apiClient: TrailsClient,
   mainSignerAddress: string,
   calls: Array<IntentCallsPayload>,
   preconditions: Array<IntentPrecondition>,
   additionalTrackingProps: Record<string, string> = {},
   requestParams?: IntentRequestParams,
 ): Promise<CommitIntentConfigReturn> {
+  apiClient = await getLocalClientIfEnabled(apiClient)
+
   logger.console.log("[trails-sdk] commitIntentConfig inputs:", {
     mainSignerAddress,
     calls: JSON.stringify(calls, bigintReplacer, 2),
@@ -336,12 +364,21 @@ export async function commitIntentConfig(
       isAddressEqual(Address.from(receivedAddress), originIntentAddress),
   })
 
+  const addressOverrides = SEQUENCE_V3_CONTRACT_ADDRESSES_OVERRIDES
+
   const args: CommitIntentConfigArgs = {
-    originIntentAddress: originIntentAddress.toString(),
-    destinationIntentAddress: destinationIntentAddress.toString(),
-    mainSigner: mainSignerAddress,
-    calls: calls,
-    preconditions: preconditions,
+    params: {
+      originIntentAddress: originIntentAddress.toString(),
+      destinationIntentAddress: destinationIntentAddress.toString(),
+      mainSigner: mainSignerAddress,
+      calls: calls,
+      preconditions: preconditions,
+      addressOverrides: addressOverrides,
+      requestParams: {
+        version: "1.0",
+        ...requestParams,
+      } as any,
+    },
   }
 
   // Add request parameters if provided
@@ -370,13 +407,6 @@ export async function commitIntentConfig(
     // This will need to be updated when the API client is regenerated
   }
 
-  const addressOverrides = {
-    trailsLiFiSapientSignerAddress: TRAILS_LIFI_SAPIENT_SIGNER_ADDRESS,
-    trailsRelaySapientSignerAddress: TRAILS_RELAY_SAPIENT_SIGNER_ADDRESS,
-    trailsCCTPV2SapientSignerAddress: TRAILS_CCTP_SAPIENT_SIGNER_ADDRESS,
-    ...args.addressOverrides,
-  }
-
   try {
     // Track successful intent commit
     trackIntentCommitStarted({
@@ -391,8 +421,6 @@ export async function commitIntentConfig(
 
     const result = await apiClient.commitIntentConfig({
       ...args,
-      addressOverrides,
-      // requestParams: requestParams, // TODO
     })
 
     // Track successful intent commit
@@ -458,13 +486,16 @@ export async function sendOriginTransaction(
     transport: http(),
   })
 
-  const gasLimit = await publicClient.estimateGas({
+  const estimatedGasLimit = await publicClient.estimateGas({
     account: account,
     to: originParams.to as `0x${string}`,
     data: originParams.data as `0x${string}`,
     value: BigInt(originParams.value),
   })
 
+  const gsaBuffer = BigInt(50_000)
+  const gasLimit = estimatedGasLimit + gsaBuffer
+
   logger.console.log("[trails-sdk] estimated gasLimit:", gasLimit)
 
   logger.console.log(

package/src/metaTxnMonitor.ts

@@ -92,6 +92,7 @@ export const useMetaTxnsMonitor = (
           }
           return newStatusEntry
         },
+        refetchIntervalInBackground: true,
         refetchInterval: (
           query: Query<
             Relayer.OperationStatus,

package/src/morpho.ts

@@ -295,11 +295,22 @@ function transformVaultToPool(vaultData: any): Pool | null {
     // Use the actual APY from the API
     const apy = state?.apy || state?.netApy || 0
 
+    const decimals = asset?.decimals
+    if (!decimals) {
+      // logger.console.warn("Decimals not found", {
+      //   asset,
+      //   state,
+      //   vaultData,
+      //   chainId,
+      // })
+      return null
+    }
+
     // Calculate TVL from totalAssetsUsd if available, otherwise from totalAssets
     const tvl = state?.totalAssetsUsd
       ? Number(state.totalAssetsUsd)
       : state?.totalAssets
-        ? Number(state.totalAssets) / 10 ** (asset?.decimals || 18)
+        ? Number(state.totalAssets) / 10 ** decimals
         : 0
 
     // Filter out vaults with TVL < 1M OR APY > 20%
@@ -324,7 +335,7 @@ function transformVaultToPool(vaultData: any): Pool | null {
         symbol: vaultData.symbol || asset?.symbol || "UNKNOWN",
         name: vaultData.name || asset?.name || "Unknown Token",
         address: asset?.address || vaultData.address,
-        decimals: asset?.decimals || 18,
+        decimals,
         logoUrl: asset?.logoURI || undefined,
       },
       depositAddress: vaultData.address,

package/src/pools.ts

@@ -1,19 +1,9 @@
-import { useMemo, useEffect } from "react"
+import { useMemo } from "react"
+import { useQuery } from "@tanstack/react-query"
 import { useAavePools } from "./aave.js"
 import { useMorphoVaults } from "./morpho.js"
 import { logger } from "./logger.js"
 
-// Cache configuration
-const CACHE_DURATION = 5 * 60 * 1000 // 5 minutes in milliseconds
-
-// Global cache for pools data
-let poolsCache: {
-  data: Pool[]
-  timestamp: number
-  aaveData: Pool[] | null
-  morphoData: Pool[] | null
-} | null = null
-
 // Pool data interface (shared across all protocols)
 export interface Pool {
   id: string
@@ -36,7 +26,7 @@ export interface Pool {
   wrappedTokenGatewayAddress?: string
 }
 
-export function usePools() {
+export function usePools({ enabled = true }: { enabled?: boolean } = {}) {
   // Fetch pools from Aave
   const {
     data: aavePools,
@@ -51,31 +41,18 @@ export function usePools() {
     error: morphoError,
   } = useMorphoVaults()
 
-  // Check if cache is valid
-  const isCacheValid = useMemo(() => {
-    if (!poolsCache) return false
-
-    const now = Date.now()
-    const isExpired = now - poolsCache.timestamp > CACHE_DURATION
-
-    // Check if underlying data has changed
-    const aaveDataChanged =
-      JSON.stringify(poolsCache.aaveData) !== JSON.stringify(aavePools)
-    const morphoDataChanged =
-      JSON.stringify(poolsCache.morphoData) !== JSON.stringify(morphoPools)
-
-    return !isExpired && !aaveDataChanged && !morphoDataChanged
-  }, [aavePools, morphoPools])
+  // Combine pools data with memoization
+  const combinedPools = useMemo(() => {
+    // Don't process if not enabled
+    if (!enabled) {
+      return []
+    }
 
-  // Combine and transform all pools with caching
-  const allPools: Pool[] = useMemo(() => {
-    // Return cached data if valid
-    if (isCacheValid && poolsCache) {
-      logger.console.log("[trails-sdk] Using cached pools data")
-      return poolsCache.data
+    if (!aavePools && !morphoPools) {
+      return []
     }
 
-    logger.console.log("[trails-sdk] Generating new pools data")
+    logger.console.log("[trails-sdk] Combining pools data from sources")
     const pools: Pool[] = []
 
     // Add Aave pools
@@ -88,68 +65,73 @@ export function usePools() {
       pools.push(...morphoPools)
     }
 
-    // Update cache
-    poolsCache = {
-      data: pools,
-      timestamp: Date.now(),
-      aaveData: aavePools,
-      morphoData: morphoPools,
+    // Sort by APY descending
+    const sortedPools = pools.sort((a: Pool, b: Pool) => b.apy - a.apy)
+
+    logger.console.log(
+      "[trails-sdk] Combined and sorted",
+      sortedPools.length,
+      "pools",
+    )
+    return sortedPools
+  }, [aavePools, morphoPools, enabled])
+
+  // Use React Query for caching the combined pools data
+  const { data: cachedPools } = useQuery({
+    queryKey: ["pools", "combined", combinedPools.length, enabled],
+    queryFn: async () => {
+      return combinedPools
+    },
+    enabled: enabled && combinedPools.length > 0,
+    staleTime: 5 * 60 * 1000, // 5 minutes
+    gcTime: 10 * 60 * 1000, // 10 minutes
+    refetchOnWindowFocus: false,
+    refetchIntervalInBackground: true,
+    refetchOnReconnect: true,
+    retry: 2,
+    initialData: combinedPools.length > 0 ? combinedPools : undefined,
+  })
+
+  // Determine loading state
+  const loading = useMemo(() => {
+    // If not enabled, never show loading
+    if (!enabled) {
+      return false
     }
 
-    return pools
-  }, [aavePools, morphoPools, isCacheValid])
-
-  // Determine overall loading and error states
-  const loading = useMemo(() => {
-    // Don't show loading if we have valid cached data
-    if (isCacheValid && poolsCache) {
+    // If we have cached data, never show loading (this is the key fix!)
+    if (cachedPools && cachedPools.length > 0) {
+      logger.console.log("[trails-sdk] Using cached pools, not showing loading")
       return false
     }
-    return aaveLoading || morphoLoading
-  }, [aaveLoading, morphoLoading, isCacheValid])
 
+    // Show loading if sources are still loading
+    const shouldShowLoading = aaveLoading || morphoLoading
+
+    if (shouldShowLoading) {
+      logger.console.log("[trails-sdk] Showing loading - sources still loading")
+    }
+
+    return shouldShowLoading
+  }, [aaveLoading, morphoLoading, cachedPools, enabled])
+
+  // Determine error state
   const error = useMemo(() => {
-    // Don't show error if we have valid cached data
-    if (isCacheValid && poolsCache) {
+    // If not enabled, don't show errors
+    if (!enabled) {
       return null
     }
-    return aaveError || morphoError
-  }, [aaveError, morphoError, isCacheValid])
-
-  // Sort by APY descending with caching
-  const sortedPools = useMemo(() => {
-    return allPools.sort((a: Pool, b: Pool) => b.apy - a.apy)
-  }, [allPools])
-
-  // Clear cache when there are errors
-  useEffect(() => {
-    if (aaveError || morphoError) {
-      logger.console.log("[trails-sdk] Clearing cache due to errors")
-      poolsCache = null
+
+    // If we have cached data, don't show errors
+    if (cachedPools && cachedPools.length > 0) {
+      return null
     }
-  }, [aaveError, morphoError])
-
-  // logger.console.log("[trails-sdk] === COMBINED POOLS DEBUG ===")
-  // logger.console.log("[trails-sdk] Cache valid:", isCacheValid)
-  // logger.console.log("[trails-sdk] Aave pools count:", aavePools?.length || 0)
-  // logger.console.log("[trails-sdk] Morpho pools count:", morphoPools?.length || 0)
-  // logger.console.log("[trails-sdk] Total pools count:", sortedPools.length)
-  // logger.console.log(
-  //   "[trails-sdk] Loading states - Aave:",
-  //   aaveLoading,
-  //   "Morpho:",
-  //   morphoLoading,
-  // )
-  // logger.console.log(
-  //   "[trails-sdk] Error states - Aave:",
-  //   aaveError,
-  //   "Morpho:",
-  //   morphoError,
-  // )
-  // logger.console.log("[trails-sdk] ==============================")
+
+    return aaveError || morphoError
+  }, [aaveError, morphoError, cachedPools, enabled])
 
   return {
-    data: sortedPools,
+    data: cachedPools || [],
     loading,
     error,
   }