┌─────────────────────────────────────────────────────────────────┐
│                           CLIENTS                               │
│                                                                 │
│   React apps          ──▶  CuratorProvider + hooks             │
│   Other web apps      ──▶  CuratorSDK class                    │
│   CLI tools           ──▶  CuratorSDK class                    │
│   AI agents / bots    ──▶  CuratorSDK class                    │
│   Keepers / cron      ──▶  CuratorSDK class                    │
│   Chat bots           ──▶  CuratorSDK class                    │
│   Other protocols     ──▶  contracts directly                  │
├─────────────────────────────────────────────────────────────────┤
│                     @curator-studio/sdk                         │
│                                                                 │
│   React layer    CuratorProvider, hooks (optional, needs React) │
│   Core layer     CuratorSDK class, indexer client (pure TS)     │
├─────────────────────────────────────────────────────────────────┤
│                     @curator-studio/indexer                     │
│                                                                 │
│   GraphQL          /graphql — strategies, distributions, etc.   │
│   REST (analytics) /api/strategies/trending, /api/stats         │
│   REST (social)    /api/drafts, /api/comments, /api/reactions   │
│   REST (notifs)    /api/notifications (authenticated)           │
├─────────────────────────────────────────────────────────────────┤
│                     ON-CHAIN CONTRACTS                          │
│                                                                 │
│   StrategyFactory          Deploys strategy clones (per tenant) │
│   Strategy                 Allocations, distribute, rebalance   │
│   SplitsWarehouse          ERC-6909 vault, withdraw (shared)    │
│   YieldRedirector4626      Wraps ERC-4626, redirects yield      │
│   ForeverSubnameRegistrar  *.tenant.eth ENS subdomains          │
└─────────────────────────────────────────────────────────────────┘

npm install @curator-studio/sdk

import { CuratorSDK } from "@curator-studio/sdk";

const sdk = new CuratorSDK(walletClient, { tenant: "support.eth" });

const sdk = new CuratorSDK(walletClient, {
  tenant: "support.eth",
  indexerUrl: "https://curatefund-multi-tenant-production.up.railway.app",
});

import { CuratorProvider, useStrategies } from "@curator-studio/sdk/react";

function App() {
  return (
    <CuratorProvider
      tenant="support.eth"
      indexerUrl="https://curatefund-multi-tenant-production.up.railway.app"
    >
      <StrategyList />
    </CuratorProvider>
  );
}

function StrategyList() {
  const { data, isPending } = useStrategies({
    orderBy: "timesForked",
    orderDirection: "desc",
    limit: 10,
  });
  if (isPending) return <div>Loading...</div>;
  return data?.items.map((s) => <div key={s.id}>{s.metadata?.title}</div>);
}

import { CuratorSDK } from "@curator-studio/sdk";
import { createWalletClient, http } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { baseSepolia } from "viem/chains";

const wallet = createWalletClient({
  account: privateKeyToAccount(process.env.PRIVATE_KEY),
  chain: baseSepolia,
  transport: http(),
});

const sdk = new CuratorSDK(wallet, {
  tenant: "support.eth",
  indexerUrl: "https://curatefund-multi-tenant-production.up.railway.app",
});

const { items } = await sdk.indexer.strategy.query({ limit: 5 });
await sdk.strategy.distribute(items[0].id, tokenAddress);

for (const strategy of strategies.items) {
  const balance = await sdk.strategy.balanceOf(strategy.id, tokenAddress);
  if (balance > threshold) {
    await sdk.strategy.distribute(strategy.id, tokenAddress);
  }
}

const stats = await sdk.indexer.stats();
const trending = await sdk.indexer.trending({ period: "7d", limit: 5 });

await sdk.strategy.create({
  owner: wallet.account.address,
  allocations: [
    { recipient: "0x...", weight: 60n, label: "Top project" },
    { recipient: "0x...", weight: 40n, label: "Runner up" },
  ],
  metadataURI: "https://...",
  sourceStrategy: "0x0000000000000000000000000000000000000000",
});

query {
  strategys(where: { tenantId: "support.eth" }, limit: 10) {
    items {
      id
      owner
      metadataURI
      totalWeight
    }
  }
}

const response = await fetch(
  "https://curatefund-multi-tenant-production.up.railway.app/api/drafts",
  {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: `Bearer ${jwt}`,
    },
    body: JSON.stringify({
      title: "My Strategy Draft",
      description: "A new allocation strategy",
      allocations: [
        { recipient: "0xabc...", weight: 60, label: "Project A" },
        { recipient: "0xdef...", weight: 40, label: "Project B" },
      ],
    }),
  },
);

const { data } = await response.json();

// sdk.indexer.draft.*
await sdk.indexer.draft.create({ title: "...", description: "...", allocations: [...] });
await sdk.indexer.draft.list({ curator: "0x..." });
await sdk.indexer.draft.update(id, { title: "Updated title" });
await sdk.indexer.draft.publish(id, strategyAddress);

// sdk.indexer.comment.*
await sdk.indexer.comment.create({ targetId: strategyId, targetType: "strategy", body: "Nice picks!" });
await sdk.indexer.comment.list({ targetId: strategyId, targetType: "strategy" });

// sdk.indexer.reaction.*
await sdk.indexer.reaction.toggle({ targetId: commentId, targetType: "comment", type: "upvote" });

// sdk.indexer.notification.*
const { data: notifications } = await sdk.indexer.notification.list();
const count = await sdk.indexer.notification.unreadCount();

import {
  useComments,
  useCreateComment,
  useReactions,
  useToggleReaction,
  useNotifications,
  useUnreadNotificationCount,
} from "@curator-studio/sdk/react";

function CommentSection({ strategyId }: { strategyId: string }) {
  const { data: comments } = useComments({
    targetId: strategyId,
    targetType: "strategy",
  });
  const { data: reactions } = useReactions(strategyId, "strategy");
  const { mutate: createComment } = useCreateComment();
  const { mutate: toggleReaction } = useToggleReaction();

  return (
    <div>
      <button
        onClick={() =>
          toggleReaction({
            targetId: strategyId,
            targetType: "strategy",
            type: "upvote",
          })
        }
      >
        Upvote ({reactions?.counts.upvote ?? 0})
      </button>
      {comments?.data.map((c) => (
        <p key={c.id}>{c.body}</p>
      ))}
    </div>
  );
}