import type { Horizon, LogLevel } from './common.js';
import type { BigNumberish } from 'ethers';
export type DeliveryMode = 'realtime' | 'redrive' | 'backfill';
export type BackfillRequest<T = Record<string, any>> = {
    jobId: string;
    indexerId: string;
    logLevel: LogLevel;
    context: T;
};
export type EvmIngestedBlock = {
    number: number;
    hash: string;
    parentHash: string;
    nonce: string;
    sha3Uncles?: string;
    stateRoot?: string;
    receiptsRoot?: string;
    logsBloom?: string;
    miner?: string;
    extraData: string;
    size: number;
    gasLimit: string;
    gasUsed: string;
    baseFeePerGas: string;
    timestamp: number;
    transactions: string[];
    uncles?: string[];
    chainId: number;
    blockForkIndex: number;
    ingestionReceivedAt: number;
    delivery: DeliveryMode;
};
export type IngestedBlock = EvmIngestedBlock;
export type EvmIngestedTransaction = {
    blockNumber: number;
    blockHash: string;
    hash: string;
    to?: string;
    from?: string;
    nonce?: number;
    gasLimit?: string;
    gasPrice?: string;
    maxFeePerGas?: string;
    maxPriorityFeePerGas?: string;
    data?: string;
    value?: string;
    type?: number;
    accessList?: any[];
    status?: boolean;
    revertReason?: string;
    blockTimestamp: number;
    gasUsed?: BigNumberish;
    effectiveGasPrice?: BigNumberish;
    deployedContractAddress?: string;
    events?: EvmInlineEvent[];
    traces?: EvmInlineTrace[];
    chainId: number;
    blockForkIndex: number;
    indexerId?: string;
    filterGroupId?: string;
    createdAt?: number;
    ingestionReceivedAt: number;
};
export type IngestedTransaction = EvmIngestedTransaction;
export type EvmIngestedEvent = {
    blockNumber: `0x${string}`;
    blockHash: string;
    address: string;
    data?: string;
    logIndex: number;
    topics?: string[];
    transactionHash: string;
    transactionIndex: number;
    blockTimestamp: number;
    chainId: number;
    blockForkIndex: number;
    localIndex: number;
    ingestionReceivedAt: number;
    receivingEndpoint?: string;
    delivery: DeliveryMode;
};
export type IngestedEvent = EvmIngestedEvent;
export type EvmParsedCall<INPUT = Record<string, any> | any[], OUTPUT = Record<string, any> | any[]> = {
    name: string;
    sighash: string;
    input: INPUT;
    output?: OUTPUT;
};
export type EvmInlineEvent<TArgs = Record<string, any>> = {
    address: string;
    logIndex: number;
    topics?: string[];
    data?: string;
    eventName?: string;
    args?: TArgs;
};
export type EvmTraceType = 'call' | 'create' | 'suicide' | 'reward';
export type EvmTraceCallType = 'call' | 'create' | 'delegatecall' | 'staticcall';
export type EvmInlineTrace = {
    action: {
        from: string;
        callType: EvmTraceCallType;
        gas: string;
        input: string;
        to: string;
        value: string;
        parsed?: EvmParsedCall;
    };
    result: {
        gasUsed: string;
        output: string;
    };
    subtraces: number;
    traceAddress: number[];
    type: EvmTraceType;
    parsed?: EvmParsedCall;
};
export type EvmBlockReorg = {
    indexerId: string;
    chainId: number;
    forkIndex: number;
    newBlock: EvmIngestedBlock;
    detectedAt: number;
};
export type BlockReorg = EvmBlockReorg;
export type BlockHandlerInput<ContextType = Record<string, any>> = {
    block: EvmIngestedBlock;
    horizon: Horizon;
    backfill?: BackfillRequest<ContextType>;
};
export type TransactionHandlerInput<ContextType = Record<string, any>> = {
    transaction: EvmIngestedTransaction;
    horizon: Horizon;
    backfill?: BackfillRequest<ContextType>;
};
export type EventHandlerInput<ArgsType = Record<string, any>, ContextType = Record<string, any>> = {
    chainId: number;
    blockNumber: number;
    blockTimestamp: number;
    txHash: string;
    txIndex: number;
    log: EvmIngestedEvent;
    horizon: Horizon;
    parsed?: {
        name: string;
        topic: string;
        args: ArgsType;
    };
    abi?: Record<string, any>;
    backfill?: BackfillRequest<ContextType>;
};
export type ReorgHandlerInput<ContextType = Record<string, any>> = {
    reorg: EvmBlockReorg;
    horizon: Horizon;
    backfill?: BackfillRequest<ContextType>;
};
export type BlockProcessorHandlerObject = {
    processBlock: <TArgs>(input: BlockHandlerInput<TArgs>) => Promise<boolean | undefined>;
};
export type TransactionProcessorHandlerObject = {
    processTransaction: <TArgs>(input: TransactionHandlerInput<TArgs>) => Promise<boolean | undefined>;
};
export type EventProcessorHandlerObject = {
    processEvent: <TArgs, TContext>(input: EventHandlerInput<TArgs, TContext>) => Promise<boolean | undefined>;
};
export type ReorgProcessorHandlerObject = {
    processReorg: <TArgs>(input: ReorgHandlerInput<TArgs>) => Promise<boolean | undefined>;
};
export type EnricherHandlerInput<TData = Record<string, any>, TParams = Record<string, any>> = {
    data?: TData;
    parameters?: TParams;
};
export type EnricherHandlerObject = {
    handleInput: (<TData, TParams>(input: EnricherHandlerInput<TData, TParams>) => Promise<boolean | undefined>) | (<TData, TParams>(input: EnricherHandlerInput<TData, TParams>, callback: (result: undefined, error?: Error) => void) => void);
};
//# sourceMappingURL=ingestion.d.ts.map