@whisk/steakhouse 0.0.6 → 0.0.8

package/src/queries/getDetailedVault.test.ts

@@ -1,202 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest"
-import { createMockClient } from "../../test/mocks.js"
-import { getDetailedVault } from "./getDetailedVault.js"
-
-// Mock the generated vaults module
-vi.mock("../metadata/generated/vaults.js", () => ({
-  STEAKHOUSE_VAULTS: [
-    {
-      chainId: 1,
-      address: "0x1111111111111111111111111111111111111111",
-      protocol: "morpho_v1",
-      name: "Steakhouse USDC",
-      description: "A USDC vault",
-      type: "Prime",
-    },
-    {
-      chainId: 1,
-      address: "0x2222222222222222222222222222222222222222",
-      protocol: "morpho_v1",
-      name: "Steakhouse ETH",
-      description: "An ETH vault",
-    },
-  ],
-}))
-
-function createMockVaultDetailResponse(vault: { vaultAddress: string } | null) {
-  if (!vault) {
-    return { erc4626Vaults: { items: [] } }
-  }
-
-  return {
-    erc4626Vaults: {
-      items: [
-        {
-          chain: { id: 1, name: "Ethereum", icon: "https://eth.icon" },
-          vaultAddress: vault.vaultAddress,
-          name: "API Vault Name",
-          symbol: "VAULT",
-          decimals: 18,
-          asset: {
-            address: "0xasset",
-            symbol: "USDC",
-            name: "USD Coin",
-            icon: "https://icon.url",
-            priceUsd: 1.0,
-            decimals: 6,
-          },
-          totalAssets: { raw: "1000000000000", formatted: "1000000", usd: 1000000 },
-          totalLiquidity: { formatted: "500000", usd: 500000 },
-          apy: {
-            base: 0.05,
-            total: 0.08,
-            rewards: [{ token: { symbol: "MORPHO", icon: "https://morpho.icon" }, apr: 0.03 }],
-            fee: 0.01,
-          },
-          performanceFee: 0.1,
-          feeRecipientAddress: "0xfee",
-          ownerAddress: "0xowner",
-          curatorAddress: "0xcurator",
-          guardianAddress: "0xguardian",
-          metadata: {
-            description: "API description",
-            image: "https://image.url",
-            forumLink: "https://forum.url",
-            curator: {
-              name: "Curator",
-              image: "https://curator.image",
-              url: "https://curator.url",
-            },
-            curators: [],
-          },
-          marketAllocations: [],
-          riskAssessment: { steakhouse: { score: 0.8, rating: "A" } },
-          // Historical data (only in historical query)
-          historical: {
-            daily: [
-              {
-                bucketTimestamp: 1704067200,
-                totalSupplied: { formatted: "1000000", usd: 1000000 },
-                supplyApy7d: { total: 0.08 },
-              },
-            ],
-          },
-        },
-      ],
-    },
-  }
-}
-
-describe("getDetailedVault", () => {
-  beforeEach(() => {
-    vi.clearAllMocks()
-  })
-
-  it("returns null for vault not in whitelist", async () => {
-    const client = createMockClient({})
-
-    const result = await getDetailedVault(client, {
-      chainId: 1,
-      address: "0x9999999999999999999999999999999999999999",
-    })
-
-    expect(result).toBeNull()
-    expect(client.query).not.toHaveBeenCalled()
-  })
-
-  it("returns null for vault on wrong chain", async () => {
-    const client = createMockClient({})
-
-    const result = await getDetailedVault(client, {
-      chainId: 8453, // Wrong chain
-      address: "0x1111111111111111111111111111111111111111",
-    })
-
-    expect(result).toBeNull()
-    expect(client.query).not.toHaveBeenCalled()
-  })
-
-  it("returns vault with historical data by default", async () => {
-    const client = createMockClient(
-      createMockVaultDetailResponse({
-        vaultAddress: "0x1111111111111111111111111111111111111111",
-      }),
-    )
-
-    const result = await getDetailedVault(client, {
-      chainId: 1,
-      address: "0x1111111111111111111111111111111111111111",
-    })
-
-    expect(result).not.toBeNull()
-    expect(result?.historical).toBeDefined()
-  })
-
-  it("can exclude historical data", async () => {
-    const mockResponse = createMockVaultDetailResponse({
-      vaultAddress: "0x1111111111111111111111111111111111111111",
-    })
-    // Remove historical from response
-    // biome-ignore lint/complexity/useLiteralKeys: Needed for index signature access
-    delete (mockResponse.erc4626Vaults.items[0] as Record<string, unknown>)["historical"]
-
-    const client = createMockClient(mockResponse)
-
-    const result = await getDetailedVault(client, {
-      chainId: 1,
-      address: "0x1111111111111111111111111111111111111111",
-      historical: false,
-    })
-
-    expect(result).not.toBeNull()
-    // Different query should be called (without historical fragment)
-    expect(client.query).toHaveBeenCalled()
-  })
-
-  it("augments result with steakhouse metadata", async () => {
-    const client = createMockClient(
-      createMockVaultDetailResponse({
-        vaultAddress: "0x1111111111111111111111111111111111111111",
-      }),
-    )
-
-    const result = await getDetailedVault(client, {
-      chainId: 1,
-      address: "0x1111111111111111111111111111111111111111",
-    })
-
-    expect(result?.steakhouseMetadata).toEqual({
-      name: "Steakhouse USDC",
-      description: "A USDC vault",
-      type: "Prime",
-      protocol: "morpho_v1",
-    })
-  })
-
-  it("handles case-insensitive address matching", async () => {
-    const client = createMockClient(
-      createMockVaultDetailResponse({
-        vaultAddress: "0x1111111111111111111111111111111111111111",
-      }),
-    )
-
-    const result = await getDetailedVault(client, {
-      chainId: 1,
-      // Uppercase address
-      address: "0x1111111111111111111111111111111111111111".toUpperCase() as `0x${string}`,
-    })
-
-    expect(result).not.toBeNull()
-  })
-
-  it("returns null when API returns no results", async () => {
-    const client = createMockClient(createMockVaultDetailResponse(null))
-
-    const result = await getDetailedVault(client, {
-      chainId: 1,
-      address: "0x1111111111111111111111111111111111111111",
-    })
-
-    expect(result).toBeNull()
-  })
-})

