@0xsplits/splits-sdk/dist/src/client/data.d.ts

SDK for the 0xSplits protocol

import { DocumentNode } from 'graphql';
import { Address } from 'viem';
import { DataClientConfig, FormattedContractEarnings, FormattedEarningsByContract, FormattedSplitEarnings, FormattedTokenBalances, FormattedUserEarningsByContract, LiquidSplit, Split, SplitsContract, SplitsPublicClient, Swapper, VestingModule, WaterfallModule } from '../types';
import { GqlVariables } from '../subgraph';
import { IAccountType, ISubgraphAccount } from '../subgraph/types';
export declare class DataClient {
    readonly _ensPublicClient: SplitsPublicClient | undefined;
    readonly _publicClient: SplitsPublicClient | undefined;
    readonly _publicClients: {
        [chainId: number]: SplitsPublicClient;
    } | undefined;
    private readonly _graphqlClient;
    readonly _includeEnsNames: boolean;
    constructor({ publicClient, publicClients, ensPublicClient, apiConfig, includeEnsNames, }: DataClientConfig);
    protected _requirePublicClient(chainId: number): void;
    protected _getPublicClient(chainId: number): SplitsPublicClient;
    protected _makeGqlRequest<ResponseType>(query: DocumentNode, variables?: GqlVariables): Promise<ResponseType>;
    protected _loadAccount(accountId: string, chainId: number): Promise<IAccountType | undefined>;
    protected _loadFullAccount(accountId: string, chainId: number): Promise<ISubgraphAccount>;
    protected _getUserBalancesByContract({ chainId, userAddress, contractAddresses, }: {
        chainId: number;
        userAddress: string;
        contractAddresses?: string[];
    }): Promise<{
        contractEarnings: FormattedEarningsByContract;
    }>;
    protected _getAccountBalances({ chainId, accountAddress, includeActiveBalances, erc20TokenList, }: {
        chainId: number;
        accountAddress: Address;
        includeActiveBalances: boolean;
        erc20TokenList?: string[];
    }): Promise<{
        withdrawn: FormattedTokenBalances;
        distributed: FormattedTokenBalances;
        activeBalances?: FormattedTokenBalances;
    }>;
    getContractEarnings({ chainId, contractAddress, includeActiveBalances, erc20TokenList, }: {
        chainId: number;
        contractAddress: string;
        includeActiveBalances?: boolean;
        erc20TokenList?: string[];
    }): Promise<FormattedContractEarnings>;
    getSplitMetadata({ chainId, splitAddress, }: {
        chainId: number;
        splitAddress: string;
    }): Promise<Split>;
    getAccountMetadata({ chainId, accountAddress, }: {
        chainId: number;
        accountAddress: string;
    }): Promise<SplitsContract | undefined>;
    getRelatedSplits({ chainId, address, }: {
        chainId: number;
        address: string;
    }): Promise<{
        receivingFrom: Split[];
        controlling: Split[];
        pendingControl: Split[];
    }>;
    getSplitEarnings({ chainId, splitAddress, includeActiveBalances, erc20TokenList, }: {
        chainId: number;
        splitAddress: string;
        includeActiveBalances?: boolean;
        erc20TokenList?: string[];
    }): Promise<FormattedSplitEarnings>;
    getUserEarnings({ chainId, userAddress, }: {
        chainId: number;
        userAddress: string;
    }): Promise<{
        withdrawn: FormattedTokenBalances;
        activeBalances: FormattedTokenBalances;
    }>;
    getUserEarningsByContract({ chainId, userAddress, contractAddresses, }: {
        chainId: number;
        userAddress: string;
        contractAddresses?: string[];
    }): Promise<FormattedUserEarningsByContract>;
    getLiquidSplitMetadata({ chainId, liquidSplitAddress, }: {
        chainId: number;
        liquidSplitAddress: string;
    }): Promise<LiquidSplit>;
    getSwapperMetadata({ chainId, swapperAddress, }: {
        chainId: number;
        swapperAddress: string;
    }): Promise<Swapper>;
    getVestingMetadata({ chainId, vestingModuleAddress, }: {
        chainId: number;
        vestingModuleAddress: string;
    }): Promise<VestingModule>;
    getWaterfallMetadata({ chainId, waterfallModuleAddress, }: {
        chainId: number;
        waterfallModuleAddress: string;
    }): Promise<WaterfallModule>;
    private _formatAccount;
    private formatWaterfallModule;
    private formatVestingModule;
    private formatSwapper;
    private formatLiquidSplit;
    private formatSplit;
}