import { Logger } from './Logger';
import { TokenAccountMetadata } from '../swap_api_utils';
import BN from 'bn.js';
import { AccountInfoBase, AccountInfoWithBase64EncodedData, Address, Base64EncodedWireTransaction, Rpc, SimulateTransactionApi, SolanaError, SolanaRpcApi, Transaction } from '@solana/kit';
export interface TokenBalance {
    mint: Address;
    amount: BN;
}
export interface BalanceChange {
    address: Address;
    beforeAmount: BN;
    afterAmount: BN;
    change: BN;
}
type OverloadToUnion<F> = F extends {
    (a: infer A1, b: infer B1): infer R1;
    (a: infer A2, b: infer B2): infer R2;
    (a: infer A3, b: infer B3): infer R3;
    (a: infer A4, b: infer B4): infer R4;
    (a: infer A5, b: infer B5): infer R5;
    (a: infer A6, b: infer B6): infer R6;
    (a: infer A7, b: infer B7): infer R7;
    (a: infer A8, b: infer B8): infer R8;
    (a: infer A9, b: infer B9): infer R9;
    (a: infer A10, b: infer B10): infer R10;
} ? ((a: A1, b: B1) => R1) | ((a: A2, b: B2) => R2) | ((a: A3, b: B3) => R3) | ((a: A4, b: B4) => R4) | ((a: A5, b: B5) => R5) | ((a: A6, b: B6) => R6) | ((a: A7, b: B7) => R7) | ((a: A8, b: B8) => R8) | ((a: A9, b: B9) => R9) | ((a: A10, b: B10) => R10) : F;
type Base64AccountsOverload<F> = Extract<OverloadToUnion<F>, (a: Base64EncodedWireTransaction, b: {
    encoding: 'base64';
    accounts: {
        encoding: 'base64';
        addresses: any;
    };
}) => any>;
type RpcPayload<F> = F extends (...args: any[]) => infer R ? R : never;
export type SimulateTransactionResponse = RpcPayload<Base64AccountsOverload<SimulateTransactionApi['simulateTransaction']>>;
export interface GenericSimulationResult {
    successful: boolean;
    tokenBalanceChanges: BalanceChange[];
    lamportsBalanceChanges: BalanceChange[];
    isSlippageError: boolean;
    simulationError: SolanaError | undefined;
    simulationResponse: SimulateTransactionResponse | undefined;
    simulationUrl: string;
    simulationTimestamp?: number;
}
export interface SwapSimulationResult {
    successful: boolean;
    inputToken: BalanceChange | null;
    outputToken: BalanceChange | null;
    nativeChangeAmount: BN;
    isSlippageError: boolean;
    simulationError: SolanaError | undefined;
    simulationResponse: SimulateTransactionResponse | undefined;
    simulationUrl: string;
    simulationTimestamp?: number;
}
export declare function buildGenericSimulationResultFromTrackedAccounts(params: {
    tokenAccounts: TokenAccountMetadata[];
    lamportsAccounts: Address[];
    tokenBalancesBefore: Map<Address, TokenBalance>;
    lamportsBalancesBefore: Map<Address, BN>;
    trackedAccounts: ((AccountInfoBase & AccountInfoWithBase64EncodedData) | null)[];
    simulationResponse?: SimulateTransactionResponse | undefined;
    simulationUrl: string;
    simulationTimestamp?: number;
}): GenericSimulationResult;
export declare function mapGenericSimulationResultToSwapSimulationResult(walletAddress: Address, result: GenericSimulationResult, inputTokenAta: Address, outputTokenAta: Address): SwapSimulationResult;
export declare function simulateTransactionsWithBalanceTracking(rpc: Rpc<SolanaRpcApi>, transactions: Transaction[], tokenAccounts: TokenAccountMetadata[], lamportsAccounts: Address[], logger?: Logger, transactionLabels?: string[]): Promise<GenericSimulationResult[]>;
export declare function simulateSwapsWithATABalances(connection: Rpc<SolanaRpcApi>, transactions: Transaction[], walletAddress: Address, inputMint: Address, outputMint: Address, inputMintProgramId: Address, outputMintProgramId: Address, logger?: Logger, transactionLabels?: string[], accountOverrides?: {
    inputTokenAccount?: Address;
    outputTokenAccount?: Address;
}): Promise<SwapSimulationResult[]>;
export declare function extractTokenBalance(accountInfo: (AccountInfoBase & AccountInfoWithBase64EncodedData) | null, mint: Address): TokenBalance | null;
export declare function isSimulationSlippageError(simulationLogs: string[] | null): boolean;
export {};
//# sourceMappingURL=simulateTransaction.d.ts.map