@oydual31/more-vaults-sdk 0.1.2 → 0.1.3

package/src/react/useOmniRedeem.ts

@@ -0,0 +1,96 @@
+import { useState, useCallback } from 'react'
+import { usePublicClient, useWalletClient, useChainId } from 'wagmi'
+import {
+  asSdkClient,
+  redeemAsync,
+  getVaultStatus,
+} from '../viem/index.js'
+import type { AsyncRequestStatusInfo } from '../viem/index.js'
+import { useLzFee } from './useLzFee.js'
+import { useAsyncRequestStatus } from './useAsyncRequestStatus.js'
+
+interface UseOmniRedeemReturn {
+  /** Execute approve + redeemAsync. Handles everything internally. */
+  redeem: (sharesInWei: bigint, receiver: `0x${string}`, owner: `0x${string}`) => Promise<void>
+  isLoading: boolean
+  txHash: `0x${string}` | undefined
+  /** GUID for cross-chain tracking. Available after tx confirmation. */
+  guid: `0x${string}` | undefined
+  /** Cross-chain request status. undefined until a guid is available. */
+  requestStatus: AsyncRequestStatusInfo | undefined
+  /** true when the wallet is connected to the wrong chain */
+  wrongChain: boolean
+  error: Error | undefined
+  reset: () => void
+}
+
+/**
+ * Complete hook for async redeems on hub vaults (R5 flow).
+ *
+ * Handles: fee quote, chain validation, share approve, redeemAsync, and GUID polling.
+ *
+ * @example
+ * const { redeem, isLoading, guid, requestStatus, wrongChain } = useOmniRedeem('0xVAULT', 747)
+ *
+ * if (wrongChain) return <SwitchNetworkButton chainId={747} />
+ *
+ * await redeem(sharesInWei, userAddress, userAddress)
+ * // requestStatus.status goes: 'pending' → 'completed' | 'refunded'
+ */
+export function useOmniRedeem(
+  vault: `0x${string}` | undefined,
+  hubChainId: number,
+): UseOmniRedeemReturn {
+  const { data: walletClient } = useWalletClient({ chainId: hubChainId })
+  const publicClient = usePublicClient({ chainId: hubChainId })
+  const currentChainId = useChainId()
+
+  const [isLoading, setIsLoading] = useState(false)
+  const [txHash, setTxHash] = useState<`0x${string}` | undefined>()
+  const [guid, setGuid] = useState<`0x${string}` | undefined>()
+  const [error, setError] = useState<Error | undefined>()
+
+  const { feeWithBuffer } = useLzFee(vault, hubChainId)
+  const { data: requestStatus } = useAsyncRequestStatus(vault, guid, hubChainId)
+
+  const wrongChain = currentChainId !== hubChainId
+
+  const redeem = useCallback(
+    async (sharesInWei: bigint, receiver: `0x${string}`, owner: `0x${string}`) => {
+      if (!vault || !walletClient || !publicClient || !feeWithBuffer) return
+      setIsLoading(true)
+      setError(undefined)
+      try {
+        const pc = asSdkClient(publicClient)
+        const status = await getVaultStatus(pc, vault)
+        // walletClient from wagmi is structurally compatible with viem WalletClient
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const result = await redeemAsync(
+          walletClient as any,
+          pc,
+          { vault, escrow: status.escrow, hubChainId },
+          sharesInWei,
+          receiver,
+          owner,
+          feeWithBuffer,
+        )
+        setTxHash(result.txHash)
+        setGuid(result.guid)
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)))
+      } finally {
+        setIsLoading(false)
+      }
+    },
+    [vault, walletClient, publicClient, feeWithBuffer, hubChainId],
+  )
+
+  const reset = useCallback(() => {
+    setTxHash(undefined)
+    setGuid(undefined)
+    setError(undefined)
+    setIsLoading(false)
+  }, [])
+
+  return { redeem, isLoading, txHash, guid, requestStatus, wrongChain, error, reset }
+}

package/src/react/useRedeemShares.ts

