@curator-studio/sdk 0.1.0

package/dist/chunk-XGB3TDIC.mjs

@@ -0,0 +1,42 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __require,
+  __commonJS,
+  __export,
+  __toESM
+};

package/dist/components/provider.d.ts

@@ -0,0 +1,14 @@
+import { type PropsWithChildren } from "react";
+import { CuratorSDK, type SupportedChainId } from "..";
+import type { WalletClient } from "viem";
+type CuratorProviderProps<T extends CuratorSDK> = PropsWithChildren<{
+    client?: WalletClient;
+    defaultChain?: SupportedChainId;
+    /** Tenant ENS name (e.g. "support.eth"). Scopes the SDK to this tenant's factory. */
+    tenant?: string;
+}>;
+export declare function CuratorProvider<T extends CuratorSDK = CuratorSDK>({ children, client, defaultChain, tenant, }: CuratorProviderProps<T>): React.ReactNode;
+export declare function useCuratorSDK<T extends CuratorSDK = CuratorSDK>(): {
+    sdk: T | null;
+};
+export {};

package/dist/config.d.ts

@@ -0,0 +1,39 @@
+export type SupportedChainId = 1 | 11155111 | 84532 | 31337;
+export type ChainConfig = {
+    warehouse?: `0x${string}`;
+    indexer?: string;
+    nameWrapper?: `0x${string}`;
+    ensUniversalResolver?: `0x${string}`;
+};
+/**
+ * Per-tenant, per-chain configuration.
+ * Each tenant deploys its own StrategyFactory under its own ENS domain.
+ */
+export type TenantConfig = {
+    ensDomain: string;
+    factory?: `0x${string}`;
+    startBlock?: number;
+    foreverSubnameRegistrar?: `0x${string}`;
+};
+/**
+ * All tenants across all chains.
+ * Add a new entry here when a new tenant deploys their StrategyFactory.
+ */
+export declare const tenants: Record<string, Partial<Record<SupportedChainId, TenantConfig>>>;
+export declare const config: Record<SupportedChainId, ChainConfig>;
+/**
+ * Returns a map of factory address (lowercase) → tenant ID for a given chain.
+ * Used by the indexer to derive tenantId from factory address on each event.
+ */
+export declare function getFactoryTenantMap(chainId: SupportedChainId): Map<string, string>;
+/**
+ * Returns all tenant factory addresses for a given chain.
+ * Used by ponder.config.ts to watch all tenant factories.
+ */
+export declare function getAllFactoryAddresses(chainId: SupportedChainId): `0x${string}`[];
+/**
+ * Returns the tenant config for a given tenant and chain.
+ */
+export declare function getTenantConfig(tenantId: string, chainId: SupportedChainId): TenantConfig | undefined;
+export declare function getEnsDomain(chainId: SupportedChainId, tenantId?: string): string;
+export declare const ENS_DOMAIN: string;

package/dist/ens.d.ts

