@whisk/steakhouse 0.0.4 → 0.0.5

package/src/queries/getVaults.test.ts

@@ -0,0 +1,186 @@
+import { beforeEach, describe, expect, it, vi } from "vitest"
+import { createMockClient } from "../../test/mocks.js"
+import { getVaults } from "./getVaults.js"
+
+// Mock the metadata module
+vi.mock("../metadata/vaults.js", () => ({
+  ALL_VAULTS: [
+    {
+      chainId: 1,
+      address: "0x1111111111111111111111111111111111111111",
+      protocol: "morpho_v1",
+      name: "Steakhouse USDC",
+      description: "A USDC vault",
+      tag: "featured",
+    },
+    {
+      chainId: 1,
+      address: "0x2222222222222222222222222222222222222222",
+      protocol: "morpho_v1",
+      name: "Steakhouse ETH",
+    },
+    {
+      chainId: 8453,
+      address: "0x3333333333333333333333333333333333333333",
+      protocol: "morpho_v2",
+    },
+    {
+      chainId: 1,
+      address: "0x4444444444444444444444444444444444444444",
+      protocol: "morpho_v1",
+      isHidden: true, // Should be excluded
+    },
+  ],
+}))
+
+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("excludes hidden vaults from whitelist", async () => {
+    const client = createMockClient(
+      createMockVaultResponse([
+        { vaultAddress: "0x1111111111111111111111111111111111111111" },
+        { vaultAddress: "0x2222222222222222222222222222222222222222" },
+      ]),
+    )
+
+    await getVaults(client, { chainId: 1 })
+
+    // Should not include the hidden vault (0x4444...)
+    const call = vi.mocked(client.query).mock.calls[0]
+    const keys = call[1].where.keys as Array<{ vaultAddress: string }>
+    expect(keys.map((k) => k.vaultAddress)).not.toContain(
+      "0x4444444444444444444444444444444444444444",
+    )
+  })
+
+  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",
+      tag: "featured",
+      protocol: "morpho_v1",
+    })
+  })
+
+  it("handles vaults without metadata overrides", async () => {
+    const client = createMockClient(
+      createMockVaultResponse([{ vaultAddress: "0x3333333333333333333333333333333333333333" }]),
+    )
+
+    const result = await getVaults(client, { chainId: 8453 })
+
+    expect(result[0].steakhouseMetadata).toEqual({
+      protocol: "morpho_v2",
+    })
+  })
+
+  it("returns all non-hidden 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, // 3 non-hidden vaults
+      }),
+    )
+  })
+})

package/src/queries/getVaults.ts

@@ -1,28 +1,77 @@
-import { graphql, type ResultOf } from "@whisk/graphql"
-import type { VariablesOf } from "gql.tada"
+import { graphql } from "@whisk/graphql"
 import type { SteakhouseClient } from "../client.js"
-import { vaultFragment } from "./fragments/vault.js"
+import type { Address, VaultConfig } from "../metadata/types.js"
+import { ALL_VAULTS } from "../metadata/vaults.js"
+import { type VaultDetail, vaultDetailFragment } from "./fragments/vaultDetail.js"
+import { buildSteakhouseMetadata, type SteakhouseMetadata } from "./steakhouseMetadata.js"
 
-export const vaultQuery = graphql(
+/** GraphQL query for fetching Steakhouse vaults */
+export const vaultsQuery = graphql(
   `
-    query GetVaults($limit: Int!) {
-      morphoVaults(limit: $limit) {
+    query GetVaults($where: Erc4626VaultFilter, $limit: Int) {
+      erc4626Vaults(where: $where, limit: $limit) {
         items {
-          ...VaultFragment
+          ...VaultDetailFragment
         }
       }
     }
   `,
-  [vaultFragment],
+  [vaultDetailFragment],
 )
 
-export type GetVaultsVariables = VariablesOf<typeof vaultQuery>
-export type GetVaultsResult = ResultOf<typeof vaultQuery>["morphoVaults"]["items"]
+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,
+  variables: GetVaultsVariables = {},
 ): Promise<GetVaultsResult> {
-  const result = await client.query(vaultQuery, variables)
-  return result.morphoVaults.items
+  const { chainId } = variables
+
+  const filteredVaults = ALL_VAULTS.filter(
+    (v) => !v.isHidden && (!chainId || v.chainId === chainId),
+  )
+
+  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/index.ts

@@ -1,8 +1,10 @@
-export { type Vault, vaultFragment } from "./fragments/vault.js"
-export {
-  type GetVaultsResult,
-  type GetVaultsVariables,
-  getVaults,
-  vaultQuery,
-} from "./getVaults.js"
+// Fragments
+export { type VaultDetail, vaultDetailFragment } from "./fragments/vaultDetail.js"
+// Queries
+export * from "./getDetailedVault.js"
+export * from "./getVaults.js"
+// Shared
+export { buildSteakhouseMetadata, type SteakhouseMetadata } from "./steakhouseMetadata.js"
+
+// Types
 export type { SteakhouseQueryFn } from "./types.js"

package/src/queries/steakhouseMetadata.ts

@@ -0,0 +1,19 @@
+import type { VaultConfig } from "../metadata/types.js"
+
+/** Steakhouse-specific metadata augmented onto vault data */
+export type SteakhouseMetadata = {
+  name?: string
+  description?: string
+  tag?: VaultConfig["tag"]
+  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.tag !== undefined && { tag: config.tag }),
+  }
+}

