import { RpcProvider } from "starknet";
import { PubKey } from "./types.js";
import { StarkPoint } from "./types.js";
import { AEBalance } from "./ae_balance.js";
export declare const ReaderEventType: {
    readonly Fund: "fund";
    readonly Withdraw: "withdraw";
    readonly Ragequit: "ragequit";
    readonly Rollover: "rollover";
    readonly TransferIn: "transferIn";
    readonly TransferOut: "transferOut";
    readonly BalanceDeclared: "balanceDeclared";
    readonly TransferDeclared: "transferDeclared";
};
type ReaderEventType = typeof ReaderEventType[keyof typeof ReaderEventType];
interface BaseEvent {
    type: ReaderEventType;
    tx_hash: string;
    block_number: number;
}
interface FundEventData {
    to: StarkPoint;
    nonce: bigint;
    amount: bigint;
}
interface WithdrawEventData {
    from: StarkPoint;
    nonce: bigint;
    amount: bigint;
    to: bigint;
}
interface RagequitEventData {
    from: StarkPoint;
    nonce: bigint;
    amount: bigint;
    to: bigint;
}
interface RolloverEventData {
    to: StarkPoint;
    nonce: bigint;
    rollovered: {
        L: StarkPoint;
        R: StarkPoint;
    };
}
interface TransferEventData {
    to: StarkPoint;
    from: StarkPoint;
    nonce: bigint;
    transferBalance: {
        L: StarkPoint;
        R: StarkPoint;
    };
    transferBalanceSelf: {
        L: StarkPoint;
        R: StarkPoint;
    };
    hintTransfer: AEBalance;
    hintLeftover: AEBalance;
}
interface BalanceDeclaredEventData {
    from: StarkPoint;
    nonce: bigint;
    auditorPubKey: StarkPoint;
    declaredCipherBalance: {
        L: StarkPoint;
        R: StarkPoint;
    };
    hint: AEBalance;
}
interface TransferDeclaredEventData {
    from: StarkPoint;
    to: StarkPoint;
    nonce: bigint;
    auditorPubKey: StarkPoint;
    declaredCipherBalance: {
        L: StarkPoint;
        R: StarkPoint;
    };
    hint: AEBalance;
}
type ReaderFundEvent = FundEventData & BaseEvent & {
    type: typeof ReaderEventType.Fund;
};
type ReaderWithdrawEvent = WithdrawEventData & BaseEvent & {
    type: typeof ReaderEventType.Withdraw;
};
type ReaderRagequitEvent = RagequitEventData & BaseEvent & {
    type: typeof ReaderEventType.Ragequit;
};
type ReaderRolloverEvent = RolloverEventData & BaseEvent & {
    type: typeof ReaderEventType.Rollover;
};
type ReaderTransferInEvent = TransferEventData & BaseEvent & {
    type: typeof ReaderEventType.TransferIn;
};
type ReaderTransferOutEvent = TransferEventData & BaseEvent & {
    type: typeof ReaderEventType.TransferOut;
};
type ReaderBalanceDeclaredEvent = BalanceDeclaredEventData & BaseEvent & {
    type: typeof ReaderEventType.BalanceDeclared;
};
type ReaderTransferDeclaredEvent = TransferDeclaredEventData & BaseEvent & {
    type: typeof ReaderEventType.TransferDeclared;
};
type ReaderEvent = ReaderFundEvent | ReaderWithdrawEvent | ReaderRagequitEvent | ReaderRolloverEvent | ReaderTransferInEvent | ReaderTransferOutEvent | ReaderBalanceDeclaredEvent | ReaderTransferDeclaredEvent;
export declare class StarknetEventReader {
    private readonly provider;
    private static readonly abiParser;
    private readonly abiParser;
    tongoAddress: string;
    constructor(provider: RpcProvider, tongoAddress: string);
    getEventsFund(initialBlock: number, otherPubKey: PubKey): Promise<ReaderFundEvent[]>;
    getEventsWithdraw(initialBlock: number, otherPubKey: PubKey): Promise<ReaderWithdrawEvent[]>;
    getEventsRagequit(initialBlock: number, otherPubKey: PubKey): Promise<ReaderRagequitEvent[]>;
    getEventsRollover(initialBlock: number, otherPubKey: PubKey): Promise<ReaderRolloverEvent[]>;
    getEventsTransferOut(initialBlock: number, otherPubKey: PubKey): Promise<ReaderTransferOutEvent[]>;
    getEventsTransferIn(initialBlock: number, otherPubKey: PubKey): Promise<ReaderTransferInEvent[]>;
    getAllEvents(initialBlock: number, otherPubKey: PubKey): Promise<ReaderEvent[]>;
    getEventsBalanceDeclared(initialBlock: number, otherPubKey: PubKey): Promise<ReaderBalanceDeclaredEvent[]>;
    getEventsTransferFrom(initialBlock: number, otherPubKey: PubKey): Promise<ReaderTransferDeclaredEvent[]>;
    getEventsTransferTo(initialBlock: number, otherPubKey: PubKey): Promise<ReaderTransferDeclaredEvent[]>;
}
export {};