@@ -0,0 +1,82 @@
+import { type Address, type WalletClient, type PublicClient } from "viem";
+import { type SupportedChainId } from "./config";
+export type ENSNameData = {
+    owner: Address;
+    expiry: bigint;
+};
+type ChainDeployments = {
+    ForeverSubnameRegistrar: {
+        abi: unknown;
+    };
+    PublicResolver: {
+        abi: unknown;
+        address: string;
+    };
+    ReverseRegistrar: {
+        abi: unknown;
+        address: string;
+    };
+};
+export declare function createENSMethods(wallet: WalletClient | undefined, publicClient: PublicClient, chainId: SupportedChainId, deployments: ChainDeployments): {
+    /**
+     * Check if a subdomain label is available for registration
+     * Works on any network where ForeverSubnameRegistrar is deployed
+     */
+    available: (label: string) => Promise<boolean>;
+    /**
+     * Register a subdomain via ForeverSubnameRegistrar
+     * Works on any network where ForeverSubnameRegistrar is deployed
+     */
+    register: (label: string, owner?: Address) => Promise<{
+        label: string;
+        owner: Address;
+        node: `0x${string}`;
+    }>;
+    /**
+     * 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: (name: string) => Promise<Address | 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: (name: string, address: Address) => Promise<{
+        hash: `0x${string}`;
+    }>;
+    /**
+     * 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: (name: string) => Promise<{
+        hash: `0x${string}`;
+    }>;
+    /**
+     * 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: (addr: Address, name: string) => Promise<{
+        hash: `0x${string}`;
+    }>;
+    /**
+     * 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: (label: string, resolveToAddress: Address, owner?: Address) => Promise<{
+        label: string;
+        owner: Address;
+        node: `0x${string}`;
+    }>;
+};
+export {};

package/dist/hooks/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./utils";
+export * from "./use-ens";
+export * from "./use-strategy";
+export * from "./use-warehouse";
+export * from "./use-yield";
+export * from "./use-indexer";

package/dist/hooks/use-ens.d.ts

@@ -0,0 +1,17 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Address } from "viem";
+type QueryOptions = {
+    enabled?: boolean;
+    refetchInterval?: number;
+};
+/**
+ * Resolve an ENS name to an address (forward resolution)
+ * Uses the SDK's configured public client with local ENS support
+ */
+export declare function useENSGetAddress(name: string, opts?: QueryOptions): UseQueryResult<Address | null>;
+/**
+ * Check if a subdomain label is available for registration
+ * Works on any network where ForeverSubnameRegistrar is deployed
+ */
+export declare function useENSAvailable(label: string, opts?: QueryOptions): UseQueryResult<boolean | null>;
+export {};

package/dist/hooks/use-indexer.d.ts

@@ -0,0 +1,21 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import type { Address } from "viem";
+import type { Strategy, Distribution, Payout, Donor, StrategyBalance, Fork, Page, QueryVariables, StrategyFilter, DistributionFilter, PayoutFilter, DonorFilter, StrategyBalanceFilter, ForkFilter, TrendingResponse, ProtocolStats, StrategyLineage } from "../lib/indexer";
+type QueryOptions = {
+    enabled?: boolean;
+    refetchInterval?: number;
+};
+export declare function useStrategies(variables?: QueryVariables<StrategyFilter>, opts?: QueryOptions): UseQueryResult<Page<Strategy> | null>;
+export declare function useStrategyById(id: Address, opts?: QueryOptions): UseQueryResult<Strategy | null>;
+export declare function useDistributions(variables?: QueryVariables<DistributionFilter>, opts?: QueryOptions): UseQueryResult<Page<Distribution> | null>;
+export declare function usePayouts(variables?: QueryVariables<PayoutFilter>, opts?: QueryOptions): UseQueryResult<Page<Payout> | null>;
+export declare function useDonors(variables?: QueryVariables<DonorFilter>, opts?: QueryOptions): UseQueryResult<Page<Donor> | null>;
+export declare function useStrategyBalances(variables?: QueryVariables<StrategyBalanceFilter>, opts?: QueryOptions): UseQueryResult<Page<StrategyBalance> | null>;
+export declare function useForks(variables?: QueryVariables<ForkFilter>, opts?: QueryOptions): UseQueryResult<Page<Fork> | null>;
+export declare function useTrendingStrategies(options?: {
+    period?: "24h" | "7d";
+    limit?: number;
+}, opts?: QueryOptions): UseQueryResult<TrendingResponse | null>;
+export declare function useProtocolStats(opts?: QueryOptions): UseQueryResult<ProtocolStats | null>;
+export declare function useStrategyLineage(strategyAddress: Address | undefined, opts?: QueryOptions): UseQueryResult<StrategyLineage | null>;
+export {};

package/dist/hooks/use-strategy.d.ts

@@ -0,0 +1,55 @@
+import { type UseMutationOptions, type UseQueryResult } from "@tanstack/react-query";
+import type { Address } from "viem";
+import type { Allocation, StrategyConfig, StrategyData } from "../strategy";
+type QueryOptions = {
+    enabled?: boolean;
+    refetchInterval?: number;
+};
+export declare function useStrategyData(strategyAddress: Address | undefined, opts?: QueryOptions): UseQueryResult<StrategyData | null>;
+export declare function useStrategyBalance(strategyAddress: Address | undefined, token: Address | undefined, opts?: QueryOptions): UseQueryResult<bigint | null>;
+export declare function useCreateStrategy(opts?: UseMutationOptions<{
+    strategy: Address;
+    config: StrategyConfig;
+}, Error, StrategyConfig>): import("@tanstack/react-query").UseMutationResult<{
+    strategy: Address;
+    config: StrategyConfig;
+}, Error, StrategyConfig, unknown>;
+export declare function useRebalanceStrategy(opts?: UseMutationOptions<{
+    hash: `0x${string}`;
+}, Error, {
+    strategyAddress: Address;
+    allocations: Allocation[];
+    metadataURI: string;
+}>): import("@tanstack/react-query").UseMutationResult<{
+    hash: `0x${string}`;
+}, Error, {
+    strategyAddress: Address;
+    allocations: Allocation[];
+    metadataURI: string;
+}, unknown>;
+export declare function useDistributeStrategy(opts?: UseMutationOptions<{
+    hash: `0x${string}`;
+}, Error, {
+    strategyAddress: Address;
+    token: Address;
+}>): import("@tanstack/react-query").UseMutationResult<{
+    hash: `0x${string}`;
+}, Error, {
+    strategyAddress: Address;
+    token: Address;
+}, unknown>;
+/**
+ * Set ENS subdomain name for an existing strategy
+ */
+export declare function useSetENSName(opts?: UseMutationOptions<{
+    hash: `0x${string}`;
+}, Error, {
+    strategyAddress: Address;
+    label: string;
+}>): import("@tanstack/react-query").UseMutationResult<{
+    hash: `0x${string}`;
+}, Error, {
+    strategyAddress: Address;
+    label: string;
+}, unknown>;
+export {};

package/dist/hooks/use-warehouse.d.ts

@@ -0,0 +1,21 @@
+import { type UseMutationOptions, type UseQueryResult } from "@tanstack/react-query";
+import type { Address } from "viem";
+import type { WarehouseBalance, Page, QueryVariables, WarehouseBalanceFilter } from "../lib/indexer";
+type QueryOptions = {
+    enabled?: boolean;
+    refetchInterval?: number;
+};
+export declare function useWarehouseBalances(variables?: QueryVariables<WarehouseBalanceFilter>, opts?: QueryOptions): UseQueryResult<Page<WarehouseBalance> | null>;
+export declare function useWarehouseBalance(user: Address | undefined, token: Address | undefined, opts?: QueryOptions): UseQueryResult<WarehouseBalance | null>;
+export declare function useWithdrawFromWarehouse(opts?: UseMutationOptions<{
+    hash: `0x${string}`;
+}, Error, {
+    owner: Address;
+    token: Address;
+}>): import("@tanstack/react-query").UseMutationResult<{
+    hash: `0x${string}`;
+}, Error, {
+    owner: Address;
+    token: Address;
+}, unknown>;
+export {};

package/dist/hooks/use-yield.d.ts

@@ -0,0 +1,35 @@
+import { type UseMutationOptions, type UseQueryResult } from "@tanstack/react-query";
+import type { Address } from "viem";
+import type { YieldRedirector, Harvest, Page, QueryVariables, YieldRedirectorFilter, HarvestFilter } from "../lib/indexer";
+type QueryOptions = {
+    enabled?: boolean;
+    refetchInterval?: number;
+};
+export declare function useYieldRedirectors(variables?: QueryVariables<YieldRedirectorFilter>, opts?: QueryOptions): UseQueryResult<Page<YieldRedirector> | null>;
+export declare function useYieldRedirectorById(id: Address | undefined, opts?: QueryOptions): UseQueryResult<YieldRedirector | null>;
+export declare function useHarvests(variables?: QueryVariables<HarvestFilter>, opts?: QueryOptions): UseQueryResult<Page<Harvest> | null>;
+/**
+ * Create a new yield redirector
+ */
+export declare function useCreateYieldRedirector(opts?: UseMutationOptions<{
+    redirector: Address;
+}, Error, {
+    sourceVault: Address;
+    yieldRecipient: Address;
+    owner: Address;
+}>): import("@tanstack/react-query").UseMutationResult<{
+    redirector: Address;
+}, Error, {
+    sourceVault: Address;
+    yieldRecipient: Address;
+    owner: Address;
+}, unknown>;
+/**
+ * Harvest yield from a redirector
+ */
+export declare function useHarvestYield(opts?: UseMutationOptions<{
+    hash: `0x${string}`;
+}, Error, Address>): import("@tanstack/react-query").UseMutationResult<{
+    hash: `0x${string}`;
+}, Error, `0x${string}`, unknown>;
+export {};

package/dist/hooks/utils.d.ts

@@ -0,0 +1,7 @@
+export declare const INVALIDATION_TIMEOUT_MS = 3000;
+export declare const ENS_INVALIDATION_TIMEOUT_MS = 1000;
+export declare function useInvalidate(): (queryKeys: unknown[][]) => void;
+/**
+ * Invalidate all ENS-related queries (both custom and wagmi's)
+ */
+export declare function useInvalidateENS(): () => void;