@curator-studio/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,1820 @@
+// src/index.ts
+import {
+  createPublicClient,
+  http
+} from "viem";
+import { mainnet as mainnet2, sepolia as sepolia2, baseSepolia as baseSepolia2, hardhat as hardhat2 } from "viem/chains";
+
+// src/lib/indexer.ts
+import { Client, fetchExchange, gql } from "@urql/core";
+var strategiesQuery = gql`
+  query Strategies(
+    $where: strategyFilter
+    $orderBy: String
+    $orderDirection: String
+    $limit: Int
+    $after: String
+  ) {
+    strategys(
+      where: $where
+      orderBy: $orderBy
+      orderDirection: $orderDirection
+      limit: $limit
+      after: $after
+    ) {
+      items {
+        id
+        chainId
+        tenantId
+        owner
+        sourceStrategy
+        metadataURI
+        feeRecipient
+        feeBps
+        metadata
+        allocations {
+          items {
+            recipient
+            weight
+            label
+            version
+          }
+        }
+        allocationsVersion
+        ensLabel
+        timesForked
+        uniqueDonors
+        createdAt
+        createdAtBlock
+        lastUpdatedAt
+        lastUpdatedAtBlock
+      }
+      totalCount
+      pageInfo {
+        hasNextPage
+        endCursor
+      }
+    }
+  }
+`;
+var strategyQuery = gql`
+  query Strategy($id: String!) {
+    strategy(id: $id) {
+      id
+      chainId
+      tenantId
+      owner
+      sourceStrategy
+      metadataURI
+      feeRecipient
+      feeBps
+      metadata
+      ensLabel
+      allocations {
+        items {
+          recipient
+          weight
+          label
+          version
+        }
+      }
+      allocationsVersion
+      timesForked
+      uniqueDonors
+      createdAt
+      createdAtBlock
+      lastUpdatedAt
+      lastUpdatedAtBlock
+    }
+  }
+`;
+var distributionsQuery = gql`
+  query Distributions(
+    $where: distributionFilter
+    $orderBy: String
+    $orderDirection: String
+    $limit: Int
+    $after: String
+  ) {
+    distributions(
+      where: $where
+      orderBy: $orderBy
+      orderDirection: $orderDirection
+      limit: $limit
+      after: $after
+    ) {
+      items {
+        id
+        strategyId
+        token
+        totalAmount
+        totalAmountUSD
+        allocationsVersion
+        allocations
+        timestamp
+        blockNumber
+        txHash
+      }
+      totalCount
+      pageInfo {
+        hasNextPage
+        endCursor
+      }
+    }
+  }
+`;
+var payoutsQuery = gql`
+  query Payouts(
+    $where: payoutFilter
+    $orderBy: String
+    $orderDirection: String
+    $limit: Int
+    $after: String
+  ) {
+    payouts(
+      where: $where
+      orderBy: $orderBy
+      orderDirection: $orderDirection
+      limit: $limit
+      after: $after
+    ) {
+      items {
+        id
+        strategyId
+        distributionId
+        recipient
+        token
+        amount
+        amountUSD
+        timestamp
+        blockNumber
+        txHash
+      }
+      totalCount
+      pageInfo {
+        hasNextPage
+        endCursor
+      }
+    }
+  }
+`;
+var donorsQuery = gql`
+  query Donors(
+    $where: donorFilter
+    $orderBy: String
+    $orderDirection: String
+    $limit: Int
+    $after: String
+  ) {
+    donors(
+      where: $where
+      orderBy: $orderBy
+      orderDirection: $orderDirection
+      limit: $limit
+      after: $after
+    ) {
+      items {
+        id
+        strategyId
+        address
+        firstDonationAt
+        lastDonationAt
+        totalDonations
+      }
+      totalCount
+      pageInfo {
+        hasNextPage
+        endCursor
+      }
+    }
+  }
+`;
+var strategyBalancesQuery = gql`
+  query StrategyBalances(
+    $where: strategyBalanceFilter
+    $orderBy: String
+    $orderDirection: String
+    $limit: Int
+    $after: String
+  ) {
+    strategyBalances(
+      where: $where
+      orderBy: $orderBy
+      orderDirection: $orderDirection
+      limit: $limit
+      after: $after
+    ) {
+      items {
+        id
+        strategyId
+        token
+        balance
+        totalReceived
+        totalDistributed
+        totalReceivedUSD
+        totalDistributedUSD
+        lastUpdatedAt
+      }
+      totalCount
+      pageInfo {
+        hasNextPage
+        endCursor
+      }
+    }
+  }
+`;
+var warehouseBalancesQuery = gql`
+  query WarehouseBalances(
+    $where: warehouseBalanceFilter
+    $orderBy: String
+    $orderDirection: String
+    $limit: Int
+    $after: String
+  ) {
+    warehouseBalances(
+      where: $where
+      orderBy: $orderBy
+      orderDirection: $orderDirection
+      limit: $limit
+      after: $after
+    ) {
+      items {
+        id
+        user
+        token
+        balance
+        totalEarned
+        totalClaimed
+        totalEarnedUSD
+        lastUpdatedAt
+      }
+      totalCount
+      pageInfo {
+        hasNextPage
+        endCursor
+      }
+    }
+  }
+`;
+var forksQuery = gql`
+  query Forks(
+    $where: forkFilter
+    $orderBy: String
+    $orderDirection: String
+    $limit: Int
+    $after: String
+  ) {
+    forks(
+      where: $where
+      orderBy: $orderBy
+      orderDirection: $orderDirection
+      limit: $limit
+      after: $after
+    ) {
+      items {
+        id
+        sourceStrategyId
+        childStrategyId
+        createdAt
+      }
+      totalCount
+      pageInfo {
+        hasNextPage
+        endCursor
+      }
+    }
+  }
+`;
+var yieldRedirectorsQuery = gql`
+  query YieldRedirectors(
+    $where: yieldRedirectorFilter
+    $orderBy: String
+    $orderDirection: String
+    $limit: Int
+    $after: String
+  ) {
+    yieldRedirectors(
+      where: $where
+      orderBy: $orderBy
+      orderDirection: $orderDirection
+      limit: $limit
+      after: $after
+    ) {
+      items {
+        id
+        owner
+        sourceVault
+        yieldRecipient
+        asset
+        name
+        symbol
+        principal
+        totalHarvested
+        totalHarvestedUSD
+        harvestCount
+        lastHarvestAt
+        createdAt
+        createdAtBlock
+      }
+      totalCount
+      pageInfo {
+        hasNextPage
+        endCursor
+      }
+    }
+  }
+`;
+var yieldRedirectorQuery = gql`
+  query YieldRedirector($id: String!) {
+    yieldRedirector(id: $id) {
+      id
+      owner
+      sourceVault
+      yieldRecipient
+      asset
+      name
+      symbol
+      principal
+      totalHarvested
+      totalHarvestedUSD
+      harvestCount
+      lastHarvestAt
+      createdAt
+      createdAtBlock
+    }
+  }
+`;
+var harvestsQuery = gql`
+  query Harvests(
+    $where: harvestFilter
+    $orderBy: String
+    $orderDirection: String
+    $limit: Int
+    $after: String
+  ) {
+    harvests(
+      where: $where
+      orderBy: $orderBy
+      orderDirection: $orderDirection
+      limit: $limit
+      after: $after
+    ) {
+      items {
+        id
+        redirectorId
+        amount
+        amountUSD
+        recipient
+        timestamp
+        blockNumber
+        txHash
+      }
+      totalCount
+      pageInfo {
+        hasNextPage
+        endCursor
+      }
+    }
+  }
+`;
+function createIndexer(url, tenant) {
+  if (!url) throw new Error("No indexer URL provided. Pass indexerUrl to CuratorSDK or CuratorProvider.");
+  const baseUrl = url.replace(/\/graphql$/, "");
+  const client = new Client({
+    url,
+    exchanges: [fetchExchange],
+    requestPolicy: "network-only",
+    preferGetMethod: false
+  });
+  const indexer = {
+    client,
+    gql,
+    baseUrl,
+    extend(extension) {
+      const extended = extension(indexer);
+      return Object.assign(indexer, extended);
+    },
+    strategy: {
+      get: async (id) => {
+        const result = await client.query(strategyQuery, { id: id.toLowerCase() }).toPromise();
+        const strategy = result.data?.strategy;
+        if (!strategy) return null;
+        const currentAllocations = (strategy.allocations?.items ?? []).filter(
+          (a) => a.version === strategy.allocationsVersion
+        );
+        return {
+          ...strategy,
+          allocations: currentAllocations
+        };
+      },
+      query: async (variables = {}) => {
+        const where = tenant ? { tenantId: tenant, ...variables.where } : variables.where;
+        const result = await client.query(strategiesQuery, { ...variables, where }).toPromise();
+        const data = result.data?.strategys;
+        if (!data) return null;
+        return {
+          ...data,
+          items: data.items.map((s) => {
+            const currentAllocations = (s.allocations?.items ?? []).filter(
+              (a) => a.version === s.allocationsVersion
+            );
+            return {
+              ...s,
+              allocations: currentAllocations
+            };
+          })
+        };
+      }
+    },
+    distribution: {
+      query: async (variables = {}) => {
+        const result = await client.query(distributionsQuery, variables).toPromise();
+        return result.data?.distributions ?? null;
+      }
+    },
+    payout: {
+      query: async (variables = {}) => {
+        const result = await client.query(payoutsQuery, variables).toPromise();
+        return result.data?.payouts ?? null;
+      }
+    },
+    donor: {
+      query: async (variables = {}) => {
+        const result = await client.query(donorsQuery, variables).toPromise();
+        return result.data?.donors ?? null;
+      }
+    },
+    strategyBalance: {
+      query: async (variables = {}) => {
+        const result = await client.query(strategyBalancesQuery, variables).toPromise();
+        return result.data?.strategyBalances ?? null;
+      }
+    },
+    warehouseBalance: {
+      query: async (variables = {}) => {
+        const result = await client.query(warehouseBalancesQuery, variables).toPromise();
+        return result.data?.warehouseBalances ?? null;
+      }
+    },
+    fork: {
+      query: async (variables = {}) => {
+        const result = await client.query(forksQuery, variables).toPromise();
+        return result.data?.forks ?? null;
+      }
+    },
+    yieldRedirector: {
+      get: async (id) => {
+        const result = await client.query(yieldRedirectorQuery, { id: id.toLowerCase() }).toPromise();
+        return result.data?.yieldRedirector ?? null;
+      },
+      query: async (variables = {}) => {
+        const result = await client.query(yieldRedirectorsQuery, variables).toPromise();
+        return result.data?.yieldRedirectors ?? null;
+      }
+    },
+    harvest: {
+      query: async (variables = {}) => {
+        const result = await client.query(harvestsQuery, variables).toPromise();
+        return result.data?.harvests ?? null;
+      }
+    },
+    // REST API methods
+    trending: async (options) => {
+      const params = new URLSearchParams();
+      if (options?.period) params.set("period", options.period);
+      if (options?.limit) params.set("limit", options.limit.toString());
+      const queryString = params.toString();
+      const url2 = `${baseUrl}/api/strategies/trending${queryString ? `?${queryString}` : ""}`;
+      const response = await fetch(url2);
+      return response.json();
+    },
+    stats: async () => {
+      const response = await fetch(`${baseUrl}/api/stats`);
+      const data = await response.json();
+      return data.data;
+    },
+    lineage: async (strategyAddress) => {
+      const response = await fetch(
+        `${baseUrl}/api/strategies/${strategyAddress.toLowerCase()}/lineage`
+      );
+      if (!response.ok) return null;
+      const data = await response.json();
+      return data.data;
+    }
+  };
+  return indexer;
+}
+
+// src/config.ts
+import { mainnet, sepolia, baseSepolia, hardhat } from "viem/chains";
+import deployments from "@curator-studio/contracts/deployments.json";
+var tenants = buildTenantsFromDeployments();
+function buildTenantsFromDeployments() {
+  const result = {};
+  const d = deployments;
+  for (const [chainIdStr, chainData] of Object.entries(d)) {
+    const chainId = Number(chainIdStr);
+    if (chainData.tenants) {
+      for (const [tenantId, tenantData] of Object.entries(chainData.tenants)) {
+        if (!result[tenantId]) result[tenantId] = {};
+        result[tenantId][chainId] = {
+          ensDomain: tenantData.ensDomain ?? tenantId,
+          factory: tenantData.StrategyFactory?.address,
+          startBlock: tenantData.StrategyFactory?.startBlock,
+          foreverSubnameRegistrar: tenantData.ForeverSubnameRegistrar?.address
+        };
+      }
+    }
+    if (!chainData.tenants && chainData.StrategyFactory) {
+      const defaultTenant = "default";
+      if (!result[defaultTenant]) result[defaultTenant] = {};
+      result[defaultTenant][chainId] = {
+        ensDomain: defaultTenant,
+        factory: chainData.StrategyFactory.address,
+        startBlock: chainData.StrategyFactory.startBlock,
+        foreverSubnameRegistrar: chainData.ForeverSubnameRegistrar?.address
+      };
+    }
+  }
+  return result;
+}
+var config = {
+  [mainnet.id]: {
+    warehouse: "0x8fb66F38cF86A3d5e8768f8F1754A24A6c661Fb8"
+  },
+  [sepolia.id]: {
+    warehouse: "0x8fb66F38cF86A3d5e8768f8F1754A24A6c661Fb8"
+  },
+  [baseSepolia.id]: {
+    warehouse: "0x8fb66F38cF86A3d5e8768f8F1754A24A6c661Fb8"
+  },
+  [hardhat.id]: {
+    warehouse: deployments["31337"].SplitsWarehouse.address,
+    nameWrapper: deployments["31337"].NameWrapper.address,
+    ensUniversalResolver: deployments["31337"].UniversalResolver.address
+  }
+};
+function getFactoryTenantMap(chainId) {
+  const map = /* @__PURE__ */ new Map();
+  for (const [tenantId, chainConfigs] of Object.entries(tenants)) {
+    const factory = chainConfigs[chainId]?.factory;
+    if (factory) map.set(factory.toLowerCase(), tenantId);
+  }
+  return map;
+}
+function getAllFactoryAddresses(chainId) {
+  return Object.values(tenants).map((chainConfigs) => chainConfigs[chainId]?.factory).filter((addr) => Boolean(addr));
+}
+function getTenantConfig(tenantId, chainId) {
+  return tenants[tenantId]?.[chainId];
+}
+function getEnsDomain(chainId, tenantId) {
+  if (tenantId) {
+    return tenants[tenantId]?.[chainId]?.ensDomain ?? "support-dev.eth";
+  }
+  const first = Object.values(tenants).find((c) => c[chainId]?.ensDomain);
+  return first?.[chainId]?.ensDomain ?? "support-dev.eth";
+}
+var ENS_DOMAIN = getEnsDomain(sepolia.id);
+
+// src/index.ts
+import deployments4 from "@curator-studio/contracts/deployments.json";
+
+// src/strategy.ts
+import {
+  getContract
+} from "viem";
+import "viem";
+
+// src/lib/tx.ts
+import { parseEventLogs } from "viem";
+import { waitForTransactionReceipt } from "viem/actions";
+async function writeAndParse(wallet, hash, abi, eventName) {
+  const receipt = await waitForTransactionReceipt(wallet, { hash });
+  const logs = parseEventLogs({ abi, logs: receipt.logs });
+  const event = logs.find((log) => log.eventName === eventName);
+  if (!event) {
+    throw new Error(`${eventName} event not found`);
+  }
+  return event.args;
+}
+async function writeAndWait(wallet, hash) {
+  await waitForTransactionReceipt(wallet, { hash });
+  return { hash };
+}
+
+// src/strategy.ts
+function createStrategyMethods(wallet, publicClient, deployments5, uploadMetadata) {
+  const resolveMetadataURI = (metadata) => {
+    if (!uploadMetadata) throw new Error("uploadMetadata is required to create strategies");
+    return uploadMetadata(metadata);
+  };
+  return {
+    /**
+     * Create a new strategy with optional ENS subdomain.
+     * Metadata is uploaded to the configured uploadUrl (defaults to inline data URI if not set).
+     */
+    create: async (config2) => {
+      if (!wallet) throw new Error("Wallet required");
+      const metadataURI = await resolveMetadataURI(config2.metadata);
+      const contract = getContract({
+        address: deployments5.StrategyFactory.address,
+        abi: deployments5.StrategyFactory.abi,
+        client: { public: publicClient, wallet }
+      });
+      const configTuple = {
+        owner: config2.owner,
+        sourceStrategy: config2.sourceStrategy,
+        allocations: config2.allocations.map((a) => ({
+          recipient: a.recipient,
+          weight: a.weight,
+          label: a.label ?? ""
+        })),
+        metadataURI
+      };
+      const hash = await contract.write.create(
+        [configTuple, config2.ensLabel],
+        {
+          account: wallet.account
+        }
+      );
+      return writeAndParse(
+        wallet,
+        hash,
+        deployments5.StrategyFactory.abi,
+        "StrategyCreated"
+      );
+    },
+    /**
+     * Get strategy data including owner, allocations, and metadata
+     * Note: Fee is the first allocation by convention
+     */
+    getData: async (strategyAddress) => {
+      const contract = getContract({
+        address: strategyAddress,
+        abi: deployments5.Strategy.abi,
+        client: { public: publicClient }
+      });
+      const [owner, sourceStrategy, allocations, totalWeight, metadataURI] = await Promise.all([
+        contract.read.owner(),
+        contract.read.sourceStrategy(),
+        contract.read.getAllocations(),
+        contract.read.totalWeight(),
+        contract.read.metadataURI()
+      ]);
+      return {
+        owner,
+        sourceStrategy,
+        allocations: allocations.map((a) => ({
+          recipient: a.recipient,
+          weight: BigInt(a.weight),
+          label: a.label || void 0
+        })),
+        totalWeight: BigInt(totalWeight),
+        metadataURI
+      };
+    },
+    /**
+     * Get the balance of a token held by the strategy
+     */
+    balanceOf: async (strategyAddress, token) => {
+      const contract = getContract({
+        address: strategyAddress,
+        abi: deployments5.Strategy.abi,
+        client: { public: publicClient }
+      });
+      return contract.read.balanceOf([token]);
+    },
+    /**
+     * Update the allocation configuration and metadata (owner only).
+     * Metadata is uploaded to the configured uploadUrl (defaults to inline data URI if not set).
+     */
+    rebalance: async (strategyAddress, allocations, metadata) => {
+      if (!wallet) throw new Error("Wallet required");
+      const metadataURI = await resolveMetadataURI(metadata);
+      const contract = getContract({
+        address: strategyAddress,
+        abi: deployments5.Strategy.abi,
+        client: { public: publicClient, wallet }
+      });
+      const allocationsTuple = allocations.map((a) => ({
+        recipient: a.recipient,
+        weight: a.weight,
+        label: a.label ?? ""
+      }));
+      const hash = await contract.write.rebalance(
+        [allocationsTuple, metadataURI],
+        {
+          account: wallet.account
+        }
+      );
+      return writeAndWait(wallet, hash);
+    },
+    /**
+     * Distribute the strategy's token balance to recipients according to allocations
+     */
+    distribute: async (strategyAddress, token) => {
+      if (!wallet) throw new Error("Wallet required");
+      const contract = getContract({
+        address: strategyAddress,
+        abi: deployments5.Strategy.abi,
+        client: { public: publicClient, wallet }
+      });
+      const hash = await contract.write.distribute([token], {
+        account: wallet.account
+      });
+      return writeAndWait(wallet, hash);
+    },
+    /**
+     * Set ENS subdomain name for an existing strategy
+     * @param strategyAddress The strategy address to set ENS name for
+     * @param label ENS subdomain label (e.g., "mystrategy")
+     * @dev Automatically handles two cases:
+     *   1. If factory doesn't own the name: registers it via ENS registrar
+     *   2. If factory owns the name: connects pre-registered name
+     */
+    setENSName: async (strategyAddress, label) => {
+      if (!wallet) throw new Error("Wallet required");
+      const contract = getContract({
+        address: deployments5.StrategyFactory.address,
+        abi: deployments5.StrategyFactory.abi,
+        client: { public: publicClient, wallet }
+      });
+      const hash = await contract.write.setENSName(
+        [strategyAddress, label],
+        {
+          account: wallet.account
+        }
+      );
+      return writeAndWait(wallet, hash);
+    }
+  };
+}
+
+// src/ens.ts
+import {
+  getContract as getContract2,
+  namehash
+} from "viem";
+function createENSMethods(wallet, publicClient, chainId, deployments5) {
+  const methods = {
+    /**
+     * Check if a subdomain label is available for registration
+     * Works on any network where ForeverSubnameRegistrar is deployed
+     */
+    available: async (label) => {
+      const registrarAddress = deployments5.ForeverSubnameRegistrar?.address;
+      if (!registrarAddress) {
+        throw new Error("ForeverSubnameRegistrar not deployed on this network");
+      }
+      const contract = getContract2({
+        address: registrarAddress,
+        abi: deployments5.ForeverSubnameRegistrar.abi,
+        client: { public: publicClient }
+      });
+      return contract.read.available([label]);
+    },
+    /**
+     * Register a subdomain via ForeverSubnameRegistrar
+     * Works on any network where ForeverSubnameRegistrar is deployed
+     */
+    register: async (label, owner) => {
+      if (!wallet) throw new Error("Wallet required");
+      const registrarAddress = deployments5.ForeverSubnameRegistrar?.address;
+      if (!registrarAddress) {
+        throw new Error("ForeverSubnameRegistrar not deployed on this network");
+      }
+      const to = owner ?? wallet.account?.address;
+      if (!to) throw new Error("Owner address required");
+      const contract = getContract2({
+        address: registrarAddress,
+        abi: deployments5.ForeverSubnameRegistrar.abi,
+        client: { public: publicClient, wallet }
+      });
+      const hash = await contract.write.register([label, to], {
+        account: wallet.account,
+        gas: 5000000n
+        // Explicit gas limit under Sepolia's 16.7M cap
+      });
+      return writeAndParse(
+        wallet,
+        hash,
+        deployments5.ForeverSubnameRegistrar.abi,
+        "NameRegistered"
+      );
+    },
+    /**
+     * Get the address record for an ENS name (forward resolution)
+     * @param name Full ENS name (e.g., "mystrategy.support.eth" - see ENS_DOMAIN config)
+     * @returns The resolved address or null if not set
+     */
+    getAddress: async (name) => {
+      try {
+        const node = namehash(name);
+        const contract = getContract2({
+          address: deployments5.PublicResolver.address,
+          abi: deployments5.PublicResolver.abi,
+          client: { public: publicClient }
+        });
+        const addr = await contract.read.addr([node]);
+        return addr === "0x0000000000000000000000000000000000000000" ? null : addr;
+      } catch {
+        return null;
+      }
+    },
+    /**
+     * Set the address record for an ENS name (forward resolution)
+     * @param name Full ENS name (e.g., "mystrategy.support.eth" - see ENS_DOMAIN config)
+     * @param address The address the name should resolve to
+     */
+    setAddress: async (name, address) => {
+      if (!wallet) throw new Error("Wallet required");
+      const node = namehash(name);
+      const contract = getContract2({
+        address: deployments5.PublicResolver.address,
+        abi: deployments5.PublicResolver.abi,
+        client: { public: publicClient, wallet }
+      });
+      const hash = await contract.write.setAddr([node, address], {
+        account: wallet.account,
+        gas: 2000000n
+        // Explicit gas limit under Sepolia's 16.7M cap
+      });
+      return writeAndWait(wallet, hash);
+    },
+    /**
+     * Set the reverse name record for the caller's address
+     * This allows resolving your wallet address back to an ENS name
+     * Note: You can only set reverse records for addresses you control
+     * @param name The full ENS name (e.g., "mystrategy.support.eth" - see ENS_DOMAIN config)
+     */
+    setReverseRecord: async (name) => {
+      if (!wallet) throw new Error("Wallet required");
+      const contract = getContract2({
+        address: deployments5.ReverseRegistrar.address,
+        abi: deployments5.ReverseRegistrar.abi,
+        client: { public: publicClient, wallet }
+      });
+      const hash = await contract.write.setName([name], {
+        account: wallet.account,
+        gas: 2000000n
+      });
+      return writeAndWait(wallet, hash);
+    },
+    /**
+     * Set the reverse name record for any address (requires authorization)
+     * This allows resolving an address back to its ENS name
+     * Note: Only works if you're authorized to set reverse records for the address
+     * @param addr The address to set the reverse record for
+     * @param name The full ENS name (e.g., "mystrategy.support.eth" - see ENS_DOMAIN config)
+     */
+    setReverseNameForAddr: async (addr, name) => {
+      if (!wallet) throw new Error("Wallet required");
+      const contract = getContract2({
+        address: deployments5.ReverseRegistrar.address,
+        abi: deployments5.ReverseRegistrar.abi,
+        client: { public: publicClient, wallet }
+      });
+      const hash = await contract.write.setNameForAddr(
+        [
+          addr,
+          wallet.account.address,
+          deployments5.PublicResolver.address,
+          name
+        ],
+        {
+          account: wallet.account,
+          gas: 2000000n
+          // Explicit gas limit under Sepolia's 16.7M cap
+        }
+      );
+      return writeAndWait(wallet, hash);
+    },
+    /**
+     * Register a subdomain and set up full address resolution
+     * 1. Registers the subdomain
+     * 2. Sets forward resolution (name -> address)
+     * @param label The subdomain label (e.g., "mystrategy" for "mystrategy.support.eth" - see ENS_DOMAIN config)
+     * @param resolveToAddress The address the name should resolve to
+     * @param owner Optional owner of the ENS name (defaults to wallet address)
+     */
+    registerWithAddress: async (label, resolveToAddress, owner) => {
+      const result = await methods.register(label, owner);
+      const fullName = `${label}.${ENS_DOMAIN}`;
+      await methods.setAddress(fullName, resolveToAddress);
+      return result;
+    }
+  };
+  return methods;
+}
+
+// src/warehouse.ts
+import {
+  getContract as getContract3
+} from "viem";
+function createWarehouseMethods(wallet, publicClient, chainId, deployments5) {
+  return {
+    /**
+     * Withdraw tokens from the SplitsWarehouse
+     * @param owner Address to withdraw for (usually msg.sender)
+     * @param token Token address to withdraw
+     */
+    withdraw: async (owner, token) => {
+      if (!wallet) throw new Error("Wallet required");
+      const warehouseAddress = config[chainId]?.warehouse;
+      if (!warehouseAddress)
+        throw new Error("SplitsWarehouse not deployed on this network");
+      const contract = getContract3({
+        address: warehouseAddress,
+        abi: deployments5.SplitsWarehouse.abi,
+        client: { public: publicClient, wallet }
+      });
+      const hash = await contract.write.withdraw([owner, token], {
+        account: wallet.account
+      });
+      return writeAndWait(wallet, hash);
+    },
+    /**
+     * Get warehouse balance for a user/token
+     * @param owner Address to check balance for
+     * @param token Token address
+     */
+    balanceOf: async (owner, token) => {
+      const warehouseAddress = config[chainId]?.warehouse;
+      if (!warehouseAddress)
+        throw new Error("SplitsWarehouse not deployed on this network");
+      const contract = getContract3({
+        address: warehouseAddress,
+        abi: deployments5.SplitsWarehouse.abi,
+        client: { public: publicClient }
+      });
+      const tokenId = BigInt(token);
+      return contract.read.balanceOf([owner, tokenId]);
+    }
+  };
+}
+
+// src/yield-redirector.ts
+import {
+  getContract as getContract4
+} from "viem";
+function createYieldRedirectorMethods(wallet, publicClient, deployments5) {
+  return {
+    /**
+     * Create a new yield redirector
+     * @param sourceVault ERC-4626 vault address that generates yield
+     * @param yieldRecipient Address to receive harvested yield (typically a Strategy)
+     * @param owner Address that can update yield recipient
+     */
+    create: async (sourceVault, yieldRecipient, owner) => {
+      if (!wallet) throw new Error("Wallet required");
+      const contract = getContract4({
+        address: deployments5.YieldRedirectorFactory.address,
+        abi: deployments5.YieldRedirectorFactory.abi,
+        client: { public: publicClient, wallet }
+      });
+      const hash = await contract.write.create(
+        [sourceVault, yieldRecipient, owner],
+        {
+          account: wallet.account
+        }
+      );
+      return writeAndParse(
+        wallet,
+        hash,
+        deployments5.YieldRedirectorFactory.abi,
+        "YieldRedirectorCreated"
+      );
+    },
+    /**
+     * Create a new yield redirector with deterministic address
+     * @param sourceVault ERC-4626 vault address that generates yield
+     * @param yieldRecipient Address to receive harvested yield (typically a Strategy)
+     * @param owner Address that can update yield recipient
+     * @param salt Bytes32 salt for deterministic address generation
+     */
+    createDeterministic: async (sourceVault, yieldRecipient, owner, salt) => {
+      if (!wallet) throw new Error("Wallet required");
+      const contract = getContract4({
+        address: deployments5.YieldRedirectorFactory.address,
+        abi: deployments5.YieldRedirectorFactory.abi,
+        client: { public: publicClient, wallet }
+      });
+      const hash = await contract.write.createDeterministic(
+        [sourceVault, yieldRecipient, owner, salt],
+        {
+          account: wallet.account
+        }
+      );
+      return writeAndParse(
+        wallet,
+        hash,
+        deployments5.YieldRedirectorFactory.abi,
+        "YieldRedirectorCreated"
+      );
+    },
+    /**
+     * Harvest yield from a redirector and send to recipient
+     * @param redirectorAddress The yield redirector contract address
+     */
+    harvest: async (redirectorAddress) => {
+      if (!wallet) throw new Error("Wallet required");
+      const contract = getContract4({
+        address: redirectorAddress,
+        abi: deployments5.YieldRedirector4626.abi,
+        client: { public: publicClient, wallet }
+      });
+      const hash = await contract.write.harvest([], {
+        account: wallet.account
+      });
+      return writeAndWait(wallet, hash);
+    },
+    /**
+     * Get the current surplus (harvestable yield) from a redirector
+     * @param redirectorAddress The yield redirector contract address
+     */
+    surplus: async (redirectorAddress) => {
+      const contract = getContract4({
+        address: redirectorAddress,
+        abi: deployments5.YieldRedirector4626.abi,
+        client: { public: publicClient }
+      });
+      return contract.read.surplus();
+    },
+    /**
+     * Get the principal deposited in a redirector
+     * @param redirectorAddress The yield redirector contract address
+     */
+    principal: async (redirectorAddress) => {
+      const contract = getContract4({
+        address: redirectorAddress,
+        abi: deployments5.YieldRedirector4626.abi,
+        client: { public: publicClient }
+      });
+      return contract.read.principal();
+    },
+    /**
+     * Get the total value in the source vault (principal + yield)
+     * @param redirectorAddress The yield redirector contract address
+     */
+    sourceVaultValue: async (redirectorAddress) => {
+      const contract = getContract4({
+        address: redirectorAddress,
+        abi: deployments5.YieldRedirector4626.abi,
+        client: { public: publicClient }
+      });
+      return contract.read.sourceVaultValue();
+    },
+    /**
+     * Update the yield recipient (owner only)
+     * @param redirectorAddress The yield redirector contract address
+     * @param newRecipient New address to receive harvested yield
+     */
+    setYieldRecipient: async (redirectorAddress, newRecipient) => {
+      if (!wallet) throw new Error("Wallet required");
+      const contract = getContract4({
+        address: redirectorAddress,
+        abi: deployments5.YieldRedirector4626.abi,
+        client: { public: publicClient, wallet }
+      });
+      const hash = await contract.write.setYieldRecipient(
+        [newRecipient],
+        {
+          account: wallet.account
+        }
+      );
+      return writeAndWait(wallet, hash);
+    }
+  };
+}
+
+// src/components/provider.tsx
+import {
+  createContext,
+  useContext,
+  useEffect,
+  useState
+} from "react";
+import { jsx } from "react/jsx-runtime";
+var CuratorContext = createContext({
+  sdk: null
+});
+function CuratorProvider({
+  children,
+  client,
+  defaultChain,
+  tenant,
+  indexerUrl,
+  uploadMetadata
+}) {
+  const [sdk, setSdk] = useState(() => {
+    return new CuratorSDK(client, { chain: defaultChain, tenant, indexerUrl, uploadMetadata });
+  });
+  useEffect(() => {
+    setSdk(new CuratorSDK(client, { chain: defaultChain, tenant, indexerUrl, uploadMetadata }));
+  }, [client, defaultChain, tenant, indexerUrl, uploadMetadata]);
+  return /* @__PURE__ */ jsx(CuratorContext.Provider, { value: { sdk }, children });
+}
+function useCuratorSDK() {
+  const context = useContext(CuratorContext);
+  if (!context) {
+    throw new Error("useCuratorSDK must be used within a CuratorProvider");
+  }
+  return context;
+}
+
+// src/hooks/utils.ts
+import { useQueryClient } from "@tanstack/react-query";
+var INVALIDATION_TIMEOUT_MS = 3e3;
+var ENS_INVALIDATION_TIMEOUT_MS = 1e3;
+function useInvalidate() {
+  const queryClient = useQueryClient();
+  return (queryKeys) => {
+    setTimeout(
+      () => queryKeys.map(
+        (queryKey) => queryClient.invalidateQueries({ queryKey })
+      ),
+      INVALIDATION_TIMEOUT_MS
+    );
+  };
+}
+function useInvalidateENS() {
+  const queryClient = useQueryClient();
+  return () => {
+    setTimeout(() => {
+      queryClient.invalidateQueries({ queryKey: ["ens"] });
+      queryClient.invalidateQueries({
+        predicate: (query) => {
+          const key = query.queryKey[0];
+          return typeof key === "string" && (key.startsWith("ens") || key === "ensName" || key === "ensAddress" || key === "ensAvatar");
+        }
+      });
+    }, ENS_INVALIDATION_TIMEOUT_MS);
+  };
+}
+
+// src/hooks/use-ens.ts
+import { useQuery } from "@tanstack/react-query";
+function useENSGetAddress(name, opts) {
+  const { sdk } = useCuratorSDK();
+  return useQuery({
+    queryKey: ["ens", "address", name],
+    queryFn: () => sdk?.ens.getAddress(name) ?? null,
+    enabled: Boolean(sdk) && Boolean(name) && (opts?.enabled ?? true),
+    refetchInterval: opts?.refetchInterval
+  });
+}
+function useENSAvailable(label, opts) {
+  const { sdk } = useCuratorSDK();
+  return useQuery({
+    queryKey: ["ens", "available", label],
+    queryFn: () => sdk?.ens.available(label) ?? null,
+    enabled: Boolean(sdk) && Boolean(label) && (opts?.enabled ?? true),
+    refetchInterval: opts?.refetchInterval
+  });
+}
+
+// src/hooks/use-strategy.ts
+import {
+  useMutation,
+  useQuery as useQuery2
+} from "@tanstack/react-query";
+import { toast } from "sonner";
+function useStrategyData(strategyAddress, opts) {
+  const { sdk } = useCuratorSDK();
+  return useQuery2({
+    queryKey: ["strategy", "data", strategyAddress],
+    queryFn: () => strategyAddress ? sdk?.strategy.getData(strategyAddress) ?? null : null,
+    enabled: Boolean(sdk) && Boolean(strategyAddress) && (opts?.enabled ?? true),
+    refetchInterval: opts?.refetchInterval
+  });
+}
+function useStrategyBalance(strategyAddress, token, opts) {
+  const { sdk } = useCuratorSDK();
+  return useQuery2({
+    queryKey: ["strategy", "balance", strategyAddress, token],
+    queryFn: () => strategyAddress && token ? sdk?.strategy.balanceOf(strategyAddress, token) ?? null : null,
+    enabled: Boolean(sdk) && Boolean(strategyAddress) && Boolean(token) && (opts?.enabled ?? true),
+    refetchInterval: opts?.refetchInterval
+  });
+}
+function useCreateStrategy(opts) {
+  const { sdk } = useCuratorSDK();
+  const invalidate = useInvalidate();
+  return useMutation({
+    mutationFn: async (config2) => {
+      if (!sdk) throw new Error("SDK not initialized");
+      return sdk.strategy.create(config2);
+    },
+    onSuccess: (data, ...args) => {
+      invalidate([
+        ["strategy"],
+        ["strategies"]
+        // Invalidate strategies list
+      ]);
+      opts?.onSuccess?.(data, ...args);
+    },
+    onError: (error, ...args) => {
+      toast.error(error.message || "Failed to create strategy");
+      opts?.onError?.(error, ...args);
+    },
+    ...opts
+  });
+}
+function useRebalanceStrategy(opts) {
+  const { sdk } = useCuratorSDK();
+  const invalidate = useInvalidate();
+  return useMutation({
+    mutationFn: async ({
+      strategyAddress,
+      allocations,
+      metadata
+    }) => {
+      if (!sdk) throw new Error("SDK not initialized");
+      return sdk.strategy.rebalance(strategyAddress, allocations, metadata);
+    },
+    onSuccess: (data, variables, ...args) => {
+      invalidate([
+        ["strategy", "data", variables.strategyAddress],
+        ["strategy", variables.strategyAddress],
+        // Invalidate indexer query
+        ["strategies"]
+        // Invalidate strategies list
+      ]);
+      opts?.onSuccess?.(data, variables, ...args);
+    },
+    onError: (error, ...args) => {
+      toast.error(error.message || "Failed to rebalance strategy");
+      opts?.onError?.(error, ...args);
+    },
+    ...opts
+  });
+}
+function useDistributeStrategy(opts) {
+  const { sdk } = useCuratorSDK();
+  const invalidate = useInvalidate();
+  return useMutation({
+    mutationFn: async ({
+      strategyAddress,
+      token
+    }) => {
+      if (!sdk) throw new Error("SDK not initialized");
+      return sdk.strategy.distribute(strategyAddress, token);
+    },
+    onSuccess: (data, variables, ...args) => {
+      toast.success("Distribution completed successfully");
+      invalidate([["strategy"]]);
+      invalidate([["strategyBalances"]]);
+      invalidate([["distributions"]]);
+      opts?.onSuccess?.(data, variables, ...args);
+    },
+    onError: (error, ...args) => {
+      toast.error(error.message || "Failed to distribute tokens");
+      opts?.onError?.(error, ...args);
+    },
+    ...opts
+  });
+}
+function useSetENSName(opts) {
+  const { sdk } = useCuratorSDK();
+  const invalidate = useInvalidate();
+  const invalidateENS = useInvalidateENS();
+  return useMutation({
+    mutationFn: async ({
+      strategyAddress,
+      label
+    }) => {
+      if (!sdk) throw new Error("SDK not initialized");
+      return sdk.strategy.setENSName(strategyAddress, label);
+    },
+    onSuccess: (data, variables, ...args) => {
+      toast.success("ENS name connected successfully");
+      invalidate([["strategy", variables.strategyAddress]]);
+      invalidateENS();
+      opts?.onSuccess?.(data, variables, ...args);
+    },
+    onError: (error, ...args) => {
+      toast.error(error.message || "Failed to connect ENS name");
+      opts?.onError?.(error, ...args);
+    },
+    ...opts
+  });
+}
+
+// src/hooks/use-warehouse.ts
+import {
+  useMutation as useMutation2,
+  useQuery as useQuery3,
+  useQueryClient as useQueryClient2
+} from "@tanstack/react-query";
+import { toast as toast2 } from "sonner";
+function useWarehouseBalances(variables = {}, opts) {
+  const { sdk } = useCuratorSDK();
+  return useQuery3({
+    queryKey: ["warehouseBalances", variables],
+    queryFn: () => sdk?.indexer?.warehouseBalance.query(variables) ?? null,
+    enabled: Boolean(sdk?.indexer) && (opts?.enabled ?? true),
+    refetchInterval: opts?.refetchInterval
+  });
+}
+function useWarehouseBalance(user, token, opts) {
+  const { sdk } = useCuratorSDK();
+  return useQuery3({
+    queryKey: ["warehouseBalance", user, token],
+    queryFn: async () => {
+      if (!user || !token) return null;
+      const result = await sdk?.indexer?.warehouseBalance.query({
+        where: { user: user.toLowerCase(), token: token.toLowerCase() },
+        limit: 1
+      });
+      return result?.items[0] ?? null;
+    },
+    enabled: Boolean(sdk?.indexer) && Boolean(user) && Boolean(token) && (opts?.enabled ?? true),
+    refetchInterval: opts?.refetchInterval
+  });
+}
+function useWithdrawFromWarehouse(opts) {
+  const { sdk } = useCuratorSDK();
+  const queryClient = useQueryClient2();
+  return useMutation2({
+    mutationFn: async ({
+      owner,
+      token
+    }) => {
+      if (!sdk) throw new Error("SDK not initialized");
+      return sdk.warehouse.withdraw(owner, token);
+    },
+    onSuccess: (data, variables, ...args) => {
+      toast2.success("Withdrawal successful");
+      queryClient.invalidateQueries({
+        queryKey: ["warehouseBalance", variables.owner, variables.token]
+      });
+      queryClient.invalidateQueries({
+        queryKey: ["warehouseBalances"]
+      });
+      opts?.onSuccess?.(data, variables, ...args);
+    },
+    onError: (error, ...args) => {
+      toast2.error(error.message || "Failed to withdraw tokens");
+      opts?.onError?.(error, ...args);
+    },
+    ...opts
+  });
+}
+
+// src/hooks/use-yield.ts
+import {
+  useMutation as useMutation3,
+  useQuery as useQuery4
+} from "@tanstack/react-query";
+import { toast as toast3 } from "sonner";
+function useYieldRedirectors(variables = {}, opts) {
+  const { sdk } = useCuratorSDK();
+  return useQuery4({
+    queryKey: ["yieldRedirectors", variables],
+    queryFn: () => sdk?.indexer?.yieldRedirector.query(variables) ?? null,
+    enabled: Boolean(sdk?.indexer) && (opts?.enabled ?? true),
+    refetchInterval: opts?.refetchInterval
+  });
+}
+function useYieldRedirectorById(id, opts) {
+  const { sdk } = useCuratorSDK();
+  return useQuery4({
+    queryKey: ["yieldRedirector", id],
+    queryFn: () => id ? sdk?.indexer?.yieldRedirector.get(id) ?? null : null,
+    enabled: Boolean(sdk?.indexer) && Boolean(id) && (opts?.enabled ?? true),
+    refetchInterval: opts?.refetchInterval
+  });
+}
+function useHarvests(variables = {}, opts) {
+  const { sdk } = useCuratorSDK();
+  return useQuery4({
+    queryKey: ["harvests", variables],
+    queryFn: () => sdk?.indexer?.harvest.query(variables) ?? null,
+    enabled: Boolean(sdk?.indexer) && (opts?.enabled ?? true),
+    refetchInterval: opts?.refetchInterval
+  });
+}
+function useCreateYieldRedirector(opts) {
+  const { sdk } = useCuratorSDK();
+  const invalidate = useInvalidate();
+  return useMutation3({
+    mutationFn: async (params) => {
+      if (!sdk) throw new Error("SDK not initialized");
+      return sdk.yieldRedirector.create(
+        params.sourceVault,
+        params.yieldRecipient,
+        params.owner
+      );
+    },
+    onSuccess: (data, variables, ...args) => {
+      toast3.success("Yield vault connected successfully");
+      invalidate([["yieldRedirectors"]]);
+      opts?.onSuccess?.(data, variables, ...args);
+    },
+    onError: (error, ...args) => {
+      toast3.error(error.message || "Failed to connect yield vault");
+      opts?.onError?.(error, ...args);
+    },
+    ...opts
+  });
+}
+function useHarvestYield(opts) {
+  const { sdk } = useCuratorSDK();
+  const invalidate = useInvalidate();
+  return useMutation3({
+    mutationFn: async (redirectorAddress) => {
+      if (!sdk) throw new Error("SDK not initialized");
+      return sdk.yieldRedirector.harvest(redirectorAddress);
+    },
+    onSuccess: (data, redirectorAddress) => {
+      toast3.success("Yield harvested successfully");
+      invalidate([["yieldRedirector", redirectorAddress]]);
+      invalidate([["yieldRedirectors"]]);
+      invalidate([["harvests"]]);
+    },
+    onError: (error, ...args) => {
+      toast3.error(error.message || "Failed to harvest yield");
+      opts?.onError?.(error, ...args);
+    },
+    ...opts
+  });
+}
+
+// src/hooks/use-indexer.ts
+import { useQuery as useQuery5 } from "@tanstack/react-query";
+function useStrategies(variables = {}, opts) {
+  const { sdk } = useCuratorSDK();
+  return useQuery5({
+    queryKey: ["strategies", variables],
+    queryFn: () => sdk?.indexer?.strategy.query(variables) ?? null,
+    enabled: Boolean(sdk?.indexer) && (opts?.enabled ?? true),
+    refetchInterval: opts?.refetchInterval
+  });
+}
+function useStrategyById(id, opts) {
+  const { sdk } = useCuratorSDK();
+  return useQuery5({
+    queryKey: ["strategy", id],
+    queryFn: () => sdk?.indexer?.strategy.get(id) ?? null,
+    enabled: Boolean(sdk?.indexer) && Boolean(id) && (opts?.enabled ?? true),
+    refetchInterval: opts?.refetchInterval
+  });
+}
+function useDistributions(variables = {}, opts) {
+  const { sdk } = useCuratorSDK();
+  return useQuery5({
+    queryKey: ["distributions", variables],
+    queryFn: () => sdk?.indexer?.distribution.query(variables) ?? null,
+    enabled: Boolean(sdk?.indexer) && (opts?.enabled ?? true),
+    refetchInterval: opts?.refetchInterval
+  });
+}
+function usePayouts(variables = {}, opts) {
+  const { sdk } = useCuratorSDK();
+  return useQuery5({
+    queryKey: ["payouts", variables],
+    queryFn: () => sdk?.indexer?.payout.query(variables) ?? null,
+    enabled: Boolean(sdk?.indexer) && (opts?.enabled ?? true),
+    refetchInterval: opts?.refetchInterval
+  });
+}
+function useDonors(variables = {}, opts) {
+  const { sdk } = useCuratorSDK();
+  return useQuery5({
+    queryKey: ["donors", variables],
+    queryFn: () => sdk?.indexer?.donor.query(variables) ?? null,
+    enabled: Boolean(sdk?.indexer) && (opts?.enabled ?? true),
+    refetchInterval: opts?.refetchInterval
+  });
+}
+function useStrategyBalances(variables = {}, opts) {
+  const { sdk } = useCuratorSDK();
+  return useQuery5({
+    queryKey: ["strategyBalances", variables],
+    queryFn: () => sdk?.indexer?.strategyBalance.query(variables) ?? null,
+    enabled: Boolean(sdk?.indexer) && (opts?.enabled ?? true),
+    refetchInterval: opts?.refetchInterval
+  });
+}
+function useForks(variables = {}, opts) {
+  const { sdk } = useCuratorSDK();
+  return useQuery5({
+    queryKey: ["forks", variables],
+    queryFn: () => sdk?.indexer?.fork.query(variables) ?? null,
+    enabled: Boolean(sdk?.indexer) && (opts?.enabled ?? true),
+    refetchInterval: opts?.refetchInterval
+  });
+}
+function useTrendingStrategies(options, opts) {
+  const { sdk } = useCuratorSDK();
+  return useQuery5({
+    queryKey: ["trending", options],
+    queryFn: () => sdk?.indexer?.trending(options) ?? null,
+    enabled: Boolean(sdk?.indexer) && (opts?.enabled ?? true),
+    refetchInterval: opts?.refetchInterval
+  });
+}
+function useProtocolStats(opts) {
+  const { sdk } = useCuratorSDK();
+  return useQuery5({
+    queryKey: ["stats"],
+    queryFn: () => sdk?.indexer?.stats() ?? null,
+    enabled: Boolean(sdk?.indexer) && (opts?.enabled ?? true),
+    refetchInterval: opts?.refetchInterval
+  });
+}
+function useStrategyLineage(strategyAddress, opts) {
+  const { sdk } = useCuratorSDK();
+  return useQuery5({
+    queryKey: ["lineage", strategyAddress],
+    queryFn: () => strategyAddress ? sdk?.indexer?.lineage(strategyAddress) ?? null : null,
+    enabled: Boolean(sdk?.indexer) && Boolean(strategyAddress) && (opts?.enabled ?? true),
+    refetchInterval: opts?.refetchInterval
+  });
+}
+
+// src/tokens.ts
+import { zeroAddress as zeroAddress2 } from "viem";
+import deployments2 from "@curator-studio/contracts/deployments.json";
+var NATIVE_TOKEN = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+var isNativeToken = (token = "") => {
+  return [zeroAddress2, NATIVE_TOKEN].map((t) => t.toLowerCase()).includes(token.toLowerCase());
+};
+var ETH_TOKEN = {
+  address: NATIVE_TOKEN,
+  symbol: "ETH",
+  name: "Ether",
+  decimals: 18
+};
+var MAINNET_TOKENS = {
+  ETH: ETH_TOKEN,
+  WETH: {
+    address: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+    symbol: "WETH",
+    name: "Wrapped Ether",
+    decimals: 18
+  },
+  USDC: {
+    address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    symbol: "USDC",
+    name: "USD Coin",
+    decimals: 6
+  },
+  USDT: {
+    address: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+    symbol: "USDT",
+    name: "Tether USD",
+    decimals: 6
+  },
+  DAI: {
+    address: "0x6B175474E89094C44Da98b954EedeAC8cB7A86Bf",
+    symbol: "DAI",
+    name: "Dai Stablecoin",
+    decimals: 18
+  }
+};
+var TOKEN_METADATA = {
+  TokenUSDC: { symbol: "USDC", name: "USD Coin", decimals: 6 },
+  TokenWETH: { symbol: "WETH", name: "Wrapped Ether", decimals: 18 },
+  TokenUSDT: { symbol: "USDT", name: "Tether USD", decimals: 6 },
+  TokenDAI: { symbol: "DAI", name: "Dai Stablecoin", decimals: 18 }
+};
+function getTestnetTokens(chainId) {
+  const d = deployments2[chainId];
+  if (!d) return {};
+  const tokens = {
+    ETH: ETH_TOKEN
+    // Always include native ETH
+  };
+  for (const [key, meta] of Object.entries(TOKEN_METADATA)) {
+    if (d[key]?.address) {
+      tokens[meta.symbol] = { ...meta, address: d[key].address };
+    }
+  }
+  return tokens;
+}
+var TOKEN_CONFIG = {
+  1: MAINNET_TOKENS,
+  11155111: getTestnetTokens("11155111"),
+  // Sepolia
+  31337: getTestnetTokens("31337")
+  // Local
+};
+function getTokens(chainId) {
+  return Object.values(TOKEN_CONFIG[chainId] ?? {});
+}
+function getToken(chainId, symbol) {
+  return TOKEN_CONFIG[chainId]?.[symbol];
+}
+function getTokenByAddress(chainId, address) {
+  return getTokens(chainId).find(
+    (t) => t.address.toLowerCase() === address.toLowerCase()
+  );
+}
+function getTokenAddresses(chainId) {
+  return getTokens(chainId).map((t) => t.address);
+}
+
+// src/vaults.ts
+import "viem";
+import deployments3 from "@curator-studio/contracts/deployments.json";
+var VAULT_METADATA = {
+  MockVaultUSDC: { name: "Mock USDC Vault", symbol: "mUSDC" },
+  MockVaultDAI: { name: "Mock DAI Vault", symbol: "mDAI" }
+};
+function getTestnetVaults(chainId) {
+  const d = deployments3[chainId];
+  if (!d) return {};
+  const vaults = {};
+  for (const [key, meta] of Object.entries(VAULT_METADATA)) {
+    if (d[key]?.address) {
+      const tokenKey = key.replace("MockVault", "Token");
+      const assetAddress = d[tokenKey]?.address;
+      if (assetAddress) {
+        vaults[key] = {
+          ...meta,
+          address: d[key].address,
+          asset: assetAddress
+        };
+      }
+    }
+  }
+  return vaults;
+}
+var VAULT_CONFIG = {
+  1: {},
+  // Mainnet - no mock vaults
+  11155111: getTestnetVaults("11155111"),
+  // Sepolia
+  31337: getTestnetVaults("31337")
+  // Local
+};
+function getVaults(chainId) {
+  return Object.values(VAULT_CONFIG[chainId] ?? {});
+}
+function getVaultByAddress(chainId, address) {
+  return getVaults(chainId).find(
+    (v) => v.address.toLowerCase() === address.toLowerCase()
+  );
+}
+function getVaultAddresses(chainId) {
+  return getVaults(chainId).map((v) => v.address);
+}
+
+// src/index.ts
+function createUploadFn(url, token) {
+  return async (metadata) => {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${token}`
+      },
+      body: JSON.stringify(metadata)
+    });
+    if (!res.ok) throw new Error(`Upload failed: ${res.statusText}`);
+    const { url: blobUrl } = await res.json();
+    return blobUrl;
+  };
+}
+function getDeployments(chainId) {
+  const d = deployments4[chainId.toString()];
+  if (!d) throw new Error(`No deployments found for chain ${chainId}. Run the relevant deploy script first.`);
+  return d;
+}
+function getChain(chainId) {
+  switch (chainId) {
+    case 1:
+      return mainnet2;
+    case 11155111:
+      return sepolia2;
+    case 84532:
+      return baseSepolia2;
+    case 31337:
+      return hardhat2;
+    default:
+      return hardhat2;
+  }
+}
+var CuratorSDK = class {
+  #wallet;
+  #public;
+  #chainId;
+  #deployments;
+  #indexer;
+  #tenant;
+  #uploadMetadata;
+  ens;
+  strategy;
+  warehouse;
+  yieldRedirector;
+  constructor(wallet, options) {
+    const opts = typeof options === "number" ? { chain: options } : options ?? {};
+    const chainId = wallet?.chain?.id ?? opts.chain ?? 31337;
+    const chain = getChain(chainId);
+    const chainConfig = config[chainId];
+    const chainWithEns = chainConfig?.ensUniversalResolver ? {
+      ...chain,
+      contracts: {
+        ...chain.contracts,
+        ensUniversalResolver: { address: chainConfig.ensUniversalResolver }
+      }
+    } : chain;
+    const indexerUrl = opts.indexerUrl ?? "";
+    this.#wallet = wallet;
+    this.#chainId = chainId;
+    this.#tenant = opts.tenant;
+    this.#uploadMetadata = opts.uploadMetadata;
+    this.#indexer = createIndexer(indexerUrl, opts.tenant);
+    this.#public = createPublicClient({ chain: chainWithEns, transport: http() });
+    this.#deployments = getDeployments(chainId);
+    const tenantCfg = opts.tenant ? getTenantConfig(opts.tenant, chainId) : void 0;
+    const deploymentOverrides = tenantCfg ? {
+      ...this.#deployments,
+      ...tenantCfg.factory && {
+        StrategyFactory: { ...this.#deployments.StrategyFactory, address: tenantCfg.factory }
+      },
+      ...tenantCfg.foreverSubnameRegistrar && {
+        ForeverSubnameRegistrar: {
+          ...this.#deployments.ForeverSubnameRegistrar,
+          address: tenantCfg.foreverSubnameRegistrar
+        }
+      }
+    } : this.#deployments;
+    this.ens = createENSMethods(wallet, this.#public, chainId, deploymentOverrides);
+    this.strategy = createStrategyMethods(wallet, this.#public, deploymentOverrides, this.#uploadMetadata);
+    this.warehouse = createWarehouseMethods(wallet, this.#public, chainId, deploymentOverrides);
+    this.yieldRedirector = createYieldRedirectorMethods(wallet, this.#public, deploymentOverrides);
+  }
+  get wallet() {
+    return this.#wallet;
+  }
+  get publicClient() {
+    return this.#public;
+  }
+  get chainId() {
+    return this.#chainId;
+  }
+  get tenant() {
+    return this.#tenant;
+  }
+  get indexer() {
+    return this.#indexer;
+  }
+};
+export {
+  CuratorProvider,
+  CuratorSDK,
+  ENS_DOMAIN,
+  ENS_INVALIDATION_TIMEOUT_MS,
+  ETH_TOKEN,
+  INVALIDATION_TIMEOUT_MS,
+  NATIVE_TOKEN,
+  config,
+  createIndexer,
+  createUploadFn,
+  getAllFactoryAddresses,
+  getFactoryTenantMap,
+  getTenantConfig,
+  getToken,
+  getTokenAddresses,
+  getTokenByAddress,
+  getTokens,
+  getVaultAddresses,
+  getVaultByAddress,
+  getVaults,
+  isNativeToken,
+  tenants,
+  useCreateStrategy,
+  useCreateYieldRedirector,
+  useCuratorSDK,
+  useDistributeStrategy,
+  useDistributions,
+  useDonors,
+  useENSAvailable,
+  useENSGetAddress,
+  useForks,
+  useHarvestYield,
+  useHarvests,
+  useInvalidate,
+  useInvalidateENS,
+  usePayouts,
+  useProtocolStats,
+  useRebalanceStrategy,
+  useSetENSName,
+  useStrategies,
+  useStrategyBalance,
+  useStrategyBalances,
+  useStrategyById,
+  useStrategyData,
+  useStrategyLineage,
+  useTrendingStrategies,
+  useWarehouseBalance,
+  useWarehouseBalances,
+  useWithdrawFromWarehouse,
+  useYieldRedirectorById,
+  useYieldRedirectors,
+  writeAndParse,
+  writeAndWait
+};