0xtrails 0.13.2 → 0.14.0

package/src/poolUtils.ts

@@ -1,222 +0,0 @@
-import { encodeFunctionData, type WalletClient } from "viem"
-import { logger } from "./logger.js"
-import type { Pool } from "./pools.js"
-import { isValidStringAmount, isPositiveBigInt } from "./utils/validation.js"
-
-/**
- * Generate Aave deposit calldata
- * @param walletClient - The wallet client
- * @param pool - The pool to deposit into
- * @param amount - The amount to deposit in wei
- */
-export function generateAaveDepositCalldata(
-  walletClient: WalletClient,
-  pool: Pool,
-  amount: string,
-): `0x${string}` | undefined {
-  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 (!isValidStringAmount(amount)) {
-      throw new Error(`Invalid amount: ${amount}`)
-    }
-
-    // Validate amount can be converted to BigInt
-    if (!isPositiveBigInt(amount)) {
-      throw new Error(`Invalid amount format: ${amount}`)
-    }
-    const amountBigInt = BigInt(amount)
-
-    // Aave V3 Pool contract deposit function
-    // function supply(address asset, uint256 amount, address onBehalfOf, uint16 referralCode)
-    const calldata = encodeFunctionData({
-      abi: [
-        {
-          name: "supply",
-          type: "function",
-          inputs: [
-            { name: "asset", type: "address" },
-            { name: "amount", type: "uint256" },
-            { name: "onBehalfOf", type: "address" },
-            { name: "referralCode", type: "uint16" },
-          ],
-          outputs: [],
-          stateMutability: "nonpayable",
-        },
-      ],
-      args: [
-        pool.token.address as `0x${string}`, // asset address
-        amountBigInt, // amount to deposit
-        addressStr as `0x${string}`, // onBehalfOf (user's address)
-        0, // referralCode (0 for no referral)
-      ],
-    })
-    logger.console.log("Generated Aave supply calldata:", calldata)
-    return calldata
-  } catch (error) {
-    logger.console.error("Error generating Aave deposit calldata:", error)
-    return undefined
-  }
-}
-
-/**
- * Generate Morpho deposit calldata
- * @param walletClient - The wallet client
- * @param amount - The amount to deposit in wei
- */
-export function generateMorphoDepositCalldata(
-  walletClient: WalletClient,
-  amount: string,
-): `0x${string}` | undefined {
-  try {
-    const userAddress = walletClient?.account?.address || walletClient?.account
-    if (!userAddress) {
-      throw new Error("User address not found")
-    }
-
-    // Validate amount
-    if (!isValidStringAmount(amount)) {
-      throw new Error("Invalid amount")
-    }
-
-    // Morpho Vault deposit function
-    // function deposit(uint256 assets, address receiver) returns (uint256 shares)
-    const calldata = encodeFunctionData({
-      abi: [
-        {
-          name: "deposit",
-          type: "function",
-          inputs: [
-            { name: "assets", type: "uint256" },
-            { name: "receiver", type: "address" },
-          ],
-          outputs: [{ name: "shares", type: "uint256" }],
-          stateMutability: "nonpayable",
-        },
-      ],
-      args: [
-        BigInt(amount), // amount to deposit
-        userAddress as `0x${string}`, // receiver (user's address)
-      ],
-    })
-    logger.console.log("Generated Morpho deposit calldata:", calldata)
-    return calldata
-  } catch (error) {
-    logger.console.error("Error generating Morpho deposit calldata:", error)
-    return undefined
-  }
-}
-
-/**
- * Generate Aave withdraw calldata
- * @param asset - The address of the underlying asset to withdraw
- * @param amount - The amount to withdraw in wei
- * @param to - The address that will receive the underlying tokens
- */
-export function generateAaveWithdrawCalldata(
-  asset: string,
-  amount: bigint,
-  to: string,
-): `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 Morpho vault withdraw calldata
- * @param amount - The amount of underlying assets to withdraw in wei
- * @param to - The address that will receive the underlying tokens (receiver)
- * @param owner - Optional owner address (defaults to 'to' if not provided)
- */
-export function generateMorphoWithdrawCalldata(
-  amount: bigint,
-  to: string,
-  owner?: string,
-): `0x${string}` {
-  const ownerAddress = owner || to
-  return encodeFunctionData({
-    abi: [
-      {
-        name: "withdraw",
-        type: "function",
-        stateMutability: "nonpayable",
-        inputs: [
-          { name: "assets", type: "uint256" },
-          { name: "receiver", type: "address" },
-          { name: "owner", type: "address" },
-        ],
-        outputs: [{ type: "uint256" }],
-      },
-    ],
-    functionName: "withdraw",
-    args: [amount, to as `0x${string}`, ownerAddress as `0x${string}`],
-  })
-}

package/src/pools.ts

@@ -1,120 +0,0 @@
-import { useQuery } from "@tanstack/react-query"
-import { useTrailsClient } from "./trailsClient.js"
-import { logger } from "./logger.js"
-import { queryPersister } from "./query/persister.js"
-import { DAY_MS } from "./utils/time.js"
-import type { EarnPool } from "@0xtrails/api"
-
-// Cache duration for earn pools (24 hours)
-// This is persisted to localStorage via React Query's persist client
-const EARN_POOLS_CACHE_DURATION = DAY_MS
-
-// Pool data interface (shared across all protocols)
-export interface Pool {
-  id: string
-  name: string
-  protocol: string
-  chainId: number
-  apy: number
-  tvl: number
-  token: {
-    symbol: string
-    name: string
-    address: string
-    decimals: number
-    logoUrl?: string
-  }
-  depositAddress: string
-  isActive: boolean
-  poolUrl?: string
-  protocolUrl?: string
-  wrappedTokenGatewayAddress?: string
-}
-
-// Transform EarnPool from API to our Pool interface
-function transformPool(apiPool: EarnPool): Pool {
-  return {
-    id: apiPool.id,
-    name: apiPool.name,
-    protocol: apiPool.protocol,
-    chainId: apiPool.chainId,
-    apy: apiPool.apy,
-    tvl: apiPool.tvl,
-    token: {
-      symbol: apiPool.token.symbol,
-      name: apiPool.token.name,
-      address: apiPool.token.address,
-      decimals: apiPool.token.decimals,
-      logoUrl: apiPool.token.logoUrl,
-    },
-    depositAddress: apiPool.depositAddress,
-    isActive: apiPool.isActive,
-    poolUrl: apiPool.poolUrl,
-    protocolUrl: apiPool.protocolUrl,
-    wrappedTokenGatewayAddress: apiPool.wrappedTokenGatewayAddress,
-  }
-}
-
-/**
- * Hook to fetch pools from the Trails API backend
- * Aggregates pool data from Aave and Morpho protocols
- */
-export function usePools({ enabled = true }: { enabled?: boolean } = {}) {
-  const client = useTrailsClient()
-
-  const query = useQuery({
-    queryKey: ["pools", "api", "v1", enabled],
-    queryFn: async () => {
-      if (!enabled) {
-        return []
-      }
-
-      logger.console.log("[trails-sdk] Fetching pools from API...")
-
-      try {
-        const response = await client.getEarnPools({
-          chainIds: [1, 8453, 42161, 137, 10, 100],
-          minTvl: 1000000, // $1M minimum TVL
-          maxApy: 20, // 20% maximum APY
-        })
-
-        logger.console.log(
-          "[trails-sdk] Fetched",
-          response.pools.length,
-          "pools from API",
-          response.cached ? "(cached)" : "(fresh)",
-        )
-
-        // Transform the pools to match our interface
-        const transformedPools = response.pools.map(transformPool)
-
-        // Sort by APY descending (in case backend doesn't sort)
-        transformedPools.sort((a, b) => b.apy - a.apy)
-
-        return transformedPools
-      } catch (error) {
-        logger.console.error(
-          "[trails-sdk] Failed to fetch pools from API:",
-          error,
-        )
-        throw error
-      }
-    },
-    enabled: enabled && !!client,
-    staleTime: EARN_POOLS_CACHE_DURATION,
-    gcTime: EARN_POOLS_CACHE_DURATION,
-    refetchOnMount: false, // Don't refetch when cached data exists (persistence-friendly)
-    refetchOnWindowFocus: false,
-    refetchOnReconnect: false,
-    retry: 2,
-    persister: queryPersister.persisterFn,
-  })
-
-  return {
-    data: query.data || [],
-    loading: query.isLoading,
-    error: query.error,
-  }
-}
-
-export default usePools