@@ -0,0 +1,77 @@
+import { useState, useCallback } from 'react'
+import { usePublicClient, useWalletClient } from 'wagmi'
+import { asSdkClient, redeemShares } from '../viem/index.js'
+import type { RedeemResult } from '../viem/index.js'
+
+interface UseRedeemSharesReturn {
+  /** Execute redeemShares (R1 flow). */
+  redeem: (sharesInWei: bigint, receiver: `0x${string}`, owner: `0x${string}`) => Promise<void>
+  isLoading: boolean
+  txHash: `0x${string}` | undefined
+  /** Assets received. Available after tx confirmation. */
+  assets: bigint | undefined
+  error: Error | undefined
+  reset: () => void
+}
+
+/**
+ * Hook for standard ERC-4626 share redemption (R1 flow).
+ *
+ * Used for local and oracle-on cross-chain vaults.
+ * No LZ fee required — single transaction.
+ *
+ * @example
+ * const { redeem, isLoading, txHash, assets } = useRedeemShares('0xVAULT', 747)
+ * await redeem(sharesInWei, userAddress, userAddress)
+ */
+export function useRedeemShares(
+  vault: `0x${string}` | undefined,
+  chainId: number,
+): UseRedeemSharesReturn {
+  const { data: walletClient } = useWalletClient({ chainId })
+  const publicClient = usePublicClient({ chainId })
+
+  const [isLoading, setIsLoading] = useState(false)
+  const [result, setResult] = useState<RedeemResult | undefined>()
+  const [error, setError] = useState<Error | undefined>()
+
+  const redeem = useCallback(
+    async (sharesInWei: bigint, receiver: `0x${string}`, owner: `0x${string}`) => {
+      if (!vault || !walletClient || !publicClient) return
+      setIsLoading(true)
+      setError(undefined)
+      try {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const res = await redeemShares(
+          walletClient as any,
+          asSdkClient(publicClient),
+          { vault, hubChainId: chainId },
+          sharesInWei,
+          receiver,
+          owner,
+        )
+        setResult(res)
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)))
+      } finally {
+        setIsLoading(false)
+      }
+    },
+    [vault, walletClient, publicClient, chainId],
+  )
+
+  const reset = useCallback(() => {
+    setResult(undefined)
+    setError(undefined)
+    setIsLoading(false)
+  }, [])
+
+  return {
+    redeem,
+    isLoading,
+    txHash: result?.txHash,
+    assets: result?.assets,
+    error,
+    reset,
+  }
+}

package/src/react/useSmartDeposit.ts

@@ -0,0 +1,70 @@
+import type { DepositResult, AsyncRequestResult, AsyncRequestStatusInfo } from '../viem/index.js'
+import { useVaultStatus } from './useVaultStatus.js'
+import { useOmniDeposit } from './useOmniDeposit.js'
+import { useDepositSimple } from './useDepositSimple.js'
+
+interface UseSmartDepositReturn {
+  /**
+   * Execute deposit using the correct flow for this vault's mode.
+   * For async vaults: wraps depositAsync (D4) — returns guid for tracking.
+   * For local/oracle vaults: wraps depositSimple (D1/D3) — returns shares.
+   */
+  deposit: (amountInWei: bigint, receiver: `0x${string}`) => Promise<void>
+  isLoading: boolean
+  txHash: `0x${string}` | undefined
+  /** Shares minted (available for D1/D3 vaults after confirmation, undefined for D4). */
+  shares: bigint | undefined
+  /** GUID for cross-chain tracking (D4 vaults only). */
+  guid: `0x${string}` | undefined
+  /** Cross-chain request status (D4 vaults only). */
+  requestStatus: AsyncRequestStatusInfo | undefined
+  /** true when the wallet is connected to the wrong chain (D4 vaults only). */
+  wrongChain: boolean
+  /** Vault mode loaded from getVaultStatus. undefined while loading. */
+  vaultMode: 'local' | 'cross-chain-oracle' | 'cross-chain-async' | 'paused' | 'full' | undefined
+  error: Error | undefined
+  reset: () => void
+}
+
+/**
+ * Auto-selects the correct deposit flow based on vault mode.
+ * Best for frontends that support multiple vault types.
+ *
+ * Internally uses useVaultStatus to detect the mode, then delegates to:
+ * - useOmniDeposit (D4) for 'cross-chain-async' vaults
+ * - useDepositSimple (D1/D3) for 'local' and 'cross-chain-oracle' vaults
+ *
+ * @example
+ * const { deposit, isLoading, guid, requestStatus, vaultMode } = useSmartDeposit('0xVAULT', 747)
+ *
+ * if (vaultMode === 'paused') return <PausedBadge />
+ *
+ * await deposit(parseUnits('100', 6), userAddress)
+ * // For async vaults: poll requestStatus until 'completed'
+ * // For sync vaults: txHash + shares are available immediately
+ */
+export function useSmartDeposit(
+  vault: `0x${string}` | undefined,
+  hubChainId: number,
+): UseSmartDepositReturn {
+  const { data: status } = useVaultStatus(vault, hubChainId)
+  const omni = useOmniDeposit(vault, hubChainId)
+  const simple = useDepositSimple(vault, hubChainId)
+
+  const isAsync = status?.mode === 'cross-chain-async'
+
+  const deposit = isAsync ? omni.deposit : simple.deposit
+
+  return {
+    deposit,
+    isLoading: isAsync ? omni.isLoading : simple.isLoading,
+    txHash: isAsync ? omni.txHash : simple.txHash,
+    shares: isAsync ? undefined : simple.shares,
+    guid: isAsync ? omni.guid : undefined,
+    requestStatus: isAsync ? omni.requestStatus : undefined,
+    wrongChain: isAsync ? omni.wrongChain : false,
+    vaultMode: status?.mode,
+    error: isAsync ? omni.error : simple.error,
+    reset: isAsync ? omni.reset : simple.reset,
+  }
+}

