import { TAddress } from '../../../models/TAddress';
import { TAccount } from '../../../models/TAccount';
import { ClientEventsStream, TClientEventsStreamData } from '../../../clients/ClientEventsStream';
import { ContractBase } from '../../../contracts/ContractBase';
import { ContractStorageReaderBase } from '../../../contracts/ContractStorageReaderBase';
import { TxWriter } from '../../../txs/TxWriter';
import { ITxLogItem } from '../../../txs/receipt/ITxLogItem';
import { Web3Client } from '../../../clients/Web3Client';
import { IBlockchainExplorer } from '../../../explorer/IBlockchainExplorer';
import { SubjectStream } from '../../../class/SubjectStream';
import type { TAbiItem } from '../../../types/TAbi';
import type { TEth } from '../../../models/TEth';
import type { TOverrideReturns } from '../../../utils/types';
export declare namespace EntryPointErrors {
    interface ExecutionResult {
        type: 'ExecutionResult';
        params: {
            preOpGas: bigint;
            paid: bigint;
            validAfter: number;
            validUntil: number;
            targetSuccess: boolean;
            targetResult: TEth.Hex;
        };
    }
    interface FailedOp {
        type: 'FailedOp';
        params: {
            opIndex: bigint;
            reason: string;
        };
    }
    interface SenderAddressResult {
        type: 'SenderAddressResult';
        params: {
            sender: TAddress;
        };
    }
    interface SignatureValidationFailed {
        type: 'SignatureValidationFailed';
        params: {
            aggregator: TAddress;
        };
    }
    interface ValidationResult {
        type: 'ValidationResult';
        params: {
            returnInfo: {
                preOpGas: bigint;
                prefund: bigint;
                sigFailed: boolean;
                validAfter: number;
                validUntil: number;
                paymasterContext: TEth.Hex;
            };
            senderInfo: {
                stake: bigint;
                unstakeDelaySec: bigint;
            };
            factoryInfo: {
                stake: bigint;
                unstakeDelaySec: bigint;
            };
            paymasterInfo: {
                stake: bigint;
                unstakeDelaySec: bigint;
            };
        };
    }
    interface ValidationResultWithAggregation {
        type: 'ValidationResultWithAggregation';
        params: {
            returnInfo: {
                preOpGas: bigint;
                prefund: bigint;
                sigFailed: boolean;
                validAfter: number;
                validUntil: number;
                paymasterContext: TEth.Hex;
            };
            senderInfo: {
                stake: bigint;
                unstakeDelaySec: bigint;
            };
            factoryInfo: {
                stake: bigint;
                unstakeDelaySec: bigint;
            };
            paymasterInfo: {
                stake: bigint;
                unstakeDelaySec: bigint;
            };
            aggregatorInfo: {
                aggregator: TAddress;
                stakeInfo: {
                    stake: bigint;
                    unstakeDelaySec: bigint;
                };
            };
        };
    }
    type Error = ExecutionResult | FailedOp | SenderAddressResult | SignatureValidationFailed | ValidationResult | ValidationResultWithAggregation;
}
export declare class EntryPoint extends ContractBase {
    address: TEth.Address;
    client: Web3Client;
    explorer: IBlockchainExplorer;
    constructor(address?: TEth.Address, client?: Web3Client, explorer?: IBlockchainExplorer);
    Types: TEntryPointTypes;
    $meta: {
        class: string;
    };
    SIG_VALIDATION_FAILED(): Promise<bigint>;
    _validateSenderAndPaymaster(initCode: TEth.Hex, _sender: TAddress, paymasterAndData: TEth.Hex): Promise<bigint>;
    addStake(sender: TSender, unstakeDelaySec: number): Promise<TxWriter>;
    balanceOf(account: TAddress): Promise<bigint>;
    depositTo(sender: TSender, account: TAddress): Promise<TxWriter>;
    deposits(input0: TAddress): Promise<{
        deposit: bigint;
        staked: boolean;
        stake: bigint;
        unstakeDelaySec: number;
        withdrawTime: number;
    }>;
    getDepositInfo(account: TAddress): Promise<{
        deposit: bigint;
        staked: boolean;
        stake: bigint;
        unstakeDelaySec: number;
        withdrawTime: number;
    }>;
    getNonce(_sender: TAddress, key: bigint): Promise<bigint>;
    getSenderAddress(sender: TSender, initCode: TEth.Hex): Promise<TxWriter>;
    getUserOpHash(userOp: {
        sender: TAddress;
        nonce: bigint;
        initCode: TEth.Hex;
        callData: TEth.Hex;
        callGasLimit: bigint;
        verificationGasLimit: bigint;
        preVerificationGas: bigint;
        maxFeePerGas: bigint;
        maxPriorityFeePerGas: bigint;
        paymasterAndData: TEth.Hex;
        signature: TEth.Hex;
    }): Promise<TEth.Hex>;
    handleAggregatedOps(sender: TSender, opsPerAggregator: {
        userOps: {
            sender: TAddress;
            nonce: bigint;
            initCode: TEth.Hex;
            callData: TEth.Hex;
            callGasLimit: bigint;
            verificationGasLimit: bigint;
            preVerificationGas: bigint;
            maxFeePerGas: bigint;
            maxPriorityFeePerGas: bigint;
            paymasterAndData: TEth.Hex;
            signature: TEth.Hex;
        }[];
        aggregator: TAddress;
        signature: TEth.Hex;
    }[], beneficiary: TAddress): Promise<TxWriter>;
    handleOps(sender: TSender, ops: {
        sender: TAddress;
        nonce: bigint;
        initCode: TEth.Hex;
        callData: TEth.Hex;
        callGasLimit: bigint;
        verificationGasLimit: bigint;
        preVerificationGas: bigint;
        maxFeePerGas: bigint;
        maxPriorityFeePerGas: bigint;
        paymasterAndData: TEth.Hex;
        signature: TEth.Hex;
    }[], beneficiary: TAddress): Promise<TxWriter>;
    incrementNonce(sender: TSender, key: bigint): Promise<TxWriter>;
    innerHandleOp(sender: TSender, callData: TEth.Hex, opInfo: {
        mUserOp: {
            sender: TAddress;
            nonce: bigint;
            callGasLimit: bigint;
            verificationGasLimit: bigint;
            preVerificationGas: bigint;
            paymaster: TAddress;
            maxFeePerGas: bigint;
            maxPriorityFeePerGas: bigint;
        };
        userOpHash: TEth.Hex;
        prefund: bigint;
        contextOffset: bigint;
        preOpGas: bigint;
    }, context: TEth.Hex): Promise<TxWriter>;
    nonceSequenceNumber(input0: TAddress, input1: bigint): Promise<bigint>;
    simulateHandleOp(sender: TSender, op: {
        sender: TAddress;
        nonce: bigint;
        initCode: TEth.Hex;
        callData: TEth.Hex;
        callGasLimit: bigint;
        verificationGasLimit: bigint;
        preVerificationGas: bigint;
        maxFeePerGas: bigint;
        maxPriorityFeePerGas: bigint;
        paymasterAndData: TEth.Hex;
        signature: TEth.Hex;
    }, target: TAddress, targetCallData: TEth.Hex): Promise<TxWriter>;
    simulateValidation(sender: TSender, userOp: {
        sender: TAddress;
        nonce: bigint;
        initCode: TEth.Hex;
        callData: TEth.Hex;
        callGasLimit: bigint;
        verificationGasLimit: bigint;
        preVerificationGas: bigint;
        maxFeePerGas: bigint;
        maxPriorityFeePerGas: bigint;
        paymasterAndData: TEth.Hex;
        signature: TEth.Hex;
    }): Promise<TxWriter>;
    unlockStake(sender: TSender): Promise<TxWriter>;
    withdrawStake(sender: TSender, withdrawAddress: TAddress): Promise<TxWriter>;
    withdrawTo(sender: TSender, withdrawAddress: TAddress, withdrawAmount: bigint): Promise<TxWriter>;
    $call(): IEntryPointTxCaller;
    $signed(): TOverrideReturns<IEntryPointTxCaller, Promise<{
        signed: TEth.Hex;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    $data(): IEntryPointTxData;
    $gas(): TOverrideReturns<IEntryPointTxCaller, Promise<{
        gas?: bigint;
        price?: bigint;
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
    }>>;
    onTransaction<TMethod extends keyof TEntryPointTypes['Methods']>(method: TMethod, options: Parameters<ContractBase['$onTransaction']>[0]): SubjectStream<{
        tx: TEth.Tx;
        block: TEth.Block<TEth.Hex>;
        calldata: {
            method: TMethod;
            arguments: TEntryPointTypes['Methods'][TMethod]['arguments'];
        };
    }>;
    onLog(event: keyof TEvents, cb?: (event: TClientEventsStreamData) => void): ClientEventsStream<TClientEventsStreamData>;
    getPastLogs<TEventName extends keyof TEvents>(events: TEventName[], options?: TEventLogOptions<TEventParams<TEventName>>): Promise<ITxLogItem<TEventParams<TEventName>, TEventName>[]>;
    getPastLogs<TEventName extends keyof TEvents>(event: TEventName, options?: TEventLogOptions<TEventParams<TEventName>>): Promise<ITxLogItem<TEventParams<TEventName>, TEventName>[]>;
    onAccountDeployed(fn?: (event: TClientEventsStreamData<TEventArguments<'AccountDeployed'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'AccountDeployed'>>>;
    onBeforeExecution(fn?: (event: TClientEventsStreamData<TEventArguments<'BeforeExecution'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'BeforeExecution'>>>;
    onDeposited(fn?: (event: TClientEventsStreamData<TEventArguments<'Deposited'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'Deposited'>>>;
    onSignatureAggregatorChanged(fn?: (event: TClientEventsStreamData<TEventArguments<'SignatureAggregatorChanged'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'SignatureAggregatorChanged'>>>;
    onStakeLocked(fn?: (event: TClientEventsStreamData<TEventArguments<'StakeLocked'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'StakeLocked'>>>;
    onStakeUnlocked(fn?: (event: TClientEventsStreamData<TEventArguments<'StakeUnlocked'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'StakeUnlocked'>>>;
    onStakeWithdrawn(fn?: (event: TClientEventsStreamData<TEventArguments<'StakeWithdrawn'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'StakeWithdrawn'>>>;
    onUserOperationEvent(fn?: (event: TClientEventsStreamData<TEventArguments<'UserOperationEvent'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'UserOperationEvent'>>>;
    onUserOperationRevertReason(fn?: (event: TClientEventsStreamData<TEventArguments<'UserOperationRevertReason'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'UserOperationRevertReason'>>>;
    onWithdrawn(fn?: (event: TClientEventsStreamData<TEventArguments<'Withdrawn'>>) => void): ClientEventsStream<TClientEventsStreamData<TEventArguments<'Withdrawn'>>>;
    extractLogsAccountDeployed(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'AccountDeployed'>>[];
    extractLogsBeforeExecution(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'BeforeExecution'>>[];
    extractLogsDeposited(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'Deposited'>>[];
    extractLogsSignatureAggregatorChanged(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'SignatureAggregatorChanged'>>[];
    extractLogsStakeLocked(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'StakeLocked'>>[];
    extractLogsStakeUnlocked(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'StakeUnlocked'>>[];
    extractLogsStakeWithdrawn(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'StakeWithdrawn'>>[];
    extractLogsUserOperationEvent(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'UserOperationEvent'>>[];
    extractLogsUserOperationRevertReason(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'UserOperationRevertReason'>>[];
    extractLogsWithdrawn(tx: TEth.TxReceipt): ITxLogItem<TEventParams<'Withdrawn'>>[];
    getPastLogsAccountDeployed(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            userOpHash?: TEth.Hex;
            sender?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'AccountDeployed'>>[]>;
    getPastLogsBeforeExecution(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {};
    }): Promise<ITxLogItem<TEventParams<'BeforeExecution'>>[]>;
    getPastLogsDeposited(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            account?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'Deposited'>>[]>;
    getPastLogsSignatureAggregatorChanged(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            aggregator?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'SignatureAggregatorChanged'>>[]>;
    getPastLogsStakeLocked(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            account?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'StakeLocked'>>[]>;
    getPastLogsStakeUnlocked(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            account?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'StakeUnlocked'>>[]>;
    getPastLogsStakeWithdrawn(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            account?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'StakeWithdrawn'>>[]>;
    getPastLogsUserOperationEvent(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            userOpHash?: TEth.Hex;
            sender?: TAddress;
            paymaster?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'UserOperationEvent'>>[]>;
    getPastLogsUserOperationRevertReason(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            userOpHash?: TEth.Hex;
            sender?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'UserOperationRevertReason'>>[]>;
    getPastLogsWithdrawn(options?: {
        fromBlock?: number | Date;
        toBlock?: number | Date;
        params?: {
            account?: TAddress;
        };
    }): Promise<ITxLogItem<TEventParams<'Withdrawn'>>[]>;
    abi: TAbiItem[];
    storage: EntryPointStorageReader;
}
type TSender = TAccount & {
    value?: string | number | bigint;
};
type TEventLogOptions<TParams> = {
    fromBlock?: number | Date;
    toBlock?: number | Date;
    params?: TParams;
};
export type TEntryPointTypes = {
    Events: {
        AccountDeployed: {
            outputParams: {
                userOpHash: TEth.Hex;
                _sender: TAddress;
                factory: TAddress;
                paymaster: TAddress;
            };
            outputArgs: [userOpHash: TEth.Hex, _sender: TAddress, factory: TAddress, paymaster: TAddress];
        };
        BeforeExecution: {
            outputParams: {};
            outputArgs: [];
        };
        Deposited: {
            outputParams: {
                account: TAddress;
                totalDeposit: bigint;
            };
            outputArgs: [account: TAddress, totalDeposit: bigint];
        };
        SignatureAggregatorChanged: {
            outputParams: {
                aggregator: TAddress;
            };
            outputArgs: [aggregator: TAddress];
        };
        StakeLocked: {
            outputParams: {
                account: TAddress;
                totalStaked: bigint;
                unstakeDelaySec: bigint;
            };
            outputArgs: [account: TAddress, totalStaked: bigint, unstakeDelaySec: bigint];
        };
        StakeUnlocked: {
            outputParams: {
                account: TAddress;
                withdrawTime: bigint;
            };
            outputArgs: [account: TAddress, withdrawTime: bigint];
        };
        StakeWithdrawn: {
            outputParams: {
                account: TAddress;
                withdrawAddress: TAddress;
                amount: bigint;
            };
            outputArgs: [account: TAddress, withdrawAddress: TAddress, amount: bigint];
        };
        UserOperationEvent: {
            outputParams: {
                userOpHash: TEth.Hex;
                _sender: TAddress;
                paymaster: TAddress;
                nonce: bigint;
                success: boolean;
                actualGasCost: bigint;
                actualGasUsed: bigint;
            };
            outputArgs: [userOpHash: TEth.Hex, _sender: TAddress, paymaster: TAddress, nonce: bigint, success: boolean, actualGasCost: bigint, actualGasUsed: bigint];
        };
        UserOperationRevertReason: {
            outputParams: {
                userOpHash: TEth.Hex;
                _sender: TAddress;
                nonce: bigint;
                revertReason: TEth.Hex;
            };
            outputArgs: [userOpHash: TEth.Hex, _sender: TAddress, nonce: bigint, revertReason: TEth.Hex];
        };
        Withdrawn: {
            outputParams: {
                account: TAddress;
                withdrawAddress: TAddress;
                amount: bigint;
            };
            outputArgs: [account: TAddress, withdrawAddress: TAddress, amount: bigint];
        };
    };
    Methods: {
        SIG_VALIDATION_FAILED: {
            method: "SIG_VALIDATION_FAILED";
            arguments: [];
        };
        _validateSenderAndPaymaster: {
            method: "_validateSenderAndPaymaster";
            arguments: [initCode: TEth.Hex, _sender: TAddress, paymasterAndData: TEth.Hex];
        };
        addStake: {
            method: "addStake";
            arguments: [unstakeDelaySec: number];
        };
        balanceOf: {
            method: "balanceOf";
            arguments: [account: TAddress];
        };
        depositTo: {
            method: "depositTo";
            arguments: [account: TAddress];
        };
        deposits: {
            method: "deposits";
            arguments: [input0: TAddress];
        };
        getDepositInfo: {
            method: "getDepositInfo";
            arguments: [account: TAddress];
        };
        getNonce: {
            method: "getNonce";
            arguments: [_sender: TAddress, key: bigint];
        };
        getSenderAddress: {
            method: "getSenderAddress";
            arguments: [initCode: TEth.Hex];
        };
        getUserOpHash: {
            method: "getUserOpHash";
            arguments: [userOp: {
                sender: TAddress;
                nonce: bigint;
                initCode: TEth.Hex;
                callData: TEth.Hex;
                callGasLimit: bigint;
                verificationGasLimit: bigint;
                preVerificationGas: bigint;
                maxFeePerGas: bigint;
                maxPriorityFeePerGas: bigint;
                paymasterAndData: TEth.Hex;
                signature: TEth.Hex;
            }];
        };
        handleAggregatedOps: {
            method: "handleAggregatedOps";
            arguments: [opsPerAggregator: {
                userOps: {
                    sender: TAddress;
                    nonce: bigint;
                    initCode: TEth.Hex;
                    callData: TEth.Hex;
                    callGasLimit: bigint;
                    verificationGasLimit: bigint;
                    preVerificationGas: bigint;
                    maxFeePerGas: bigint;
                    maxPriorityFeePerGas: bigint;
                    paymasterAndData: TEth.Hex;
                    signature: TEth.Hex;
                }[];
                aggregator: TAddress;
                signature: TEth.Hex;
            }[], beneficiary: TAddress];
        };
        handleOps: {
            method: "handleOps";
            arguments: [ops: {
                sender: TAddress;
                nonce: bigint;
                initCode: TEth.Hex;
                callData: TEth.Hex;
                callGasLimit: bigint;
                verificationGasLimit: bigint;
                preVerificationGas: bigint;
                maxFeePerGas: bigint;
                maxPriorityFeePerGas: bigint;
                paymasterAndData: TEth.Hex;
                signature: TEth.Hex;
            }[], beneficiary: TAddress];
        };
        incrementNonce: {
            method: "incrementNonce";
            arguments: [key: bigint];
        };
        innerHandleOp: {
            method: "innerHandleOp";
            arguments: [callData: TEth.Hex, opInfo: {
                mUserOp: {
                    sender: TAddress;
                    nonce: bigint;
                    callGasLimit: bigint;
                    verificationGasLimit: bigint;
                    preVerificationGas: bigint;
                    paymaster: TAddress;
                    maxFeePerGas: bigint;
                    maxPriorityFeePerGas: bigint;
                };
                userOpHash: TEth.Hex;
                prefund: bigint;
                contextOffset: bigint;
                preOpGas: bigint;
            }, context: TEth.Hex];
        };
        nonceSequenceNumber: {
            method: "nonceSequenceNumber";
            arguments: [input0: TAddress, input1: bigint];
        };
        simulateHandleOp: {
            method: "simulateHandleOp";
            arguments: [op: {
                sender: TAddress;
                nonce: bigint;
                initCode: TEth.Hex;
                callData: TEth.Hex;
                callGasLimit: bigint;
                verificationGasLimit: bigint;
                preVerificationGas: bigint;
                maxFeePerGas: bigint;
                maxPriorityFeePerGas: bigint;
                paymasterAndData: TEth.Hex;
                signature: TEth.Hex;
            }, target: TAddress, targetCallData: TEth.Hex];
        };
        simulateValidation: {
            method: "simulateValidation";
            arguments: [userOp: {
                sender: TAddress;
                nonce: bigint;
                initCode: TEth.Hex;
                callData: TEth.Hex;
                callGasLimit: bigint;
                verificationGasLimit: bigint;
                preVerificationGas: bigint;
                maxFeePerGas: bigint;
                maxPriorityFeePerGas: bigint;
                paymasterAndData: TEth.Hex;
                signature: TEth.Hex;
            }];
        };
        unlockStake: {
            method: "unlockStake";
            arguments: [];
        };
        withdrawStake: {
            method: "withdrawStake";
            arguments: [withdrawAddress: TAddress];
        };
        withdrawTo: {
            method: "withdrawTo";
            arguments: [withdrawAddress: TAddress, withdrawAmount: bigint];
        };
    };
};
declare class EntryPointStorageReader extends ContractStorageReaderBase {
    address: TAddress;
    client: Web3Client;
    explorer: IBlockchainExplorer;
    constructor(address: TAddress, client: Web3Client, explorer: IBlockchainExplorer);
    deposits(key: TAddress): Promise<{
        deposit: bigint;
        staked: boolean;
        stake: bigint;
        unstakeDelaySec: number;
        withdrawTime: number;
    }>;
    nonceSequenceNumber(key: TAddress): Promise<Record<string | number, bigint>>;
    _status(): Promise<bigint>;
    $slots: {
        slot: number;
        position: number;
        name: string;
        size: number;
        type: string;
    }[];
}
interface IEntryPointTxCaller {
    addStake(sender: TSender, unstakeDelaySec: number): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    depositTo(sender: TSender, account: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    getSenderAddress(sender: TSender, initCode: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    handleAggregatedOps(sender: TSender, opsPerAggregator: {
        userOps: {
            sender: TAddress;
            nonce: bigint;
            initCode: TEth.Hex;
            callData: TEth.Hex;
            callGasLimit: bigint;
            verificationGasLimit: bigint;
            preVerificationGas: bigint;
            maxFeePerGas: bigint;
            maxPriorityFeePerGas: bigint;
            paymasterAndData: TEth.Hex;
            signature: TEth.Hex;
        }[];
        aggregator: TAddress;
        signature: TEth.Hex;
    }[], beneficiary: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    handleOps(sender: TSender, ops: {
        sender: TAddress;
        nonce: bigint;
        initCode: TEth.Hex;
        callData: TEth.Hex;
        callGasLimit: bigint;
        verificationGasLimit: bigint;
        preVerificationGas: bigint;
        maxFeePerGas: bigint;
        maxPriorityFeePerGas: bigint;
        paymasterAndData: TEth.Hex;
        signature: TEth.Hex;
    }[], beneficiary: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    incrementNonce(sender: TSender, key: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    innerHandleOp(sender: TSender, callData: TEth.Hex, opInfo: {
        mUserOp: {
            sender: TAddress;
            nonce: bigint;
            callGasLimit: bigint;
            verificationGasLimit: bigint;
            preVerificationGas: bigint;
            paymaster: TAddress;
            maxFeePerGas: bigint;
            maxPriorityFeePerGas: bigint;
        };
        userOpHash: TEth.Hex;
        prefund: bigint;
        contextOffset: bigint;
        preOpGas: bigint;
    }, context: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    simulateHandleOp(sender: TSender, op: {
        sender: TAddress;
        nonce: bigint;
        initCode: TEth.Hex;
        callData: TEth.Hex;
        callGasLimit: bigint;
        verificationGasLimit: bigint;
        preVerificationGas: bigint;
        maxFeePerGas: bigint;
        maxPriorityFeePerGas: bigint;
        paymasterAndData: TEth.Hex;
        signature: TEth.Hex;
    }, target: TAddress, targetCallData: TEth.Hex): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    simulateValidation(sender: TSender, userOp: {
        sender: TAddress;
        nonce: bigint;
        initCode: TEth.Hex;
        callData: TEth.Hex;
        callGasLimit: bigint;
        verificationGasLimit: bigint;
        preVerificationGas: bigint;
        maxFeePerGas: bigint;
        maxPriorityFeePerGas: bigint;
        paymasterAndData: TEth.Hex;
        signature: TEth.Hex;
    }): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    unlockStake(sender: TSender): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    withdrawStake(sender: TSender, withdrawAddress: TAddress): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
    withdrawTo(sender: TSender, withdrawAddress: TAddress, withdrawAmount: bigint): Promise<{
        error?: Error & {
            data?: {
                type: string;
                params: any;
            };
        };
        result?: any;
    }>;
}
interface IEntryPointTxData {
    addStake(sender: TSender, unstakeDelaySec: number): Promise<TEth.TxLike>;
    depositTo(sender: TSender, account: TAddress): Promise<TEth.TxLike>;
    getSenderAddress(sender: TSender, initCode: TEth.Hex): Promise<TEth.TxLike>;
    handleAggregatedOps(sender: TSender, opsPerAggregator: {
        userOps: {
            sender: TAddress;
            nonce: bigint;
            initCode: TEth.Hex;
            callData: TEth.Hex;
            callGasLimit: bigint;
            verificationGasLimit: bigint;
            preVerificationGas: bigint;
            maxFeePerGas: bigint;
            maxPriorityFeePerGas: bigint;
            paymasterAndData: TEth.Hex;
            signature: TEth.Hex;
        }[];
        aggregator: TAddress;
        signature: TEth.Hex;
    }[], beneficiary: TAddress): Promise<TEth.TxLike>;
    handleOps(sender: TSender, ops: {
        sender: TAddress;
        nonce: bigint;
        initCode: TEth.Hex;
        callData: TEth.Hex;
        callGasLimit: bigint;
        verificationGasLimit: bigint;
        preVerificationGas: bigint;
        maxFeePerGas: bigint;
        maxPriorityFeePerGas: bigint;
        paymasterAndData: TEth.Hex;
        signature: TEth.Hex;
    }[], beneficiary: TAddress): Promise<TEth.TxLike>;
    incrementNonce(sender: TSender, key: bigint): Promise<TEth.TxLike>;
    innerHandleOp(sender: TSender, callData: TEth.Hex, opInfo: {
        mUserOp: {
            sender: TAddress;
            nonce: bigint;
            callGasLimit: bigint;
            verificationGasLimit: bigint;
            preVerificationGas: bigint;
            paymaster: TAddress;
            maxFeePerGas: bigint;
            maxPriorityFeePerGas: bigint;
        };
        userOpHash: TEth.Hex;
        prefund: bigint;
        contextOffset: bigint;
        preOpGas: bigint;
    }, context: TEth.Hex): Promise<TEth.TxLike>;
    simulateHandleOp(sender: TSender, op: {
        sender: TAddress;
        nonce: bigint;
        initCode: TEth.Hex;
        callData: TEth.Hex;
        callGasLimit: bigint;
        verificationGasLimit: bigint;
        preVerificationGas: bigint;
        maxFeePerGas: bigint;
        maxPriorityFeePerGas: bigint;
        paymasterAndData: TEth.Hex;
        signature: TEth.Hex;
    }, target: TAddress, targetCallData: TEth.Hex): Promise<TEth.TxLike>;
    simulateValidation(sender: TSender, userOp: {
        sender: TAddress;
        nonce: bigint;
        initCode: TEth.Hex;
        callData: TEth.Hex;
        callGasLimit: bigint;
        verificationGasLimit: bigint;
        preVerificationGas: bigint;
        maxFeePerGas: bigint;
        maxPriorityFeePerGas: bigint;
        paymasterAndData: TEth.Hex;
        signature: TEth.Hex;
    }): Promise<TEth.TxLike>;
    unlockStake(sender: TSender): Promise<TEth.TxLike>;
    withdrawStake(sender: TSender, withdrawAddress: TAddress): Promise<TEth.TxLike>;
    withdrawTo(sender: TSender, withdrawAddress: TAddress, withdrawAmount: bigint): Promise<TEth.TxLike>;
}
type TEvents = TEntryPointTypes['Events'];
type TEventParams<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputParams']>;
type TEventArguments<TEventName extends keyof TEvents> = Partial<TEvents[TEventName]['outputArgs']>;
export {};