@curator-studio/sdk 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,846 @@
+import { Address, WalletClient, PublicClient, Abi } from 'viem';
+import { Client, gql } from '@urql/core';
+import { PropsWithChildren } from 'react';
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { UseQueryResult, UseMutationOptions } from '@tanstack/react-query';
+
+type Allocation$1 = {
+    recipient: Address;
+    weight: string;
+    label?: string;
+};
+type Strategy = {
+    id: Address;
+    chainId: number;
+    tenantId: string | null;
+    owner: Address;
+    sourceStrategy: Address | null;
+    metadataURI: string | null;
+    feeRecipient: Address | null;
+    feeBps: number;
+    ensLabel: string | null;
+    metadata: {
+        title: string;
+        description: string;
+        image?: string;
+    };
+    allocations: Allocation$1[];
+    allocationsVersion: number;
+    timesForked: number;
+    uniqueDonors: number;
+    createdAt: bigint;
+    createdAtBlock: bigint;
+    lastUpdatedAt: bigint;
+    lastUpdatedAtBlock: bigint;
+};
+type Distribution = {
+    id: string;
+    strategyId: Address;
+    token: Address;
+    totalAmount: string;
+    totalAmountUSD: string;
+    allocationsVersion: number;
+    allocations: Allocation$1[];
+    timestamp: bigint;
+    blockNumber: bigint;
+    txHash: Address;
+};
+type Payout = {
+    id: string;
+    strategyId: Address;
+    distributionId: string;
+    recipient: Address;
+    token: Address;
+    amount: string;
+    amountUSD: string;
+    timestamp: bigint;
+    blockNumber: bigint;
+    txHash: Address;
+};
+type Transfer = {
+    id: string;
+    strategyId: Address;
+    token: Address;
+    from: Address;
+    to: Address;
+    amount: string;
+    amountUSD: string;
+    direction: "in" | "out";
+    timestamp: bigint;
+    blockNumber: bigint;
+    txHash: Address;
+};
+type Donor = {
+    id: string;
+    strategyId: Address;
+    address: Address;
+    firstDonationAt: bigint;
+    lastDonationAt: bigint;
+    totalDonations: number;
+};
+type StrategyBalance = {
+    id: string;
+    strategyId: Address;
+    token: Address;
+    balance: string;
+    totalReceived: string;
+    totalDistributed: string;
+    totalReceivedUSD: string;
+    totalDistributedUSD: string;
+    lastUpdatedAt: bigint;
+};
+type Fork = {
+    id: string;
+    sourceStrategyId: Address;
+    childStrategyId: Address;
+    createdAt: bigint;
+};
+type WarehouseBalance = {
+    id: string;
+    user: Address;
+    token: Address;
+    balance: string;
+    totalEarned: string;
+    totalClaimed: string;
+    totalEarnedUSD: string;
+    lastUpdatedAt: bigint;
+};
+type YieldRedirector = {
+    id: Address;
+    owner: Address;
+    sourceVault: Address;
+    yieldRecipient: Address;
+    asset: Address;
+    name: string | null;
+    symbol: string | null;
+    principal: string;
+    totalHarvested: string;
+    totalHarvestedUSD: string;
+    harvestCount: number;
+    lastHarvestAt: bigint | null;
+    createdAt: bigint;
+    createdAtBlock: bigint;
+};
+type Harvest = {
+    id: string;
+    redirectorId: Address;
+    amount: string;
+    amountUSD: string;
+    recipient: Address;
+    timestamp: bigint;
+    blockNumber: bigint;
+    txHash: Address;
+};
+type Page<T> = {
+    items: T[];
+    totalCount: number;
+    pageInfo: {
+        hasNextPage: boolean;
+        endCursor?: string;
+    };
+};
+type StrategyFilter = {
+    id?: string;
+    id_in?: string[];
+    tenantId?: string;
+    tenantId_in?: string[];
+    owner?: string;
+    owner_in?: string[];
+    sourceStrategy?: string;
+    sourceStrategy_in?: string[];
+};
+type DistributionFilter = {
+    strategyId?: string;
+    strategyId_in?: string[];
+    token?: string;
+    token_in?: string[];
+};
+type PayoutFilter = {
+    strategyId?: string;
+    strategyId_in?: string[];
+    distributionId?: string;
+    recipient?: string;
+    recipient_in?: string[];
+    token?: string;
+};
+type TransferFilter = {
+    strategyId?: string;
+    strategyId_in?: string[];
+    token?: string;
+    from?: string;
+    to?: string;
+    direction?: "in" | "out";
+};
+type DonorFilter = {
+    strategyId?: string;
+    strategyId_in?: string[];
+    address?: string;
+    address_in?: string[];
+};
+type StrategyBalanceFilter = {
+    strategyId?: string;
+    strategyId_in?: string[];
+    token?: string;
+    token_in?: string[];
+};
+type ForkFilter = {
+    sourceStrategyId?: string;
+    sourceStrategyId_in?: string[];
+    childStrategyId?: string;
+    childStrategyId_in?: string[];
+};
+type WarehouseBalanceFilter = {
+    user?: string;
+    user_in?: string[];
+    token?: string;
+    token_in?: string[];
+};
+type YieldRedirectorFilter = {
+    id?: string;
+    id_in?: string[];
+    owner?: string;
+    owner_in?: string[];
+    sourceVault?: string;
+    yieldRecipient?: string;
+    yieldRecipient_in?: string[];
+};
+type HarvestFilter = {
+    redirectorId?: string;
+    redirectorId_in?: string[];
+    recipient?: string;
+    recipient_in?: string[];
+};
+type QueryVariables<TFilter> = {
+    where?: TFilter;
+    orderBy?: string;
+    orderDirection?: "asc" | "desc";
+    limit?: number;
+    after?: string;
+};
+type TrendingStrategy = Strategy & {
+    trendingStats: {
+        transferCount: number;
+        totalAmount: string;
+    };
+};
+type TrendingResponse = {
+    data: TrendingStrategy[];
+    period: "24h" | "7d";
+};
+type TokenTotals = {
+    token: Address;
+    totalReceived: string;
+    totalDistributed: string;
+};
+type ProtocolStats = {
+    totalStrategies: number;
+    totalCurators: number;
+    totalDonors: number;
+    totalDistributions: number;
+    totalAllocatedUSD: string;
+    totalsByToken: TokenTotals[];
+};
+type StatsResponse = {
+    data: ProtocolStats;
+};
+type StrategyLineage = {
+    strategy: Address;
+    sourceStrategy: Address | null;
+    ancestors: Address[];
+    children: Address[];
+    depth: number;
+};
+type LineageResponse = {
+    data: StrategyLineage;
+};
+type IndexerBase = {
+    client: Client;
+    gql: typeof gql;
+    baseUrl: string;
+    strategy: {
+        get: (id: Address) => Promise<Strategy | null>;
+        query: (variables?: QueryVariables<StrategyFilter>) => Promise<Page<Strategy> | null>;
+    };
+    distribution: {
+        query: (variables?: QueryVariables<DistributionFilter>) => Promise<Page<Distribution> | null>;
+    };
+    payout: {
+        query: (variables?: QueryVariables<PayoutFilter>) => Promise<Page<Payout> | null>;
+    };
+    donor: {
+        query: (variables?: QueryVariables<DonorFilter>) => Promise<Page<Donor> | null>;
+    };
+    strategyBalance: {
+        query: (variables?: QueryVariables<StrategyBalanceFilter>) => Promise<Page<StrategyBalance> | null>;
+    };
+    fork: {
+        query: (variables?: QueryVariables<ForkFilter>) => Promise<Page<Fork> | null>;
+    };
+    warehouseBalance: {
+        query: (variables?: QueryVariables<WarehouseBalanceFilter>) => Promise<Page<WarehouseBalance> | null>;
+    };
+    yieldRedirector: {
+        get: (id: Address) => Promise<YieldRedirector | null>;
+        query: (variables?: QueryVariables<YieldRedirectorFilter>) => Promise<Page<YieldRedirector> | null>;
+    };
+    harvest: {
+        query: (variables?: QueryVariables<HarvestFilter>) => Promise<Page<Harvest> | null>;
+    };
+    trending: (options?: {
+        period?: "24h" | "7d";
+        limit?: number;
+    }) => Promise<TrendingResponse>;
+    stats: () => Promise<ProtocolStats>;
+    lineage: (strategyAddress: Address) => Promise<StrategyLineage | null>;
+};
+type Indexer = IndexerBase & {
+    extend<T>(extension: IndexerExtension<T>): Indexer & T;
+};
+type IndexerExtension<T> = (indexer: Indexer) => T;
+declare function createIndexer(url: string, tenant?: string): Indexer;
+
+type SupportedChainId = 1 | 11155111 | 84532 | 31337;
+type ChainConfig = {
+    warehouse?: `0x${string}`;
+    nameWrapper?: `0x${string}`;
+    ensUniversalResolver?: `0x${string}`;
+};
+/**
+ * Per-tenant, per-chain configuration.
+ * Each tenant deploys its own StrategyFactory under its own ENS domain.
+ */
+type TenantConfig = {
+    ensDomain: string;
+    factory?: `0x${string}`;
+    startBlock?: number;
+    foreverSubnameRegistrar?: `0x${string}`;
+};
+/**
+ * All tenants across all chains.
+ * Auto-populated from deployments.json tenants section + legacy flat StrategyFactory fallback.
+ */
+declare const tenants: Record<string, Partial<Record<SupportedChainId, TenantConfig>>>;
+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.
+ */
+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.
+ */
+declare function getAllFactoryAddresses(chainId: SupportedChainId): `0x${string}`[];
+/**
+ * Returns the tenant config for a given tenant and chain.
+ */
+declare function getTenantConfig(tenantId: string, chainId: SupportedChainId): TenantConfig | undefined;
+declare const ENS_DOMAIN: string;
+
+type Allocation = {
+    recipient: Address;
+    weight: bigint;
+    label?: string;
+};
+type StrategyMetadata = {
+    title: string;
+    description?: string;
+    image?: string;
+};
+/**
+ * Strategy configuration for creation
+ * Note: Fee is handled as the first allocation by convention
+ */
+type StrategyConfig = {
+    owner: Address;
+    sourceStrategy: Address;
+    allocations: Allocation[];
+    metadata: StrategyMetadata;
+    ensLabel: string;
+};
+/**
+ * Strategy data returned from contract
+ * Note: Fee is calculated from first allocation
+ */
+type StrategyData = {
+    owner: Address;
+    sourceStrategy: Address;
+    allocations: Allocation[];
+    totalWeight: bigint;
+    metadataURI: string;
+};
+type ChainDeployments$3 = {
+    Strategy: {
+        abi: unknown;
+    };
+    StrategyFactory: {
+        abi: unknown;
+        address: string;
+    };
+};
+type UploadMetadataFn = (metadata: StrategyMetadata) => Promise<string>;
+declare function createStrategyMethods(wallet: WalletClient | undefined, publicClient: PublicClient, deployments: ChainDeployments$3, uploadMetadata: UploadMetadataFn | undefined): {
+    /**
+     * Create a new strategy with optional ENS subdomain.
+     * Metadata is uploaded to the configured uploadUrl (defaults to inline data URI if not set).
+     */
+    create: (config: StrategyConfig) => Promise<{
+        strategy: Address;
+        config: StrategyConfig;
+    }>;
+    /**
+     * Get strategy data including owner, allocations, and metadata
+     * Note: Fee is the first allocation by convention
+     */
+    getData: (strategyAddress: Address) => Promise<StrategyData>;
+    /**
+     * Get the balance of a token held by the strategy
+     */
+    balanceOf: (strategyAddress: Address, token: Address) => Promise<bigint>;
+    /**
+     * Update the allocation configuration and metadata (owner only).
+     * Metadata is uploaded to the configured uploadUrl (defaults to inline data URI if not set).
+     */
+    rebalance: (strategyAddress: Address, allocations: Allocation[], metadata: StrategyMetadata) => Promise<{
+        hash: `0x${string}`;
+    }>;
+    /**
+     * Distribute the strategy's token balance to recipients according to allocations
+     */
+    distribute: (strategyAddress: Address, token: Address) => Promise<{
+        hash: `0x${string}`;
+    }>;
+    /**
+     * 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: (strategyAddress: Address, label: string) => Promise<{
+        hash: `0x${string}`;
+    }>;
+};
+
+type ENSNameData = {
+    owner: Address;
+    expiry: bigint;
+};
+type ChainDeployments$2 = {
+    ForeverSubnameRegistrar: {
+        abi: unknown;
+        address?: string;
+    };
+    PublicResolver: {
+        abi: unknown;
+        address: string;
+    };
+    ReverseRegistrar: {
+        abi: unknown;
+        address: string;
+    };
+};
+declare function createENSMethods(wallet: WalletClient | undefined, publicClient: PublicClient, chainId: SupportedChainId, deployments: ChainDeployments$2): {
+    /**
+     * 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}`;
+    }>;
+};
+
+type ChainDeployments$1 = {
+    SplitsWarehouse: {
+        abi: unknown;
+    };
+};
+declare function createWarehouseMethods(wallet: WalletClient | undefined, publicClient: PublicClient, chainId: SupportedChainId, deployments: ChainDeployments$1): {
+    /**
+     * Withdraw tokens from the SplitsWarehouse
+     * @param owner Address to withdraw for (usually msg.sender)
+     * @param token Token address to withdraw
+     */
+    withdraw: (owner: Address, token: Address) => Promise<{
+        hash: `0x${string}`;
+    }>;
+    /**
+     * Get warehouse balance for a user/token
+     * @param owner Address to check balance for
+     * @param token Token address
+     */
+    balanceOf: (owner: Address, token: Address) => Promise<bigint>;
+};
+
+type ChainDeployments = {
+    YieldRedirectorFactory: {
+        abi: unknown;
+        address: string;
+    };
+    YieldRedirector4626: {
+        abi: unknown;
+    };
+};
+declare function createYieldRedirectorMethods(wallet: WalletClient | undefined, publicClient: PublicClient, deployments: ChainDeployments): {
+    /**
+     * 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: (sourceVault: Address, yieldRecipient: Address, owner: Address) => Promise<{
+        redirector: Address;
+        sourceVault: Address;
+        yieldRecipient: Address;
+        owner: Address;
+    }>;
+    /**
+     * 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: (sourceVault: Address, yieldRecipient: Address, owner: Address, salt: `0x${string}`) => Promise<{
+        redirector: Address;
+        sourceVault: Address;
+        yieldRecipient: Address;
+        owner: Address;
+    }>;
+    /**
+     * Harvest yield from a redirector and send to recipient
+     * @param redirectorAddress The yield redirector contract address
+     */
+    harvest: (redirectorAddress: Address) => Promise<{
+        hash: `0x${string}`;
+    }>;
+    /**
+     * Get the current surplus (harvestable yield) from a redirector
+     * @param redirectorAddress The yield redirector contract address
+     */
+    surplus: (redirectorAddress: Address) => Promise<bigint>;
+    /**
+     * Get the principal deposited in a redirector
+     * @param redirectorAddress The yield redirector contract address
+     */
+    principal: (redirectorAddress: Address) => Promise<bigint>;
+    /**
+     * Get the total value in the source vault (principal + yield)
+     * @param redirectorAddress The yield redirector contract address
+     */
+    sourceVaultValue: (redirectorAddress: Address) => Promise<bigint>;
+    /**
+     * Update the yield recipient (owner only)
+     * @param redirectorAddress The yield redirector contract address
+     * @param newRecipient New address to receive harvested yield
+     */
+    setYieldRecipient: (redirectorAddress: Address, newRecipient: Address) => Promise<{
+        hash: `0x${string}`;
+    }>;
+};
+
+/**
+ * Execute a transaction and extract a specific event from the logs.
+ */
+declare function writeAndParse<T>(wallet: WalletClient, hash: `0x${string}`, abi: Abi, eventName: string): Promise<T>;
+/**
+ * Execute a transaction without parsing events, just wait for confirmation.
+ */
+declare function writeAndWait(wallet: WalletClient, hash: `0x${string}`): Promise<{
+    hash: `0x${string}`;
+}>;
+
+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;
+    /** GraphQL endpoint for the indexer (e.g. "https://...railway.app/graphql") */
+    indexerUrl?: string;
+    /** Function to upload strategy metadata and return a public URL. Use createUploadFn() for the standard implementation. */
+    uploadMetadata?: UploadMetadataFn;
+}>;
+declare function CuratorProvider<T extends CuratorSDK = CuratorSDK>({ children, client, defaultChain, tenant, indexerUrl, uploadMetadata, }: CuratorProviderProps<T>): React.ReactNode;
+declare function useCuratorSDK<T extends CuratorSDK = CuratorSDK>(): {
+    sdk: T | null;
+};
+
+declare const INVALIDATION_TIMEOUT_MS = 3000;
+declare const ENS_INVALIDATION_TIMEOUT_MS = 1000;
+declare function useInvalidate(): (queryKeys: unknown[][]) => void;
+/**
+ * Invalidate all ENS-related queries (both custom and wagmi's)
+ */
+declare function useInvalidateENS(): () => void;
+
+type QueryOptions$4 = {
+    enabled?: boolean;
+    refetchInterval?: number;
+};
+/**
+ * Resolve an ENS name to an address (forward resolution)
+ * Uses the SDK's configured public client with local ENS support
+ */
+declare function useENSGetAddress(name: string, opts?: QueryOptions$4): UseQueryResult<Address | null>;
+/**
+ * Check if a subdomain label is available for registration
+ * Works on any network where ForeverSubnameRegistrar is deployed
+ */
+declare function useENSAvailable(label: string, opts?: QueryOptions$4): UseQueryResult<boolean | null>;
+
+type QueryOptions$3 = {
+    enabled?: boolean;
+    refetchInterval?: number;
+};
+declare function useStrategyData(strategyAddress: Address | undefined, opts?: QueryOptions$3): UseQueryResult<StrategyData | null>;
+declare function useStrategyBalance(strategyAddress: Address | undefined, token: Address | undefined, opts?: QueryOptions$3): UseQueryResult<bigint | null>;
+declare function useCreateStrategy(opts?: UseMutationOptions<{
+    strategy: Address;
+    config: StrategyConfig;
+}, Error, StrategyConfig>): _tanstack_react_query.UseMutationResult<{
+    strategy: Address;
+    config: StrategyConfig;
+}, Error, StrategyConfig, unknown>;
+declare function useRebalanceStrategy(opts?: UseMutationOptions<{
+    hash: `0x${string}`;
+}, Error, {
+    strategyAddress: Address;
+    allocations: Allocation[];
+    metadata: StrategyMetadata;
+}>): _tanstack_react_query.UseMutationResult<{
+    hash: `0x${string}`;
+}, Error, {
+    strategyAddress: Address;
+    allocations: Allocation[];
+    metadata: StrategyMetadata;
+}, unknown>;
+declare function useDistributeStrategy(opts?: UseMutationOptions<{
+    hash: `0x${string}`;
+}, Error, {
+    strategyAddress: Address;
+    token: Address;
+}>): _tanstack_react_query.UseMutationResult<{
+    hash: `0x${string}`;
+}, Error, {
+    strategyAddress: Address;
+    token: Address;
+}, unknown>;
+/**
+ * Set ENS subdomain name for an existing strategy
+ */
+declare function useSetENSName(opts?: UseMutationOptions<{
+    hash: `0x${string}`;
+}, Error, {
+    strategyAddress: Address;
+    label: string;
+}>): _tanstack_react_query.UseMutationResult<{
+    hash: `0x${string}`;
+}, Error, {
+    strategyAddress: Address;
+    label: string;
+}, unknown>;
+
+type QueryOptions$2 = {
+    enabled?: boolean;
+    refetchInterval?: number;
+};
+declare function useWarehouseBalances(variables?: QueryVariables<WarehouseBalanceFilter>, opts?: QueryOptions$2): UseQueryResult<Page<WarehouseBalance> | null>;
+declare function useWarehouseBalance(user: Address | undefined, token: Address | undefined, opts?: QueryOptions$2): UseQueryResult<WarehouseBalance | null>;
+declare function useWithdrawFromWarehouse(opts?: UseMutationOptions<{
+    hash: `0x${string}`;
+}, Error, {
+    owner: Address;
+    token: Address;
+}>): _tanstack_react_query.UseMutationResult<{
+    hash: `0x${string}`;
+}, Error, {
+    owner: Address;
+    token: Address;
+}, unknown>;
+
+type QueryOptions$1 = {
+    enabled?: boolean;
+    refetchInterval?: number;
+};
+declare function useYieldRedirectors(variables?: QueryVariables<YieldRedirectorFilter>, opts?: QueryOptions$1): UseQueryResult<Page<YieldRedirector> | null>;
+declare function useYieldRedirectorById(id: Address | undefined, opts?: QueryOptions$1): UseQueryResult<YieldRedirector | null>;
+declare function useHarvests(variables?: QueryVariables<HarvestFilter>, opts?: QueryOptions$1): UseQueryResult<Page<Harvest> | null>;
+/**
+ * Create a new yield redirector
+ */
+declare function useCreateYieldRedirector(opts?: UseMutationOptions<{
+    redirector: Address;
+}, Error, {
+    sourceVault: Address;
+    yieldRecipient: Address;
+    owner: Address;
+}>): _tanstack_react_query.UseMutationResult<{
+    redirector: Address;
+}, Error, {
+    sourceVault: Address;
+    yieldRecipient: Address;
+    owner: Address;
+}, unknown>;
+/**
+ * Harvest yield from a redirector
+ */
+declare function useHarvestYield(opts?: UseMutationOptions<{
+    hash: `0x${string}`;
+}, Error, Address>): _tanstack_react_query.UseMutationResult<{
+    hash: `0x${string}`;
+}, Error, `0x${string}`, unknown>;
+
+type QueryOptions = {
+    enabled?: boolean;
+    refetchInterval?: number;
+};
+declare function useStrategies(variables?: QueryVariables<StrategyFilter>, opts?: QueryOptions): UseQueryResult<Page<Strategy> | null>;
+declare function useStrategyById(id: Address, opts?: QueryOptions): UseQueryResult<Strategy | null>;
+declare function useDistributions(variables?: QueryVariables<DistributionFilter>, opts?: QueryOptions): UseQueryResult<Page<Distribution> | null>;
+declare function usePayouts(variables?: QueryVariables<PayoutFilter>, opts?: QueryOptions): UseQueryResult<Page<Payout> | null>;
+declare function useDonors(variables?: QueryVariables<DonorFilter>, opts?: QueryOptions): UseQueryResult<Page<Donor> | null>;
+declare function useStrategyBalances(variables?: QueryVariables<StrategyBalanceFilter>, opts?: QueryOptions): UseQueryResult<Page<StrategyBalance> | null>;
+declare function useForks(variables?: QueryVariables<ForkFilter>, opts?: QueryOptions): UseQueryResult<Page<Fork> | null>;
+declare function useTrendingStrategies(options?: {
+    period?: "24h" | "7d";
+    limit?: number;
+}, opts?: QueryOptions): UseQueryResult<TrendingResponse | null>;
+declare function useProtocolStats(opts?: QueryOptions): UseQueryResult<ProtocolStats | null>;
+declare function useStrategyLineage(strategyAddress: Address | undefined, opts?: QueryOptions): UseQueryResult<StrategyLineage | null>;
+
+type TokenConfig = {
+    address: Address;
+    symbol: string;
+    name: string;
+    decimals: number;
+    logoURI?: string;
+};
+/**
+ * Native ETH address per ERC-7528 standard
+ * Used throughout the system to represent native ETH
+ */
+declare const NATIVE_TOKEN = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+declare const isNativeToken: (token?: string) => boolean;
+/**
+ * Native ETH token config
+ */
+declare const ETH_TOKEN: TokenConfig;
+/**
+ * Get all available tokens for a chain
+ */
+declare function getTokens(chainId: number): TokenConfig[];
+/**
+ * Get a token by symbol for a chain
+ */
+declare function getToken(chainId: number, symbol: string): TokenConfig | undefined;
+/**
+ * Get a token by address for a chain
+ */
+declare function getTokenByAddress(chainId: number, address: Address): TokenConfig | undefined;
+/**
+ * Get token addresses for a chain (useful for indexer)
+ */
+declare function getTokenAddresses(chainId: number): Address[];
+
+type VaultConfig = {
+    address: Address;
+    name: string;
+    symbol: string;
+    asset: Address;
+};
+/**
+ * Get all available vaults for a chain
+ */
+declare function getVaults(chainId: number): VaultConfig[];
+/**
+ * Get a vault by address for a chain
+ */
+declare function getVaultByAddress(chainId: number, address: Address): VaultConfig | undefined;
+/**
+ * Get vault addresses for a chain
+ */
+declare function getVaultAddresses(chainId: number): Address[];
+
+/**
+ * Creates an upload function for use with CuratorSDKOptions.uploadMetadata.
+ * Posts metadata JSON to the given URL with a Bearer token.
+ */
+declare function createUploadFn(url: string, token: string): UploadMetadataFn;
+
+type CuratorSDKOptions = {
+    chain?: SupportedChainId;
+    tenant?: string;
+    /** GraphQL endpoint for the indexer (e.g. "https://...railway.app/graphql") */
+    indexerUrl?: string;
+    /** Function to upload strategy metadata and return a public URL. Use createUploadFn() for the standard implementation. */
+    uploadMetadata?: UploadMetadataFn;
+};
+declare class CuratorSDK {
+    #private;
+    ens: ReturnType<typeof createENSMethods>;
+    strategy: ReturnType<typeof createStrategyMethods>;
+    warehouse: ReturnType<typeof createWarehouseMethods>;
+    yieldRedirector: ReturnType<typeof createYieldRedirectorMethods>;
+    constructor(wallet?: WalletClient, options?: CuratorSDKOptions | SupportedChainId);
+    get wallet(): WalletClient | undefined;
+    get publicClient(): PublicClient;
+    get chainId(): SupportedChainId;
+    get tenant(): string | undefined;
+    get indexer(): Indexer | null;
+}
+
+export { type Allocation, CuratorProvider, CuratorSDK, type CuratorSDKOptions, type Distribution, type DistributionFilter, type Donor, type DonorFilter, type ENSNameData, ENS_DOMAIN, ENS_INVALIDATION_TIMEOUT_MS, ETH_TOKEN, type Fork, type ForkFilter, type Harvest, type HarvestFilter, INVALIDATION_TIMEOUT_MS, type Indexer, type IndexerExtension, type LineageResponse, NATIVE_TOKEN, type Page, type Payout, type PayoutFilter, type ProtocolStats, type QueryVariables, type StatsResponse, type Strategy, type StrategyBalance, type StrategyBalanceFilter, type StrategyConfig, type StrategyData, type StrategyFilter, type StrategyLineage, type StrategyMetadata, type SupportedChainId, type TenantConfig, type TokenConfig, type TokenTotals, type Transfer, type TransferFilter, type TrendingResponse, type TrendingStrategy, type UploadMetadataFn, type VaultConfig, type WarehouseBalance, type WarehouseBalanceFilter, type YieldRedirector, type YieldRedirectorFilter, 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 };