package/src/queries/getDetailedVault.ts

@@ -1,131 +0,0 @@
-import { graphql } from "@whisk/graphql"
-import type { SteakhouseClient } from "../client.js"
-import { STEAKHOUSE_VAULTS } from "../metadata/generated/vaults.js"
-import type { Address } from "../metadata/types.js"
-import { type VaultDetail, vaultDetailFragment } from "./fragments/vaultDetail.js"
-import { buildSteakhouseMetadata, type SteakhouseMetadata } from "./steakhouseMetadata.js"
-
-/** Historical data fragment for vault charts (works for both v1 and v2) */
-const vaultHistoricalFragment = graphql(`
-  fragment VaultHistoricalFragment on Erc4626Vault {
-    ... on MorphoVault {
-      historical {
-        daily {
-          bucketTimestamp
-          totalSupplied {
-            formatted
-            usd
-          }
-          supplyApy7d {
-            total
-          }
-        }
-      }
-    }
-    ... on MorphoVaultV2 {
-      historical {
-        daily {
-          bucketTimestamp
-          totalSupplied {
-            formatted
-            usd
-          }
-          supplyApy7d {
-            total
-          }
-        }
-      }
-    }
-  }
-`)
-
-/** Historical data type extracted from the fragment */
-type VaultHistoricalData = {
-  daily: Array<{
-    bucketTimestamp: number
-    totalSupplied: { formatted: string; usd: number | null }
-    supplyApy7d: { total: number }
-  }>
-}
-
-/** Query for fetching a single vault without historical data */
-export const vaultQuery = graphql(
-  `
-    query GetVault($where: Erc4626VaultFilter) {
-      erc4626Vaults(where: $where, limit: 1) {
-        items {
-          ...VaultDetailFragment
-        }
-      }
-    }
-  `,
-  [vaultDetailFragment],
-)
-
-/** Query for fetching a single vault with historical data */
-export const vaultWithHistoricalQuery = graphql(
-  `
-    query GetVaultWithHistorical($where: Erc4626VaultFilter) {
-      erc4626Vaults(where: $where, limit: 1) {
-        items {
-          ...VaultDetailFragment
-          ...VaultHistoricalFragment
-        }
-      }
-    }
-  `,
-  [vaultDetailFragment, vaultHistoricalFragment],
-)
-
-export type GetDetailedVaultVariables = {
-  chainId: number
-  address: Address
-  /** Include historical data for charts (default: true) */
-  historical?: boolean
-}
-
-/** Vault detail with Steakhouse metadata and optional historical data */
-export type DetailedVault = VaultDetail & {
-  historical?: VaultHistoricalData | null
-  steakhouseMetadata: SteakhouseMetadata
-}
-
-export type GetDetailedVaultResult = DetailedVault | null
-
-/**
- * Get full details for a single Steakhouse vault with optional historical data.
- * Returns null if the vault is not in the whitelist.
- */
-export async function getDetailedVault(
-  client: SteakhouseClient,
-  variables: GetDetailedVaultVariables,
-): Promise<GetDetailedVaultResult> {
-  const { chainId, address, historical = true } = variables
-
-  const vaultConfig = STEAKHOUSE_VAULTS.find(
-    (v) => v.chainId === chainId && v.address.toLowerCase() === address.toLowerCase(),
-  )
-
-  if (!vaultConfig) {
-    return null
-  }
-
-  const where = {
-    keys: [
-      {
-        chainId,
-        vaultAddress: address,
-        protocol: vaultConfig.protocol,
-      },
-    ],
-  }
-  const query = historical ? vaultWithHistoricalQuery : vaultQuery
-  const result = await client.query(query, { where })
-  const vault = result.erc4626Vaults.items[0]
-
-  if (!vault) {
-    return null
-  }
-
-  return { ...vault, steakhouseMetadata: buildSteakhouseMetadata(vaultConfig) }
-}

