import { BN } from "@coral-xyz/anchor";
import { PublicKey, AccountMeta, Keypair, TransactionInstruction, TransactionSignature, VersionedTransaction } from "@solana/web3.js";
import { BaseClient, BaseTxBuilder, TxOptions } from "./base";
type BufferLike = Uint8Array | number[] | Buffer;
type BufferLike32 = BufferLike;
type BufferLike20 = BufferLike;
export type EpiDenominationKindInput = {
    usd: Record<string, never>;
} | {
    mint: Record<string, never>;
};
export type EpiDenominationSpecInput = {
    denom: EpiDenominationKindInput;
    mint: PublicKey;
};
export type EpiExternalPositionTypeInput = {
    valued: Record<string, never>;
} | {
    tokenized: Record<string, never>;
};
export type EpiExternalSourceTypeInput = {
    trusted: Record<string, never>;
} | {
    native: Record<string, never>;
} | {
    wormhole: Record<string, never>;
};
export type EpiNativeCustodyKindInput = {
    splToken: Record<string, never>;
} | {
    nativeSol: Record<string, never>;
};
export type UpsertExternalPositionParams = {
    positionId: BufferLike32;
    positionType: EpiExternalPositionTypeInput;
    sourceType: EpiExternalSourceTypeInput;
    denomination: EpiDenominationSpecInput;
    nativeCustodyAccount?: PublicKey;
    nativeCustodyKind?: EpiNativeCustodyKindInput;
    enabled?: boolean;
    freshnessOverrideSecs?: number;
    submitAllowlist?: PublicKey[];
    validateAllowlist?: PublicKey[];
    configureAllowlist?: PublicKey[];
};
export type SubmitExternalObservationParams = {
    positionId: BufferLike32;
    amount: BN;
    denomination: EpiDenominationSpecInput;
    observationTimestamp: BN;
    externalShares?: BN;
    reserved?: Uint8Array | number[] | Buffer;
};
export type ValidateExternalObservationOracleAccounts = {
    glamConfig?: PublicKey | null;
    solUsdOracle?: PublicKey | null;
    baseAssetOracle?: PublicKey | null;
    observedMintOracle?: PublicKey | null;
};
export type ValidateExternalObservationParams = {
    positionId: BufferLike32;
} & ValidateExternalObservationOracleAccounts;
export type WormholeObservationConfigInput = {
    positionId: BufferLike32;
    emitterChain: number;
    emitterAddress: BufferLike32;
    payloadVersion: number;
    payloadType: number;
    maxAgeSeconds: number;
};
export type WormholeHyperliquidObservationConfigInput = {
    positionId: BufferLike32;
    hyperliquidAccount: BufferLike20;
    accountMarginSummaryPrecompile: BufferLike20;
    spotBalancePrecompile: BufferLike20;
    perpDexIndex: number;
    usdcSpotToken: BN;
};
export type SubmitExternalObservationWormholeParams = {
    positionId: BufferLike32;
    signedVaa: BufferLike;
    payloadConfigAccounts?: AccountMeta[];
    guardianSignatures?: Keypair;
    guardianSet?: PublicKey;
    wormholeCoreBridgeProgram?: PublicKey;
    wormholeVerifyVaaShimProgram?: PublicKey;
    maxSignaturesPerPost?: number;
};
export type SubmitExternalObservationWormholeResult = {
    postSignatureTxs: TransactionSignature[];
    submitTx: TransactionSignature;
    guardianSignatures: PublicKey;
};
export type ParsedWormholeSignedVaa = {
    version: number;
    guardianSetIndex: number;
    signatures: Buffer[];
    vaaBody: Buffer;
};
export declare function evmAddressToBytes20(address: string): number[];
export declare function evmAddressToWormholeEmitterAddress(address: string): number[];
export declare function parseWormholeSignedVaa(signedVaa: BufferLike): ParsedWormholeSignedVaa;
export declare function getWormholeGuardianSetPda(guardianSetIndex: number, wormholeCoreBridgeProgram?: PublicKey): [PublicKey, number];
declare class TxBuilder extends BaseTxBuilder<EpiClient> {
    upsertExternalPositionIx(params: UpsertExternalPositionParams, signer?: PublicKey): Promise<TransactionInstruction>;
    upsertExternalPositionWormholeConfigIx(params: WormholeObservationConfigInput, signer?: PublicKey): Promise<TransactionInstruction>;
    upsertExternalPositionWormholeHyperliquidConfigIx(params: WormholeHyperliquidObservationConfigInput, signer?: PublicKey): Promise<TransactionInstruction>;
    submitExternalObservationIx(params: SubmitExternalObservationParams, signer?: PublicKey): Promise<TransactionInstruction>;
    wormholePostSignaturesIx(parsedVaa: ParsedWormholeSignedVaa, guardianSignatures: PublicKey, payer?: PublicKey, signatures?: Buffer[], wormholeVerifyVaaShimProgram?: PublicKey): TransactionInstruction;
    wormholeCloseSignaturesIx(guardianSignatures: PublicKey, refundRecipient?: PublicKey, wormholeVerifyVaaShimProgram?: PublicKey): TransactionInstruction;
    submitExternalObservationWormholeIx(params: SubmitExternalObservationWormholeParams, guardianSignatures: PublicKey, signer?: PublicKey): Promise<TransactionInstruction>;
    validateExternalObservationIx(paramsOrPositionId: BufferLike32 | ValidateExternalObservationParams, signer?: PublicKey): Promise<TransactionInstruction>;
    refreshPricedProtocolIx(signer?: PublicKey): Promise<TransactionInstruction>;
    submitExternalObservationTx(params: SubmitExternalObservationParams, txOptions?: TxOptions): Promise<VersionedTransaction>;
    upsertExternalPositionTx(params: UpsertExternalPositionParams, txOptions?: TxOptions): Promise<VersionedTransaction>;
    removeExternalPositionTx(positionId: BufferLike32, txOptions?: TxOptions): Promise<VersionedTransaction>;
    upsertExternalPositionWormholeConfigTx(params: WormholeObservationConfigInput, txOptions?: TxOptions): Promise<VersionedTransaction>;
    upsertExternalPositionWormholeHyperliquidConfigTx(params: WormholeHyperliquidObservationConfigInput, txOptions?: TxOptions): Promise<VersionedTransaction>;
    submitExternalObservationWormholeTx(params: SubmitExternalObservationWormholeParams, guardianSignatures: PublicKey, txOptions?: TxOptions, closeSignatures?: boolean): Promise<VersionedTransaction>;
    validateExternalObservationTx(paramsOrPositionId: BufferLike32 | ValidateExternalObservationParams, txOptions?: TxOptions): Promise<VersionedTransaction>;
    refreshPricedProtocolTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
}
export declare class EpiClient {
    readonly base: BaseClient;
    readonly txBuilder: TxBuilder;
    constructor(base: BaseClient);
    getObservationStatePda(): PublicKey;
    getWormholeObservationConfigPda(positionId: BufferLike32): PublicKey;
    getWormholeHyperliquidObservationConfigPda(positionId: BufferLike32): PublicKey;
    getIntegrationAuthorityPda(): PublicKey;
    fetchObservationState(): Promise<{
        glamState: PublicKey;
        bump: number;
        positionsLen: number;
        reserved: number[];
        positions: {
            positionId: number[];
            hasPending: boolean;
            padPending: number[];
            pendingObservation: {
                amount: {
                    bytes: number[];
                };
                denomination: {
                    denom: ({
                        usd?: undefined;
                    } & {
                        mint: Record<string, never>;
                    }) | ({
                        mint?: undefined;
                    } & {
                        usd: Record<string, never>;
                    });
                    mint: PublicKey;
                };
                padDenom: number[];
                observationTimestamp: BN;
                externalShares: BN;
                submittedBy: PublicKey;
                submittedAtSlot: BN;
            };
            hasValidated: boolean;
            padValidated: number[];
            lastValidatedObservation: {
                amount: {
                    bytes: number[];
                };
                denomination: {
                    denom: ({
                        usd?: undefined;
                    } & {
                        mint: Record<string, never>;
                    }) | ({
                        mint?: undefined;
                    } & {
                        usd: Record<string, never>;
                    });
                    mint: PublicKey;
                };
                padDenom: number[];
                observationTimestamp: BN;
                externalShares: BN;
                submittedBy: PublicKey;
                submittedAtSlot: BN;
            };
            validatedBy: PublicKey;
            validatedAtSlot: BN;
            validatedBaseAssetAmount: {
                bytes: number[];
            };
        }[];
    } | null>;
    fetchWormholeObservationConfig(positionId: BufferLike32): Promise<{
        glamState: PublicKey;
        positionId: number[];
        emitterChain: number;
        emitterAddress: number[];
        payloadVersion: number;
        payloadType: number;
        maxAgeSeconds: number;
        hasLastSequence: boolean;
        lastSequence: BN;
        lastVaaHash: number[];
        bump: number;
    } | null>;
    fetchWormholeHyperliquidObservationConfig(positionId: BufferLike32): Promise<{
        glamState: PublicKey;
        positionId: number[];
        hyperliquidAccount: number[];
        accountMarginSummaryPrecompile: number[];
        spotBalancePrecompile: number[];
        perpDexIndex: number;
        usdcSpotToken: BN;
        bump: number;
    } | null>;
    submitExternalObservation(params: SubmitExternalObservationParams, txOptions?: TxOptions): Promise<TransactionSignature>;
    upsertExternalPosition(params: UpsertExternalPositionParams, txOptions?: TxOptions): Promise<TransactionSignature>;
    removeExternalPosition(positionId: BufferLike32, txOptions?: TxOptions): Promise<TransactionSignature>;
    upsertExternalPositionWormholeConfig(params: WormholeObservationConfigInput, txOptions?: TxOptions): Promise<TransactionSignature>;
    upsertExternalPositionWormholeHyperliquidConfig(params: WormholeHyperliquidObservationConfigInput, txOptions?: TxOptions): Promise<TransactionSignature>;
    submitExternalObservationWormhole(params: SubmitExternalObservationWormholeParams, txOptions?: TxOptions): Promise<SubmitExternalObservationWormholeResult>;
    validateExternalObservation(paramsOrPositionId: BufferLike32 | ValidateExternalObservationParams, txOptions?: TxOptions): Promise<TransactionSignature>;
    resolveValidateExternalObservationAccounts(params: ValidateExternalObservationParams): Promise<Required<Omit<ValidateExternalObservationOracleAccounts, "observedMintOracle">> & {
        remainingAccounts: AccountMeta[];
    }>;
    refreshPricedProtocol(txOptions?: TxOptions): Promise<TransactionSignature>;
}
export {};