import * as _solana_web3_js from '@solana/web3.js';
import { Connection, PublicKey } from '@solana/web3.js';
import { C as ChainClient, a as ChainConfig, T as TransferParams, E as ExecuteParams, B as BridgeParams, W as WebAuthnSignature, D as DispatchResult, V as VaultCreationResult } from '../../types-DP2CQT8p.mjs';

interface SolanaClientConfig {
    wormholeChainId: number;
    rpcUrl: string;
    programId: string;
    wormholeCoreBridge: string;
    tokenBridge: string;
    network?: 'mainnet' | 'devnet' | 'testnet';
    commitment?: 'processed' | 'confirmed' | 'finalized';
}
/**
 * Solana implementation of the ChainClient interface
 */
declare class SolanaClient implements ChainClient {
    private config;
    private connection;
    private programId;
    constructor(config: SolanaClientConfig);
    getConfig(): ChainConfig;
    getNonce(userKeyHash: string): Promise<bigint>;
    getMessageFee(): Promise<bigint>;
    buildTransferPayload(params: TransferParams): Promise<string>;
    buildExecutePayload(params: ExecuteParams): Promise<string>;
    buildBridgePayload(params: BridgeParams): Promise<string>;
    dispatch(signature: WebAuthnSignature, publicKeyX: bigint, publicKeyY: bigint, targetChain: number, actionPayload: string, nonce: bigint, signer: any): Promise<DispatchResult>;
    /**
     * Dispatch an action via relayer (gasless)
     * Note: On Solana, this still goes through the Hub chain
     * Solana is a spoke-only chain in Veridex architecture
     */
    dispatchGasless(signature: WebAuthnSignature, publicKeyX: bigint, publicKeyY: bigint, targetChain: number, actionPayload: string, nonce: bigint, relayerUrl: string): Promise<DispatchResult>;
    getVaultAddress(userKeyHash: string): Promise<string | null>;
    /**
     * Compute vault address using PDA (Program Derived Address)
     * Seeds: ["vault", userKeyHash]
     */
    computeVaultAddress(userKeyHash: string): string;
    private computeVaultAddressFromHash;
    vaultExists(userKeyHash: string): Promise<boolean>;
    createVault(userKeyHash: string, signer: any): Promise<VaultCreationResult>;
    createVaultSponsored?(userKeyHash: string, sponsorPrivateKey: string, rpcUrl?: string): Promise<VaultCreationResult>;
    /**
     * Create a vault via the relayer (sponsored/gasless)
     * This is the recommended way to create Solana vaults
     */
    createVaultViaRelayer(userKeyHash: string, relayerUrl: string): Promise<VaultCreationResult>;
    /**
     * Get vault info via relayer (includes existence check)
     */
    getVaultViaRelayer(userKeyHash: string, relayerUrl: string): Promise<{
        vaultAddress: string;
        exists: boolean;
    }>;
    estimateVaultCreationGas(userKeyHash: string): Promise<bigint>;
    getFactoryAddress(): string | undefined;
    getImplementationAddress(): string | undefined;
    /**
     * Get native SOL balance
     */
    getNativeBalance(address: string): Promise<bigint>;
    /**
     * Get SPL token balance
     */
    getTokenBalance(tokenAddress: string, ownerAddress: string): Promise<bigint>;
    /**
     * Compute key hash from public key coordinates
     * Matches EVM keccak256(abi.encode(publicKeyX, publicKeyY))
     */
    private computeKeyHash;
    /**
     * Build message for signing (matches Hub chain format)
     */
    private buildMessage;
    /**
     * Get connection instance for advanced usage
     */
    getConnection(): Connection;
    /**
     * Get program ID
     */
    getProgramId(): PublicKey;
    /**
     * Get current slot
     */
    getSlot(): Promise<number>;
    /**
     * Get transaction status
     */
    getTransaction(signature: string, commitment?: 'confirmed' | 'finalized'): Promise<_solana_web3_js.VersionedTransactionResponse | null>;
    /**
     * Check if a recovery VAA has been executed on this spoke
     *
     * @param vaaHash - Hash of the recovery VAA
     * @returns Whether the VAA has been processed
     */
    isRecoveryExecuted(vaaHash: string): Promise<boolean>;
    /**
     * Get vault owner after potential recovery
     *
     * @param vaultAddress - Vault address to check
     * @returns Current owner key hash
     */
    getVaultOwner(vaultAddress: string): Promise<string>;
    /**
     * Get authorized signers for a vault
     *
     * @param vaultAddress - Vault address to check
     * @returns Array of authorized signer key hashes
     */
    getAuthorizedSigners(vaultAddress: string): Promise<string[]>;
}

export { SolanaClient, type SolanaClientConfig };