package/src/react/hooks/index.ts

@@ -1,2 +1,3 @@
+export { useDetailedVault } from "./useDetailedVault.js"
 export { useSteakhouseQuery } from "./useSteakhouseQuery.js"
 export { useVaults } from "./useVaults.js"

package/src/react/hooks/useDetailedVault.ts

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

package/src/react/hooks/useVaults.ts

@@ -1,9 +1,14 @@
 "use client"
 
-import { type GetVaultsVariables, getVaults } from "../../queries/getVaults.js"
+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) {
+export function useVaults(variables: GetVaultsVariables): UseQueryResult<GetVaultsResult, Error> {
   return useSteakhouseQuery({
     queryName: "vaults",
     queryFn: getVaults,

package/src/react/index.ts

@@ -1,7 +1,2 @@
 export * from "./hooks/index.js"
-export {
-  type SteakhouseContextValue,
-  SteakhouseProvider,
-  type SteakhouseProviderProps,
-  useSteakhouse,
-} from "./provider.js"
+export * from "./provider.js"

package/dist/queries/fragments/vault.d.ts

@@ -1,19 +0,0 @@
-import * as gql_tada from 'gql.tada';
-import { FragmentOf } from '@whisk/graphql';
-
-declare const vaultFragment: gql_tada.TadaDocumentNode<{
-    chain: {
-        id: number;
-    };
-    vaultAddress: `0x${string}`;
-    totalSupplied: {
-        raw: bigint;
-    };
-}, {}, {
-    fragment: "VaultFragment";
-    on: "MorphoVault";
-    masked: false;
-}>;
-type Vault = FragmentOf<typeof vaultFragment>;
-
-export { type Vault, vaultFragment };

package/dist/queries/fragments/vault.js

@@ -1,16 +0,0 @@
-import { graphql } from "@whisk/graphql";
-const vaultFragment = graphql(`
-  fragment VaultFragment on MorphoVault {
-    chain {
-      id
-    }
-    vaultAddress
-    totalSupplied {
-      raw
-    }
-  }
-`);
-export {
-  vaultFragment
-};
-//# sourceMappingURL=vault.js.map

package/dist/queries/fragments/vault.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/queries/fragments/vault.ts"],"sourcesContent":["import { type FragmentOf, graphql } from \"@whisk/graphql\"\n\nexport const vaultFragment = graphql(`\n  fragment VaultFragment on MorphoVault {\n    chain {\n      id\n    }\n    vaultAddress\n    totalSupplied {\n      raw\n    }\n  }\n`)\n\nexport type Vault = FragmentOf<typeof vaultFragment>\n"],"mappings":"AAAA,SAA0B,eAAe;AAElC,MAAM,gBAAgB,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,CAUpC;","names":[]}

package/src/client.test.ts

@@ -1,27 +0,0 @@
-import { describe, expect, it } from "vitest"
-import { SteakhouseClient } from "./client.js"
-
-describe("SteakhouseClient", () => {
-  it("creates client with config", () => {
-    const client = new SteakhouseClient({
-      apiKey: "test-key",
-    })
-    expect(client).toBeDefined()
-  })
-
-  it("creates client with custom url", () => {
-    const client = new SteakhouseClient({
-      apiKey: "test-key",
-      url: "https://custom.api.example.com/graphql",
-    })
-    expect(client).toBeDefined()
-  })
-
-  it("creates client with debug mode", () => {
-    const client = new SteakhouseClient({
-      apiKey: "test-key",
-      debug: true,
-    })
-    expect(client).toBeDefined()
-  })
-})

package/src/queries/fragments/vault.ts

@@ -1,15 +0,0 @@
-import { type FragmentOf, graphql } from "@whisk/graphql"
-
-export const vaultFragment = graphql(`
-  fragment VaultFragment on MorphoVault {
-    chain {
-      id
-    }
-    vaultAddress
-    totalSupplied {
-      raw
-    }
-  }
-`)
-
-export type Vault = FragmentOf<typeof vaultFragment>