package/src/react/useUserPosition.ts

@@ -0,0 +1,29 @@
+import { useQuery } from '@tanstack/react-query'
+import { usePublicClient } from 'wagmi'
+import { asSdkClient, getUserPosition } from '../viem/index.js'
+import type { UserPosition } from '../viem/index.js'
+
+export type { UserPosition }
+
+/**
+ * Read the user's current position in a vault.
+ * Refetches every 15s to keep the balance display current.
+ *
+ * @example
+ * const { data: position } = useUserPosition('0xVAULT', '0xUSER', 747)
+ * // position.shares, position.estimatedAssets, position.pendingWithdrawal
+ */
+export function useUserPosition(
+  vault: `0x${string}` | undefined,
+  user: `0x${string}` | undefined,
+  chainId: number,
+) {
+  const publicClient = usePublicClient({ chainId })
+  return useQuery({
+    queryKey: ['userPosition', vault, user, chainId],
+    queryFn: () => getUserPosition(asSdkClient(publicClient), vault!, user!),
+    enabled: !!vault && !!user && !!publicClient,
+    refetchInterval: 15_000,
+    staleTime: 10_000,
+  })
+}

package/src/react/useVaultMetadata.ts

@@ -0,0 +1,29 @@
+import { useQuery } from '@tanstack/react-query'
+import { usePublicClient } from 'wagmi'
+import { asSdkClient, getVaultMetadata } from '../viem/index.js'
+import type { VaultMetadata } from '../viem/index.js'
+
+export type { VaultMetadata }
+
+/**
+ * Read display metadata for a vault and its underlying token.
+ * Uses a long stale time (5 min) because metadata rarely changes.
+ *
+ * @example
+ * const { data: meta } = useVaultMetadata('0xVAULT', 747)
+ * // meta.name, meta.symbol, meta.underlying, meta.underlyingSymbol
+ */
+export function useVaultMetadata(
+  vault: `0x${string}` | undefined,
+  chainId: number,
+) {
+  const publicClient = usePublicClient({ chainId })
+  return useQuery({
+    queryKey: ['vaultMetadata', vault, chainId],
+    queryFn: () => getVaultMetadata(asSdkClient(publicClient), vault!),
+    enabled: !!vault && !!publicClient,
+    // Metadata (name, symbol, underlying) changes very rarely — 5 min stale time
+    staleTime: 5 * 60_000,
+    refetchInterval: 5 * 60_000,
+  })
+}

package/src/react/useVaultStatus.ts

@@ -0,0 +1,34 @@
+import { useQuery } from '@tanstack/react-query'
+import { usePublicClient } from 'wagmi'
+import { asSdkClient, getVaultStatus } from '../viem/index.js'
+import type { VaultStatus } from '../viem/index.js'
+
+export type { VaultStatus }
+
+interface UseVaultStatusOptions {
+  /** Refetch interval in ms. Default: 30_000 (30s) */
+  refetchInterval?: number
+}
+
+/**
+ * Read the full vault status snapshot.
+ * Automatically refetches on a configurable interval.
+ *
+ * @example
+ * const { data: status, isLoading } = useVaultStatus('0xVAULT', 747)
+ * if (status?.mode === 'cross-chain-async') { ... }
+ */
+export function useVaultStatus(
+  vault: `0x${string}` | undefined,
+  chainId: number,
+  options?: UseVaultStatusOptions,
+) {
+  const publicClient = usePublicClient({ chainId })
+  return useQuery({
+    queryKey: ['vaultStatus', vault, chainId],
+    queryFn: () => getVaultStatus(asSdkClient(publicClient), vault!),
+    enabled: !!vault && !!publicClient,
+    refetchInterval: options?.refetchInterval ?? 30_000,
+    staleTime: 15_000,
+  })
+}