package/src/queries/getVaults.test.ts

@@ -1,167 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest"
-import { createMockClient } from "../../test/mocks.js"
-import { getVaults } from "./getVaults.js"
-
-// Mock the generated vaults module
-vi.mock("../metadata/generated/vaults.js", () => ({
-  STEAKHOUSE_VAULTS: [
-    {
-      chainId: 1,
-      address: "0x1111111111111111111111111111111111111111",
-      protocol: "morpho_v1",
-      name: "Steakhouse USDC",
-      description: "A USDC vault",
-      type: "Prime",
-    },
-    {
-      chainId: 1,
-      address: "0x2222222222222222222222222222222222222222",
-      protocol: "morpho_v1",
-      name: "Steakhouse ETH",
-      description: "An ETH vault",
-    },
-    {
-      chainId: 8453,
-      address: "0x3333333333333333333333333333333333333333",
-      protocol: "morpho_v2",
-      name: "Base Vault",
-      description: "A Base vault",
-    },
-  ],
-}))
-
-function createMockVaultResponse(vaults: Array<{ vaultAddress: string }>) {
-  return {
-    erc4626Vaults: {
-      items: vaults.map((v) => ({
-        chain: { id: 1, name: "Ethereum", icon: "https://chain.icon" },
-        vaultAddress: v.vaultAddress,
-        name: "API Vault Name",
-        symbol: "VAULT",
-        decimals: 18,
-        asset: {
-          address: "0xasset",
-          symbol: "USDC",
-          name: "USD Coin",
-          icon: "https://icon.url",
-          priceUsd: 1.0,
-          decimals: 6,
-        },
-        totalAssets: { raw: "1000000000000", formatted: "1000000", usd: 1000000 },
-        totalLiquidity: { formatted: "500000", usd: 500000 },
-        apy: { base: 0.05, total: 0.08, rewards: [], fee: 0.1 },
-        performanceFee: 0.1,
-        feeRecipientAddress: "0xfee",
-        ownerAddress: "0xowner",
-        curatorAddress: "0xcurator",
-        guardianAddress: "0xguardian",
-        metadata: {
-          description: "A vault",
-          image: null,
-          forumLink: null,
-          curator: null,
-          curators: [],
-        },
-        marketAllocations: [],
-        riskAssessment: { steakhouse: { score: 0.8, rating: "A" } },
-      })),
-    },
-  }
-}
-
-describe("getVaults", () => {
-  beforeEach(() => {
-    vi.clearAllMocks()
-  })
-
-  it("returns empty array when no vaults in whitelist match filter", async () => {
-    const client = createMockClient({ erc4626Vaults: { items: [] } })
-
-    // Filter for a chain with no vaults
-    const result = await getVaults(client, { chainId: 999 })
-
-    expect(result).toEqual([])
-    // Should not call API if no vaults match
-    expect(client.query).not.toHaveBeenCalled()
-  })
-
-  it("filters vaults by chainId", async () => {
-    const client = createMockClient(
-      createMockVaultResponse([
-        { vaultAddress: "0x1111111111111111111111111111111111111111" },
-        { vaultAddress: "0x2222222222222222222222222222222222222222" },
-      ]),
-    )
-
-    const result = await getVaults(client, { chainId: 1 })
-
-    expect(result).toHaveLength(2)
-    expect(client.query).toHaveBeenCalledWith(
-      expect.anything(),
-      expect.objectContaining({
-        where: expect.objectContaining({
-          keys: expect.arrayContaining([
-            expect.objectContaining({
-              chainId: 1,
-              vaultAddress: "0x1111111111111111111111111111111111111111",
-              protocol: "morpho_v1",
-            }),
-            expect.objectContaining({
-              chainId: 1,
-              vaultAddress: "0x2222222222222222222222222222222222222222",
-              protocol: "morpho_v1",
-            }),
-          ]),
-        }),
-      }),
-    )
-  })
-
-  it("augments results with steakhouse metadata", async () => {
-    const client = createMockClient(
-      createMockVaultResponse([{ vaultAddress: "0x1111111111111111111111111111111111111111" }]),
-    )
-
-    const result = await getVaults(client, { chainId: 1 })
-
-    expect(result[0]?.steakhouseMetadata).toEqual({
-      name: "Steakhouse USDC",
-      description: "A USDC vault",
-      type: "Prime",
-      protocol: "morpho_v1",
-    })
-  })
-
-  it("handles vaults without type", async () => {
-    const client = createMockClient(
-      createMockVaultResponse([{ vaultAddress: "0x3333333333333333333333333333333333333333" }]),
-    )
-
-    const result = await getVaults(client, { chainId: 8453 })
-
-    expect(result[0]?.steakhouseMetadata).toEqual({
-      name: "Base Vault",
-      description: "A Base vault",
-      protocol: "morpho_v2",
-    })
-  })
-
-  it("returns all vaults when no chainId filter", async () => {
-    const client = createMockClient(
-      createMockVaultResponse([
-        { vaultAddress: "0x1111111111111111111111111111111111111111" },
-        { vaultAddress: "0x2222222222222222222222222222222222222222" },
-        { vaultAddress: "0x3333333333333333333333333333333333333333" },
-      ]),
-    )
-
-    await getVaults(client)
-
-    expect(client.query).toHaveBeenCalledWith(
-      expect.anything(),
-      expect.objectContaining({
-        limit: 3,
-      }),
-    )
-  })
-})

