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

SDK for the 0xSplits protocol

import { Address, GetContractReturnType, Hash, Hex, Log, TypedDataDomain } from 'viem';
import { SplitV2CreatedLogType, SplitV2UpdatedLogType } from '../constants';
import { splitV2ABI } from '../constants/abi/splitV2';
import { splitV2FactoryABI } from '../constants/abi/splitV2Factory';
import { CallData, CreateSplitV2Config, DistributeSplitConfig, FormattedSplitEarnings, SetPausedConfig, Split, SplitV2ExecCallsConfig, SplitV2Type, SplitsClientConfig, SplitsPublicClient, TransactionConfig, TransactionFormat, TransferOwnershipConfig, UpdateSplitV2Config } from '../types';
import { BaseClientMixin, BaseGasEstimatesMixin, BaseTransactions } from './base';
import { SplitV2Versions } from '../subgraph/types';
import { splitV2o1FactoryAbi } from '../constants/abi';
type SplitV2o1FactoryABI = typeof splitV2o1FactoryAbi;
type SplitFactoryABI = typeof splitV2FactoryABI;
type SplitV2ABI = typeof splitV2ABI;
type V2Type = 'splitV2' | 'splitV2o1';
declare class SplitV2Transactions extends BaseTransactions {
    constructor(transactionClientArgs: SplitsClientConfig & TransactionConfig);
    protected _createSplit({ recipients, distributorFeePercent, totalAllocationPercent, splitType, ownerAddress: controllerAddress, creatorAddress, salt, chainId, transactionOverrides, v2Type, }: CreateSplitV2Config & {
        v2Type: V2Type;
    }): Promise<TransactionFormat>;
    protected _transferOwnership({ splitAddress, newOwner: newController, transactionOverrides, }: TransferOwnershipConfig): Promise<TransactionFormat>;
    protected _setPaused({ splitAddress, paused, transactionOverrides, }: SetPausedConfig): Promise<TransactionFormat>;
    protected _execCalls({ splitAddress, calls, transactionOverrides, }: SplitV2ExecCallsConfig): Promise<TransactionFormat>;
    protected _updateSplit({ splitAddress, recipients, distributorFeePercent, totalAllocationPercent, transactionOverrides, }: UpdateSplitV2Config): Promise<TransactionFormat>;
    protected _distribute({ splitAddress, tokenAddress: token, distributorAddress, chainId, splitFields, transactionOverrides, }: DistributeSplitConfig): Promise<TransactionFormat>;
    protected _paused(splitAddress: Address, chainId: number): Promise<boolean>;
    protected _owner(splitAddress: Address, chainId: number): Promise<Address>;
    protected _checkForSplitExistence({ splitAddress, chainId, }: {
        splitAddress: Address;
        chainId: number;
    }): Promise<void>;
    protected _getSplitVersion({ splitAddress, chainId, }: {
        splitAddress: Address;
        chainId: number;
    }): Promise<SplitV2Versions>;
    protected _getSplitMetadataViaProvider({ splitAddress, chainId, cachedData, }: {
        splitAddress: Address;
        chainId: number;
        cachedData?: {
            blocks?: {
                createBlock?: bigint;
                updateBlock?: bigint;
                latestScannedBlock: bigint;
            };
            blockRange?: bigint;
        };
    }): Promise<{
        split: Split;
        blockRange: bigint;
    }>;
    protected _buildSplitFromLogs({ splitAddress, chainId, createLog, updateLog, }: {
        splitAddress: Address;
        chainId: number;
        createLog?: SplitV2CreatedLogType;
        updateLog?: SplitV2UpdatedLogType;
    }): Promise<Split>;
    protected _getSplitV2Contract(splitAddress: Address, chainId: number): GetContractReturnType<SplitV2ABI, SplitsPublicClient>;
    protected _getSplitV2FactoryContract(splitType: SplitV2Type, chainId: number): GetContractReturnType<SplitFactoryABI, SplitsPublicClient>;
    protected _getSplitV2o1FactoryContract(splitType: SplitV2Type, chainId: number): GetContractReturnType<SplitV2o1FactoryABI, SplitsPublicClient>;
    protected _eip712Domain(splitAddress: Address, chainId: number): Promise<{
        domain: TypedDataDomain;
    }>;
    protected _requireOwner(splitAddress: Address): Promise<void>;
}
export declare class SplitV2Client extends SplitV2Transactions {
    readonly eventTopics: {
        [key: string]: Hex[];
    };
    readonly callData: SplitV2CallData;
    readonly estimateGas: SplitV2GasEstimates;
    readonly sign: SplitV2Signature;
    constructor(clientArgs: SplitsClientConfig);
    _submitCreateSplitTransaction(createSplitArgs: CreateSplitV2Config): Promise<{
        txHash: Hash;
    }>;
    createSplit(createSplitArgs: CreateSplitV2Config): Promise<{
        splitAddress: Address;
        event: Log;
    }>;
    _submitCreateSplitTransactionOldV2(createSplitArgs: CreateSplitV2Config): Promise<{
        txHash: Hash;
    }>;
    _createSplitOldV2(createSplitArgs: CreateSplitV2Config): Promise<{
        splitAddress: Address;
        event: Log;
    }>;
    _submitTransferOwnershipTransaction(transferOwnershipArgs: TransferOwnershipConfig): Promise<{
        txHash: Hash;
    }>;
    transferOwnership(transferOwnershipArgs: TransferOwnershipConfig): Promise<{
        event: Log;
    }>;
    _submitSetPauseTransaction(setPausedArgs: SetPausedConfig): Promise<{
        txHash: Hash;
    }>;
    setPause(setPausedArgs: SetPausedConfig): Promise<{
        event: Log;
    }>;
    _submitExecCallsTransaction(execCallsArgs: SplitV2ExecCallsConfig): Promise<{
        txHash: Hash;
    }>;
    execCalls(execCallsArgs: SplitV2ExecCallsConfig): Promise<{
        event: Log;
    }>;
    _submitDistributeTransaction(distributeArgs: DistributeSplitConfig): Promise<{
        txHash: Hash;
    }>;
    distribute(distributeArgs: DistributeSplitConfig): Promise<{
        event: Log;
    }>;
    _submitUpdateSplitTransaction(updateSplitArgs: UpdateSplitV2Config): Promise<{
        txHash: Hash;
    }>;
    updateSplit(updateSplitArgs: UpdateSplitV2Config): Promise<{
        event: Log;
    }>;
    private _predictDeterministicAddress;
    predictDeterministicAddress(createSplitArgs: CreateSplitV2Config): Promise<{
        splitAddress: Address;
    }>;
    _predictDeterministicAddressOldV2(createSplitArgs: CreateSplitV2Config): Promise<{
        splitAddress: Address;
    }>;
    private _isDeployed;
    isDeployed(createSplitArgs: CreateSplitV2Config): Promise<{
        splitAddress: Address;
        deployed: boolean;
    }>;
    _isDeployedOldV2(createSplitArgs: CreateSplitV2Config): Promise<{
        splitAddress: Address;
        deployed: boolean;
    }>;
    getSplitBalance({ splitAddress, tokenAddress, chainId, }: {
        splitAddress: Address;
        tokenAddress: Address;
        chainId?: number;
    }): Promise<{
        splitBalance: bigint;
        warehouseBalance: bigint;
    }>;
    getReplaySafeHash({ splitAddress, hash, chainId, }: {
        splitAddress: Address;
        hash: Hex;
        chainId?: number;
    }): Promise<{
        hash: Hex;
    }>;
    isValidSignature({ splitAddress, hash, signature, chainId, }: {
        splitAddress: Address;
        hash: Hex;
        signature: Hex;
        chainId?: number;
    }): Promise<{
        isValid: boolean;
    }>;
    eip712Domain({ splitAddress, chainId, }: {
        splitAddress: Address;
        chainId?: number;
    }): Promise<{
        domain: TypedDataDomain;
    }>;
    paused({ splitAddress, chainId, }: {
        splitAddress: Address;
        chainId?: number;
    }): Promise<{
        paused: boolean;
    }>;
    owner({ splitAddress, chainId, }: {
        splitAddress: Address;
        chainId?: number;
    }): Promise<{
        ownerAddress: Address;
    }>;
    _doesSplitExist({ splitAddress, chainId, }: {
        splitAddress: Address;
        chainId: number;
    }): Promise<boolean>;
    _getSplitFromLogs({ splitAddress, chainId, createLog, updateLog, }: {
        splitAddress: Address;
        chainId: number;
        createLog: SplitV2CreatedLogType;
        updateLog?: SplitV2UpdatedLogType;
    }): Promise<Split>;
    getSplitVersion({ splitAddress, chainId, }: {
        splitAddress: Address;
        chainId: number;
    }): Promise<SplitV2Versions>;
    getSplitMetadataViaProvider({ splitAddress, chainId, cachedData, }: {
        splitAddress: string;
        chainId?: number;
        cachedData?: {
            blocks?: {
                createBlock?: bigint;
                updateBlock?: bigint;
                latestScannedBlock: bigint;
            };
            blockRange?: bigint;
        };
    }): Promise<{
        split: Split;
        blockRange: bigint;
    }>;
    getSplitActiveBalances({ splitAddress, chainId, erc20TokenList, }: {
        splitAddress: string;
        chainId?: number;
        erc20TokenList?: string[];
    }): Promise<Pick<FormattedSplitEarnings, 'activeBalances'>>;
}
export interface SplitV2Client extends BaseClientMixin {
}
declare class SplitV2GasEstimates extends SplitV2Transactions {
    constructor(clientArgs: SplitsClientConfig);
    createSplit(createSplitArgs: CreateSplitV2Config): Promise<bigint>;
    _createSplitOldV2(createSplitArgs: CreateSplitV2Config): Promise<bigint>;
    transferOwnership(transferOwnershipArgs: TransferOwnershipConfig): Promise<bigint>;
    setPaused(setPausedArgs: SetPausedConfig): Promise<bigint>;
    execCalls(execCallsArgs: SplitV2ExecCallsConfig): Promise<bigint>;
    distribute(distributeArgs: DistributeSplitConfig): Promise<bigint>;
    updateSplit(updateSplitArgs: UpdateSplitV2Config): Promise<bigint>;
}
interface SplitV2GasEstimates extends BaseGasEstimatesMixin {
}
declare class SplitV2CallData extends SplitV2Transactions {
    constructor(clientArgs: SplitsClientConfig);
    createSplit(createSplitArgs: CreateSplitV2Config): Promise<CallData>;
    _createSplitOldV2(createSplitArgs: CreateSplitV2Config): Promise<CallData>;
    transferOwnership(transferOwnershipArgs: TransferOwnershipConfig): Promise<CallData>;
    setPaused(setPausedArgs: SetPausedConfig): Promise<CallData>;
    execCalls(execCallsArgs: SplitV2ExecCallsConfig): Promise<CallData>;
    distribute(distributeArgs: DistributeSplitConfig): Promise<CallData>;
    updateSplit(updateSplitArgs: UpdateSplitV2Config): Promise<CallData>;
}
declare class SplitV2Signature extends SplitV2Transactions {
    constructor(clientArgs: SplitsClientConfig);
    signData(splitAddress: Address, data: Hex, chainId?: number): Promise<{
        signature: Hex;
    }>;
}
export {};