import { Connection, Keypair, PublicKey, Transaction, VersionedTransaction } from "@solana/web3.js";
import { VM } from "../vm";
import { ChainAddress, ChainWallet } from "../IChainWallet";
import { Balance, ChainWalletConfig, UserTokenBalance, TokenInfo, TransactionResult, NFT, WalletDiscoveryOptions, WalletDiscoveryResult, PocketDiscoveryOptions } from "../types";
import { JupiterQuoteResponse } from "./utils";
import { PriceResponse } from "../price.types";
import { SVMTransactionHistoryItem } from "./transactionParsing";
export declare const createSvmConnection: (config: ChainWalletConfig) => Connection;
export declare const getSvmNativeBalanceForAddress: (address: PublicKey, connection: Connection) => Promise<Balance>;
export declare const getSvmTokenBalanceForAddress: (address: PublicKey, tokenAddress: PublicKey, connection: Connection) => Promise<Balance>;
export declare const discoverSvmTokens: (address: PublicKey, connection: Connection) => Promise<UserTokenBalance<PublicKey>[]>;
export declare const discoverSvmNFTs: (address: PublicKey, connection: Connection) => Promise<NFT[]>;
export declare const getSvmTransactionHistoryForAddress: (connection: Connection, address: PublicKey) => Promise<SVMTransactionHistoryItem[]>;
export declare const getSvmPricesForTokens: (config: ChainWalletConfig, tokenAddresses: string[]) => Promise<PriceResponse>;
export declare class SVMVM extends VM<PublicKey, Keypair, Connection> {
    getTokenInfo: (tokenAddress: PublicKey, connection: Connection, programId?: PublicKey) => Promise<TokenInfo>;
    static getTokenInfo: (tokenAddress: PublicKey, connection: Connection, programId?: PublicKey) => Promise<TokenInfo>;
    static validateAddress(address: PublicKey): boolean;
    derivationPath: string;
    constructor(seed: string);
    static getNativeBalance(address: PublicKey, connection: Connection): Promise<Balance>;
    static getTokenBalance(address: PublicKey, tokenAddress: PublicKey, connection: Connection): Promise<Balance>;
    static generateMnemonicFromPrivateKey(privateKey: Keypair): string;
    static signAndSendTransaction: (transaction: VersionedTransaction | Transaction, connection: Connection, signers: Keypair, options?: {
        partialSign?: boolean;
        feePayerSigner?: Keypair;
    }) => Promise<string>;
    static signTransaction: (transaction: VersionedTransaction | Transaction, signers: Keypair) => Promise<VersionedTransaction | Transaction>;
    static sendTransaction: (transaction: VersionedTransaction | Transaction, connection: Connection) => Promise<string>;
    static convertFromEntropyToPrivateKey: (entropy: string) => Keypair;
    generatePrivateKey(index: number, seed?: string, mnemonic?: string, derivationPath?: string): {
        privateKey: Keypair;
        index: number;
    };
    static fromMnemonic(mnemonic: string): VM<PublicKey, Keypair, Connection>;
    deriveSavingsAccount(accountIndex: number): {
        privateKey: Keypair;
        address: PublicKey;
        derivationPath: string;
    };
    discoverWallets(connection: Connection, options?: WalletDiscoveryOptions): Promise<WalletDiscoveryResult>;
    private checkWalletBalance;
    private sleep;
    discoverPockets(connection: Connection, options?: PocketDiscoveryOptions): Promise<WalletDiscoveryResult>;
    private checkPocketBalance;
}
export declare class SVMChainAddress extends ChainAddress<PublicKey, Connection> {
    constructor(config: ChainWalletConfig, address: PublicKey, index?: number);
    getNativeBalance(): Promise<Balance>;
    getTokenBalance(tokenAddress: PublicKey): Promise<Balance>;
    discoverToken(): Promise<UserTokenBalance<PublicKey>[]>;
    discoverNFT(): Promise<NFT[]>;
    getTransactionHistory(): Promise<SVMTransactionHistoryItem[]>;
    getPrices(tokenAddresses: string[]): Promise<PriceResponse>;
}
export declare class SVMChainWallet extends ChainWallet<PublicKey, Keypair, Connection> {
    constructor(config: ChainWalletConfig, privateKey: Keypair, index: number);
    generateAddress(): PublicKey;
    convertFromEntropyToPrivateKey: (entropy: string) => Keypair;
    getNativeBalance(): Promise<Balance>;
    getTokenBalance(tokenAddress: PublicKey): Promise<Balance>;
    discoverToken(): Promise<UserTokenBalance<PublicKey>[]>;
    discoverNFT(): Promise<NFT[]>;
    transferNative(to: PublicKey, amount: number): Promise<TransactionResult>;
    transferToken(token: TokenInfo, to: PublicKey, amount: number): Promise<TransactionResult>;
    signTransaction(transaction: VersionedTransaction | Transaction): Promise<VersionedTransaction | Transaction>;
    sendTransaction(transaction: VersionedTransaction | Transaction): Promise<string>;
    signAndSendTransaction(transaction: VersionedTransaction | Transaction): Promise<string>;
    getTransactionHistory(): Promise<SVMTransactionHistoryItem[]>;
    estimateGas(transaction: VersionedTransaction | Transaction): Promise<number>;
    private extractComputeBudgetDetails;
    private readU32LE;
    private readU64LE;
    private ceilDiv;
    getTokenInfo(tokenAddress: PublicKey): Promise<TokenInfo>;
    getPrices(tokenAddresses: string[]): Promise<PriceResponse>;
    swap(fromToken: TokenInfo, toToken: PublicKey, amount: number, slippage?: number): Promise<TransactionResult>;
    getSwapQuote(fromToken: TokenInfo, toToken: PublicKey, amount: number, slippage?: number): Promise<{
        success: boolean;
        inputAmount?: string;
        outputAmount?: string;
        priceImpact?: string;
        routePlan?: JupiterQuoteResponse['routePlan'];
        slippageBps?: number;
        error?: string;
    }>;
    signMessage: (message: Uint8Array<ArrayBuffer>) => Uint8Array<ArrayBufferLike>;
}