package/src/queries/getVaults.ts

@@ -1,77 +0,0 @@
-import { graphql } from "@whisk/graphql"
-import type { SteakhouseClient } from "../client.js"
-import { STEAKHOUSE_VAULTS } from "../metadata/generated/vaults.js"
-import type { Address, VaultConfig } from "../metadata/types.js"
-import { type VaultDetail, vaultDetailFragment } from "./fragments/vaultDetail.js"
-import { buildSteakhouseMetadata, type SteakhouseMetadata } from "./steakhouseMetadata.js"
-
-/** GraphQL query for fetching Steakhouse vaults */
-export const vaultsQuery = graphql(
-  `
-    query GetVaults($where: Erc4626VaultFilter, $limit: Int) {
-      erc4626Vaults(where: $where, limit: $limit) {
-        items {
-          ...VaultDetailFragment
-        }
-      }
-    }
-  `,
-  [vaultDetailFragment],
-)
-
-export type GetVaultsVariables = {
-  /** Filter by chain ID */
-  chainId?: number
-}
-
-/** Vault with Steakhouse metadata */
-export type VaultWithMetadata = VaultDetail & {
-  steakhouseMetadata?: SteakhouseMetadata
-}
-
-export type GetVaultsResult = VaultWithMetadata[]
-
-/**
- * Get all Steakhouse-curated vaults.
- * Results are filtered to the SDK whitelist and augmented with Steakhouse metadata.
- */
-export async function getVaults(
-  client: SteakhouseClient,
-  variables: GetVaultsVariables = {},
-): Promise<GetVaultsResult> {
-  const { chainId } = variables
-
-  const filteredVaults = chainId
-    ? STEAKHOUSE_VAULTS.filter((v) => v.chainId === chainId)
-    : STEAKHOUSE_VAULTS
-
-  if (filteredVaults.length === 0) {
-    return []
-  }
-
-  // Build keys array for erc4626Vaults filter
-  const keys = filteredVaults.map((v) => ({
-    chainId: v.chainId,
-    vaultAddress: v.address,
-    protocol: v.protocol,
-  }))
-
-  const result = await client.query(vaultsQuery, {
-    where: { keys },
-    limit: keys.length,
-  })
-
-  const metadataMap = new Map<Address, VaultConfig>(
-    filteredVaults.map((v) => [v.address.toLowerCase() as Address, v]),
-  )
-
-  return result.erc4626Vaults.items
-    .filter((vault): vault is NonNullable<typeof vault> => vault !== null)
-    .map((vault) => {
-      const config = metadataMap.get(vault.vaultAddress.toLowerCase() as Address)
-      if (config) {
-        return { ...vault, steakhouseMetadata: buildSteakhouseMetadata(config) }
-      }
-      return vault
-    })
-}

