import 'dotenv/config';
import { ICache } from './dex-helper/icache';
interface StateObject {
    storage?: Record<string, string>;
    balance?: string;
    nonce?: number;
    code?: string;
}
export type StateOverride = Record<string, StateObject>;
interface TokenStorageSlots {
    balanceSlot: string;
    allowanceSlot: string;
    isVyper?: boolean;
    stateProxy?: string;
    additionalOverrides?: StateOverride;
}
interface SimulateTransactionRequest {
    from: string | null;
    to: string | null;
    value?: string;
    data: string;
    chainId: number;
    timestamp?: number;
    blockNumber?: number;
    stateOverride?: StateOverride;
}
interface SimulatedTransactionCall {
    hash: string;
    contract_name: string;
    function_name: string;
    function_pc: number;
    function_op: string;
    function_file_index: number;
    function_code_start: number;
    function_line_number: number;
    function_code_length: number;
    absolute_position: number;
    caller_pc: number;
    caller_op: string;
    call_type: string;
    address: string;
    from: string;
    from_balance: string;
    to: string;
    to_balance: string;
    value: string | null;
    caller: {
        address: string;
        balance: string;
    };
    block_timestamp: string;
    gas: number;
    gas_used: number;
    intrinsic_gas: number;
    storage_address: string;
    input: string;
    output: string;
    storage_slot: string[] | undefined;
    calls: SimulatedTransactionCall[] | null;
}
type SimulatedTransactionCallWithParent = SimulatedTransactionCall & {
    parentCall: SimulatedTransactionCall | null;
};
interface Simulation {
    id: string;
    project_id: string;
    owner_id: string;
    network_id: string;
    block_number: number;
    transaction_index: number;
    from: string;
    to: string;
    input: string;
    gas: number;
    gas_price: string;
    gas_used: number;
    value: string;
    method: string;
    status: boolean;
}
interface SimulatedTransactionDetails {
    transaction: {
        hash: string;
        block_hash: string;
        block_number: number;
        from: string;
        gas: number;
        gas_price: number;
        gas_fee_cap: number;
        gas_tip_cap: number;
        cumulative_gas_used: number;
        gas_used: number;
        effective_gas_price: number;
        input: string;
        nonce: number;
        to: string;
        index: number;
        value: string;
        access_list: null;
        status: boolean;
        transaction_info: {
            call_trace: SimulatedTransactionCall;
        };
        call_trace: SimulatedTransactionCall[];
    };
}
export type SimulatedTransaction = Pick<SimulatedTransactionDetails['transaction'], 'transaction_info' | 'call_trace'>;
export type SimulationResult = {
    transaction: SimulatedTransaction;
    simulation: Simulation;
};
export declare class TenderlySimulator {
    static readonly DEFAULT_OWNER = "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
    static readonly DEFAULT_SPENDER = "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
    private static instance;
    private constructor();
    static getInstance(cache?: ICache, tenderlyToken?: string, tenderlyProject?: string, tenderlyAccountId?: string): TenderlySimulator;
    simulateTransaction(request: SimulateTransactionRequest, forceSimulationAPI?: boolean): Promise<SimulationResult>;
    private simulateWithTenderlySimulationAPI;
    private simulateWithTenderlyVNet;
    getSimulatedTransactionDetails(id: string): Promise<SimulatedTransactionDetails | null>;
    getSLOADCalls: (callTrace: SimulatedTransactionCall, parentCall?: SimulatedTransactionCall | null) => SimulatedTransactionCallWithParent[];
    /**
     *
     * @param balanceOfSlot storage slot of `balanceOf` mapping
     * @param owner account's address
     * @param isVyper `true` if contract is written in Vyper
     */
    calculateAddressBalanceSlot(balanceOfSlot: string, owner: string, isVyper?: boolean): string;
    /**
     *
     * @param balanceOfSlot storage slot of `balanceOf` mapping
     * @param owner account's address
     */
    calculateSolidityAddressBalanceSlot(balanceOfSlot: string, owner: string): string;
    /**
     *
     * @param balanceOfSlot storage slot of `balanceOf` mapping
     * @param owner account's address
     */
    calculateVyperAddressBalanceSlot(balanceOfSlot: string, owner: string): string;
    /**
     *
     * @param allowanceSlot storage slot of `allowance` mapping
     * @param owner account's address
     * @param spender spender's address
     * @param isVyper `true` if contract is written in Vyper
     */
    calculateAddressAllowanceSlot(allowanceSlot: string, owner: string, spender: string, isVyper?: boolean): string;
    /**
     *
     * @param allowanceSlot storage slot of `allowance` mapping
     * @param owner account's address
     * @param spender spender's address
     */
    calculateSolidityAddressAllowanceSlot(allowanceSlot: string, owner: string, spender: string): string;
    /**
     *
     * @param allowanceSlot storage slot of `allowance` mapping
     * @param owner account's address
     * @param spender spender's address
     */
    calculateVyperAddressAllowanceSlot(allowanceSlot: string, owner: string, spender: string): string;
    buildBalanceOfSimulationRequest(chainId: number, token: string, owner: string): SimulateTransactionRequest;
    buildAllowanceSimulationRequest(chainId: number, token: string, owner: string, spender: string): SimulateTransactionRequest;
    /**
     * Finds the slot of the `balanceOf` mapping in given token contract's storage.
     * Supports `Solidity` and `Vyper` contracts
     * @param chainId token chain id
     * @param token token address
     */
    findTokenBalanceOfSlot(chainId: number, token: string): Promise<{
        slot: string;
        isVyper?: boolean;
        stateProxy?: string;
    }>;
    /**
     * Finds the slot of the `allowance` mapping in given token contract's storage
     * Supports `Solidity` and `Vyper` contracts
     * @param chainId token chain id
     * @param token token address
     */
    findTokenAllowanceSlot(chainId: number, token: string): Promise<{
        slot: string;
        isVyper?: boolean;
        stateProxy?: string;
    }>;
    /**
     * Returns storage slots for the given token contract.
     * @param chainId Token chain ID
     * @param token Token address. Doesn't have to be normalized
     */
    getTokenStorageSlots(chainId: number, token: string): Promise<TokenStorageSlots>;
    /**
     * Adds native balance override to an existing `StateOverride` object
     * @param stateOverride object to add the override to
     * @param account address to be given the balance
     * @param amount token amount in wei
     */
    addBalanceOverride(stateOverride: StateOverride, account: string, amount: bigint): void;
    /**
     * Adds token balance override to an existing `StateOverride` object
     * @param stateOverride object to add the override to
     * @param chainId token chain ID
     * @param token token address
     * @param account address to be given the balance
     * @param amount token amount in wei
     */
    addTokenBalanceOverride(stateOverride: StateOverride, chainId: number, token: string, account: string, amount: bigint): Promise<void>;
    /**
     * Adds token allowance override to an existing `StateOverride` object
     * @param stateOverride object to add the override to
     * @param chainId token chain ID
     * @param token token address
     * @param account owner address
     * @param spender spender address
     * @param amount token amount in wei
     */
    addAllowanceOverride(stateOverride: StateOverride, chainId: number, token: string, account: string, spender: string, amount: bigint): Promise<void>;
}
export {};