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

SDK for the 0xSplits protocol

import { Address, GetContractReturnType, Hash, Hex, Log } from 'viem';
import { BaseClientMixin, BaseGasEstimatesMixin, BaseTransactions } from './base';
import { uniV3SwapAbi } from '../constants/abi/uniV3Swap';
import { swapperAbi } from '../constants/abi/swapper';
import type { CallData, CreateSwapperConfig, ReadContractArgs, SplitsClientConfig, SplitsPublicClient, SwapperExecCallsConfig, SwapperPauseConfig, SwapperSetBeneficiaryConfig, SwapperSetDefaultScaledOfferFactorConfig, SwapperSetOracleConfig, SwapperSetScaledOfferFactorOverridesConfig, SwapperSetTokenToBeneficiaryConfig, TransactionConfig, TransactionFormat, UniV3FlashSwapConfig } from '../types';
type SwapperAbi = typeof swapperAbi;
type UniV3SwapAbi = typeof uniV3SwapAbi;
declare class SwapperTransactions extends BaseTransactions {
    constructor(transactionClientArgs: SplitsClientConfig & TransactionConfig);
    protected _createSwapperTransaction({ owner, paused, beneficiary, tokenToBeneficiary, oracleParams, defaultScaledOfferFactorPercent, scaledOfferFactorOverrides, transactionOverrides, }: CreateSwapperConfig): Promise<TransactionFormat>;
    protected _uniV3FlashSwapTransaction({ swapperAddress, excessRecipient, inputAssets, transactionTimeLimit, chainId, transactionOverrides, }: UniV3FlashSwapConfig): Promise<TransactionFormat>;
    protected _setBeneficiaryTransaction({ swapperAddress, beneficiary, transactionOverrides, }: SwapperSetBeneficiaryConfig): Promise<TransactionFormat>;
    protected _setTokenToBeneficiaryTransaction({ swapperAddress, tokenToBeneficiary, transactionOverrides, }: SwapperSetTokenToBeneficiaryConfig): Promise<TransactionFormat>;
    protected _setOracleTransaction({ swapperAddress, oracle, transactionOverrides, }: SwapperSetOracleConfig): Promise<TransactionFormat>;
    protected _setDefaultScaledOfferFactorTransaction({ swapperAddress, defaultScaledOfferFactorPercent, transactionOverrides, }: SwapperSetDefaultScaledOfferFactorConfig): Promise<TransactionFormat>;
    protected _setScaledOfferFactorOverridesTransaction({ swapperAddress, scaledOfferFactorOverrides, transactionOverrides, }: SwapperSetScaledOfferFactorOverridesConfig): Promise<TransactionFormat>;
    protected _execCallsTransaction({ swapperAddress, calls, transactionOverrides, }: SwapperExecCallsConfig): Promise<TransactionFormat>;
    protected _setPausedTransaction({ swapperAddress, paused, transactionOverrides, }: SwapperPauseConfig): Promise<TransactionFormat>;
    private _requireOwner;
    protected _getUniV3SwapContract(chainId: number): GetContractReturnType<UniV3SwapAbi, SplitsPublicClient>;
    protected _getSwapperContract(swapper: string, chainId: number): GetContractReturnType<SwapperAbi, SplitsPublicClient>;
}
export declare class SwapperClient extends SwapperTransactions {
    readonly eventTopics: {
        [key: string]: Hex[];
    };
    readonly callData: SwapperCallData;
    readonly estimateGas: SwapperGasEstimates;
    constructor(clientArgs: SplitsClientConfig);
    _submitCreateSwapperTransaction(createSwapperArgs: CreateSwapperConfig): Promise<{
        txHash: Hash;
    }>;
    createSwapper(createSwapperArgs: CreateSwapperConfig): Promise<{
        swapperAddress: Address;
        event: Log;
    }>;
    _submitUniV3FlashSwapTransaction(flashArgs: UniV3FlashSwapConfig): Promise<{
        txHash: Hash;
    }>;
    uniV3FlashSwap(flashArgs: UniV3FlashSwapConfig): Promise<{
        event: Log;
    }>;
    _submitExecCallsTransaction(callArgs: SwapperExecCallsConfig): Promise<{
        txHash: Hash;
    }>;
    execCalls(callArgs: SwapperExecCallsConfig): Promise<{
        event: Log;
    }>;
    _submitSetPausedTransaction(pauseArgs: SwapperPauseConfig): Promise<{
        txHash: Hash;
    }>;
    setPaused(pauseArgs: SwapperPauseConfig): Promise<{
        event: Log;
    }>;
    _submitSetBeneficiaryTransaction(args: SwapperSetBeneficiaryConfig): Promise<{
        txHash: Hash;
    }>;
    setBeneficiary(args: SwapperSetBeneficiaryConfig): Promise<{
        event: Log;
    }>;
    _submitSetTokenToBeneficiaryTransaction(args: SwapperSetTokenToBeneficiaryConfig): Promise<{
        txHash: Hash;
    }>;
    setTokenToBeneficiary(args: SwapperSetTokenToBeneficiaryConfig): Promise<{
        event: Log;
    }>;
    _submitSetOracleTransaction(args: SwapperSetOracleConfig): Promise<{
        txHash: Hash;
    }>;
    setOracle(args: SwapperSetOracleConfig): Promise<{
        event: Log;
    }>;
    _submitSetDefaultScaledOfferFactorTransaction(args: SwapperSetDefaultScaledOfferFactorConfig): Promise<{
        txHash: Hash;
    }>;
    setDefaultScaledOfferFactor(args: SwapperSetDefaultScaledOfferFactorConfig): Promise<{
        event: Log;
    }>;
    _submitSetScaledOfferFactorOverridesTransaction(args: SwapperSetScaledOfferFactorOverridesConfig): Promise<{
        txHash: Hash;
    }>;
    setScaledOfferFactorOverrides(args: SwapperSetScaledOfferFactorOverridesConfig): Promise<{
        event: Log;
    }>;
    getBeneficiary({ swapperAddress, chainId, }: ReadContractArgs & {
        swapperAddress: string;
    }): Promise<{
        beneficiary: Address;
    }>;
    getTokenToBeneficiary({ swapperAddress, chainId, }: ReadContractArgs & {
        swapperAddress: string;
    }): Promise<{
        tokenToBeneficiary: Address;
    }>;
    getOracle({ swapperAddress, chainId, }: ReadContractArgs & {
        swapperAddress: string;
    }): Promise<{
        oracle: Address;
    }>;
    getDefaultScaledOfferFactor({ swapperAddress, chainId, }: ReadContractArgs & {
        swapperAddress: string;
    }): Promise<{
        defaultScaledOfferFactor: number;
    }>;
    getScaledOfferFactorOverrides({ swapperAddress, quotePairs, chainId, }: ReadContractArgs & {
        swapperAddress: string;
        quotePairs: {
            base: string;
            quote: string;
        }[];
    }): Promise<{
        scaledOfferFactorOverrides: number[];
    }>;
}
export interface SwapperClient extends BaseClientMixin {
}
declare class SwapperGasEstimates extends SwapperTransactions {
    constructor(clientArgs: SplitsClientConfig);
    createSwapper(createSwapperArgs: CreateSwapperConfig): Promise<bigint>;
    uniV3FlashSwap(flashArgs: UniV3FlashSwapConfig): Promise<bigint>;
    execCalls(callArgs: SwapperExecCallsConfig): Promise<bigint>;
    setPaused(args: SwapperPauseConfig): Promise<bigint>;
    setBeneficiary(args: SwapperSetBeneficiaryConfig): Promise<bigint>;
    setTokenToBeneficiary(args: SwapperSetTokenToBeneficiaryConfig): Promise<bigint>;
    setOracle(args: SwapperSetOracleConfig): Promise<bigint>;
    setDefaultScaledOfferFactor(args: SwapperSetDefaultScaledOfferFactorConfig): Promise<bigint>;
    setScaledOfferFactorOverrides(args: SwapperSetScaledOfferFactorOverridesConfig): Promise<bigint>;
}
interface SwapperGasEstimates extends BaseGasEstimatesMixin {
}
declare class SwapperCallData extends SwapperTransactions {
    constructor(clientArgs: SplitsClientConfig);
    createSwapper(createSwapperArgs: CreateSwapperConfig): Promise<CallData>;
    uniV3FlashSwap(flashArgs: UniV3FlashSwapConfig): Promise<CallData>;
    execCalls(callArgs: SwapperExecCallsConfig): Promise<CallData>;
    setPaused(args: SwapperPauseConfig): Promise<CallData>;
    setBeneficiary(args: SwapperSetBeneficiaryConfig): Promise<CallData>;
    setTokenToBeneficiary(args: SwapperSetTokenToBeneficiaryConfig): Promise<CallData>;
    setOracle(args: SwapperSetOracleConfig): Promise<CallData>;
    setDefaultScaledOfferFactor(args: SwapperSetDefaultScaledOfferFactorConfig): Promise<CallData>;
    setScaledOfferFactorOverrides(args: SwapperSetScaledOfferFactorOverridesConfig): Promise<CallData>;
}
export {};