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 RpiDenominationKindInput = {
    usd: Record<string, never>;
} | {
    mint: Record<string, never>;
};
export type RpiDenominationSpecInput = {
    denom: RpiDenominationKindInput;
    mint: PublicKey;
};
export type RpiRegisteredPositionTypeInput = {
    valued: Record<string, never>;
} | {
    tokenized: Record<string, never>;
};
export type RpiRegisteredSourceTypeInput = {
    trusted: Record<string, never>;
} | {
    native: Record<string, never>;
} | {
    wormhole: Record<string, never>;
};
export type RpiNativeCustodyKindInput = {
    splToken: Record<string, never>;
} | {
    nativeSol: Record<string, never>;
};
export type UpsertRegisteredPositionParams = {
    positionId: BufferLike32;
    positionType: RpiRegisteredPositionTypeInput;
    sourceType: RpiRegisteredSourceTypeInput;
    denomination: RpiDenominationSpecInput;
    nativeCustodyAccount?: PublicKey;
    nativeCustodyKind?: RpiNativeCustodyKindInput;
    enabled?: boolean;
    freshnessOverrideSecs?: number;
    submitAllowlist?: PublicKey[];
    validateAllowlist?: PublicKey[];
    configureAllowlist?: PublicKey[];
};
export type SubmitObservationParams = {
    positionId: BufferLike32;
    amount: BN;
    denomination: RpiDenominationSpecInput;
    observationTimestamp: BN;
    externalShares?: BN;
    reserved?: Uint8Array | number[] | Buffer;
};
export type ValidateObservationOracleAccounts = {
    glamConfig?: PublicKey | null;
    solUsdOracle?: PublicKey | null;
    baseAssetOracle?: PublicKey | null;
    observedMintOracle?: PublicKey | null;
};
export type ValidateObservationParams = {
    positionId: BufferLike32;
} & ValidateObservationOracleAccounts;
type ResolvedValidateObservationAccounts = Required<Omit<ValidateObservationOracleAccounts, "observedMintOracle">> & {
    remainingAccounts: AccountMeta[];
    kaminoReservesToRefresh: PublicKey[];
};
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 SubmitObservationWormholeParams = {
    positionId: BufferLike32;
    signedVaa: BufferLike;
    payloadConfigAccounts?: AccountMeta[];
    guardianSignatures?: Keypair;
    guardianSet?: PublicKey;
    wormholeCoreBridgeProgram?: PublicKey;
    wormholeVerifyVaaShimProgram?: PublicKey;
    maxSignaturesPerPost?: number;
};
export type SubmitObservationWormholeResult = {
    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<RpiClient> {
    upsertRegisteredPositionIx(params: UpsertRegisteredPositionParams, signer?: PublicKey): Promise<TransactionInstruction>;
    upsertRegisteredPositionWormholeConfigIx(params: WormholeObservationConfigInput, signer?: PublicKey): Promise<TransactionInstruction>;
    upsertRegisteredPositionWormholeHyperliquidConfigIx(params: WormholeHyperliquidObservationConfigInput, signer?: PublicKey): Promise<TransactionInstruction>;
    submitObservationIx(params: SubmitObservationParams, signer?: PublicKey): Promise<TransactionInstruction>;
    wormholePostSignaturesIx(parsedVaa: ParsedWormholeSignedVaa, guardianSignatures: PublicKey, payer?: PublicKey, signatures?: Buffer[], wormholeVerifyVaaShimProgram?: PublicKey): TransactionInstruction;
    wormholeCloseSignaturesIx(guardianSignatures: PublicKey, refundRecipient?: PublicKey, wormholeVerifyVaaShimProgram?: PublicKey): TransactionInstruction;
    submitObservationWormholeIx(params: SubmitObservationWormholeParams, guardianSignatures: PublicKey, signer?: PublicKey): Promise<TransactionInstruction>;
    validateObservationIx(paramsOrPositionId: BufferLike32 | ValidateObservationParams, signer?: PublicKey): Promise<TransactionInstruction>;
    private validateObservationIxWithAccounts;
    private refreshKaminoReserveOracleIxs;
    submitObservationTx(params: SubmitObservationParams, txOptions?: TxOptions): Promise<VersionedTransaction>;
    upsertRegisteredPositionTx(params: UpsertRegisteredPositionParams, txOptions?: TxOptions): Promise<VersionedTransaction>;
    removeRegisteredPositionTx(positionId: BufferLike32, txOptions?: TxOptions): Promise<VersionedTransaction>;
    upsertRegisteredPositionWormholeConfigTx(params: WormholeObservationConfigInput, txOptions?: TxOptions): Promise<VersionedTransaction>;
    upsertRegisteredPositionWormholeHyperliquidConfigTx(params: WormholeHyperliquidObservationConfigInput, txOptions?: TxOptions): Promise<VersionedTransaction>;
    submitObservationWormholeTx(params: SubmitObservationWormholeParams, guardianSignatures: PublicKey, txOptions?: TxOptions, closeSignatures?: boolean): Promise<VersionedTransaction>;
    validateObservationTx(paramsOrPositionId: BufferLike32 | ValidateObservationParams, txOptions?: TxOptions): Promise<VersionedTransaction>;
}
export declare class RpiClient {
    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>;
    submitObservation(params: SubmitObservationParams, txOptions?: TxOptions): Promise<TransactionSignature>;
    upsertRegisteredPosition(params: UpsertRegisteredPositionParams, txOptions?: TxOptions): Promise<TransactionSignature>;
    removeRegisteredPosition(positionId: BufferLike32, txOptions?: TxOptions): Promise<TransactionSignature>;
    upsertRegisteredPositionWormholeConfig(params: WormholeObservationConfigInput, txOptions?: TxOptions): Promise<TransactionSignature>;
    upsertRegisteredPositionWormholeHyperliquidConfig(params: WormholeHyperliquidObservationConfigInput, txOptions?: TxOptions): Promise<TransactionSignature>;
    submitObservationWormhole(params: SubmitObservationWormholeParams, txOptions?: TxOptions): Promise<SubmitObservationWormholeResult>;
    validateObservation(paramsOrPositionId: BufferLike32 | ValidateObservationParams, txOptions?: TxOptions): Promise<TransactionSignature>;
    resolveValidateObservationAccounts(params: ValidateObservationParams): Promise<ResolvedValidateObservationAccounts>;
}
export {};