package/src/queries/steakhouseMetadata.ts

@@ -1,19 +0,0 @@
-import type { VaultConfig } from "../metadata/types.js"
-
-/** Steakhouse-specific metadata augmented onto vault data */
-export type SteakhouseMetadata = {
-  name?: string
-  description?: string
-  type?: VaultConfig["type"]
-  protocol: VaultConfig["protocol"]
-}
-
-/** Build metadata object from vault config */
-export function buildSteakhouseMetadata(config: VaultConfig): SteakhouseMetadata {
-  return {
-    protocol: config.protocol,
-    ...(config.name !== undefined && { name: config.name }),
-    ...(config.description !== undefined && { description: config.description }),
-    ...(config.type !== undefined && { type: config.type }),
-  }
-}

package/src/queries/types.ts

@@ -1,6 +0,0 @@
-import type { SteakhouseClient } from "../client.js"
-
-export type SteakhouseQueryFn<TData, TVariables> = (
-  client: SteakhouseClient,
-  variables: TVariables,
-) => Promise<TData>

package/src/react/hooks/useDetailedVault.ts

@@ -1,19 +0,0 @@
-"use client"
-
-import type { UseQueryResult } from "@tanstack/react-query"
-import {
-  type GetDetailedVaultResult,
-  type GetDetailedVaultVariables,
-  getDetailedVault,
-} from "../../queries/getDetailedVault.js"
-import { useSteakhouseQuery } from "./useSteakhouseQuery.js"
-
-export function useDetailedVault(
-  variables: GetDetailedVaultVariables,
-): UseQueryResult<GetDetailedVaultResult, Error> {
-  return useSteakhouseQuery({
-    queryName: "detailedVault",
-    queryFn: getDetailedVault,
-    variables,
-  })
-}

package/src/react/hooks/useSteakhouseQuery.ts

@@ -1,17 +0,0 @@
-"use client"
-
-import { type UseQueryResult, useQuery } from "@tanstack/react-query"
-import type { SteakhouseQueryFn } from "../../queries/types.js"
-import { useSteakhouse } from "../provider.js"
-
-export function useSteakhouseQuery<TData, TVariables>(options: {
-  queryName: string
-  queryFn: SteakhouseQueryFn<TData, TVariables>
-  variables: TVariables
-}): UseQueryResult<TData, Error> {
-  const { client } = useSteakhouse()
-  return useQuery({
-    queryKey: ["steakhouse", options.queryName, options.variables],
-    queryFn: () => options.queryFn(client, options.variables),
-  })
-}

package/src/react/hooks/useVaults.ts

@@ -1,17 +0,0 @@
-"use client"
-
-import type { UseQueryResult } from "@tanstack/react-query"
-import {
-  type GetVaultsResult,
-  type GetVaultsVariables,
-  getVaults,
-} from "../../queries/getVaults.js"
-import { useSteakhouseQuery } from "./useSteakhouseQuery.js"
-
-export function useVaults(variables: GetVaultsVariables): UseQueryResult<GetVaultsResult, Error> {
-  return useSteakhouseQuery({
-    queryName: "vaults",
-    queryFn: getVaults,
-    variables,
-  })
-}