import type { PublicKey } from '@metaplex-foundation/umi-public-keys';
import type { MaybeRpcAccount, RpcAccount } from './Account';
import { SolAmount } from './Amount';
import type { Cluster } from './Cluster';
import { DateTime } from './DateTime';
import type { GenericAbortSignal } from './GenericAbortSignal';
import type { Blockhash, BlockhashWithExpiryBlockHeight, Transaction, TransactionError, TransactionSignature, TransactionStatus, TransactionVersion, TransactionWithMeta } from './Transaction';
/**
 * Defines the interface for an RPC client.
 * It allows us to interact with the Solana blockchain.
 *
 * @category Context and Interfaces
 */
export interface RpcInterface {
    /** The RPC endpoint used by the client. */
    getEndpoint(): string;
    /** The Solana cluster of the RPC being used. */
    getCluster(): Cluster;
    /**
     * Fetch a raw account at the given address.
     *
     * @param publicKey The public key of the account to fetch.
     * @param options The options to use when fetching the account.
     * @returns A raw account that may or may not exist.
     */
    getAccount(publicKey: PublicKey, options?: RpcGetAccountOptions): Promise<MaybeRpcAccount>;
    /**
     * Fetch multiple raw accounts at the given addresses.
     *
     * @param publicKey The public keys of the accounts to fetch.
     * @param options The options to use when fetching multiple accounts.
     * @returns An array of raw accounts that may or may not exist.
     */
    getAccounts(publicKeys: PublicKey[], options?: RpcGetAccountsOptions): Promise<MaybeRpcAccount[]>;
    /**
     * Fetch multiple raw accounts from a program.
     *
     * @param programId The public key of the program to fetch accounts from.
     * @param options The options to use when fetching program accounts.
     * @returns An array of raw accounts.
     */
    getProgramAccounts(programId: PublicKey, options?: RpcGetProgramAccountsOptions): Promise<RpcAccount[]>;
    /**
     * Fetch the estimated production time of a block.
     *
     * @param slot The slot to get the estimated production time for.
     * @param options The options to use when getting the block time of a slot.
     * @returns The estimated production time of the block in Unix time.
     */
    getBlockTime(slot: number, options?: RpcGetBlockTimeOptions): Promise<DateTime | null>;
    /**
     * Fetch the balance of an account.
     *
     * @param publicKey The public key of the account.
     * @param options The options to use when fetching an account's balance.
     * @returns An amount of SOL.
     */
    getBalance(publicKey: PublicKey, options?: RpcGetBalanceOptions): Promise<SolAmount>;
    /**
     * Get the genesis hash.
     *
     * @returns The genesis hash.
     */
    getGenesisHash(): Promise<string>;
    /**
     * Get the amount of rent-exempt SOL required to create an account of the given size.
     *
     * @param bytes The size of the account in bytes.
     * @param options The options to use when fetching the rent exempt amount.
     * @returns An amount of SOL.
     */
    getRent(bytes: number, options?: RpcGetRentOptions): Promise<SolAmount>;
    /**
     * Fetch the recent slot.
     *
     * @param options The options to use when fetching the recent slot.
     * @returns The recent slot.
     */
    getSlot(options?: RpcGetSlotOptions): Promise<number>;
    /**
     * Fetch the latest blockhash.
     *
     * @param options The options to use when fetching the latest blockhash.
     * @returns The latest blockhash and its block height.
     */
    getLatestBlockhash(options?: RpcGetLatestBlockhashOptions): Promise<BlockhashWithExpiryBlockHeight>;
    /**
     * Fetch a transaction by its signature.
     *
     * @param signature The signature of the transaction to fetch.
     * @param options The options to use when fetching transactions.
     * @returns A transaction with its metadata or `null` if the transaction was not found.
     */
    getTransaction(signature: TransactionSignature, options?: RpcGetTransactionOptions): Promise<(TransactionWithMeta & RpcGetTransactionResponseOther) | null>;
    /**
     * Fetch transaction commitments from an array of signatures.
     *
     * @param signatures The signatures of all transactions we want to fetch commitments for.
     * @param options The options to use when fetching transaction commitments.
     * @returns An array of transaction statuses in the same order as the signatures.
     * If a transaction was not found, `null` will be returned instead.
     */
    getSignatureStatuses(signatures: TransactionSignature[], options?: RpcGetSignatureStatusesOptions): Promise<Array<TransactionStatus | null>>;
    /**
     * Whether or not an account at a given address exists.
     *
     * @param publicKey The public key of the account.
     * @param options The options to use when checking if an account exists.
     * @returns `true` if the account exists, `false` otherwise.
     */
    accountExists(publicKey: PublicKey, options?: RpcAccountExistsOptions): Promise<boolean>;
    /**
     * Send and confirm an airdrop transaction to the given address.
     *
     * @param publicKey The public key of the account to airdrop to.
     * @param amount The amount of SOL to airdrop.
     * @param options The options to use when airdropping SOL.
     */
    airdrop(publicKey: PublicKey, amount: SolAmount, options?: RpcAirdropOptions): Promise<void>;
    /**
     * Send a custom RPC request to the node.
     *
     * @param method The method to call.
     * @param params The parameters to pass to the method. Can be either:
     *               - An array for positional parameters
     *               - An object for named parameters
     * @param options The options to use when sending a custom RPC request.
     * @returns The generic result of the RPC call.
     */
    call<R, P extends any[] | Record<string, any> = any[]>(method: string, params?: P, options?: RpcCallOptions): Promise<R>;
    /**
     * Send a transaction to the blockchain.
     *
     * @param transaction The transaction to send.
     * @param options The options to use when sending a transaction.
     * @returns The signature of the sent transaction.
     */
    sendTransaction(transaction: Transaction, options?: RpcSendTransactionOptions): Promise<TransactionSignature>;
    /**
     * Simulate a transaction.
     *
     * @param transaction The transaction to simulate.
     * @param options The options to use when simulating a transaction.
     * @returns The signature of the sent transaction.
     */
    simulateTransaction(transaction: Transaction, options?: RpcSimulateTransactionOptions): Promise<RpcSimulateTransactionResult>;
    /**
     * Confirm a sent transaction.
     *
     * @param signature The signature of the transaction to confirm.
     * @param options The options to use when confirming a transaction.
     * @returns The RPC response of the transaction confirmation.
     */
    confirmTransaction(signature: TransactionSignature, options: RpcConfirmTransactionOptions): Promise<RpcConfirmTransactionResult>;
}
/**
 * The various commitment levels when fetching data from the blockchain.
 * @category Rpc
 */
export type Commitment = 'processed' | 'confirmed' | 'finalized';
/**
 * An object to request a slice of data starting
 * at `offset` and ending at `offset + length`.
 * @category Rpc
 */
export type RpcDataSlice = {
    offset: number;
    length: number;
};
/**
 * Defines a filter to use when fetching program accounts.
 * @category Rpc
 */
export type RpcDataFilter = RpcDataFilterSize | RpcDataFilterMemcmp;
/**
 * Defines a filter that selects accounts by size.
 * @category Rpc
 */
export type RpcDataFilterSize = {
    dataSize: number;
};
/**
 * Defines a filter that selects accounts by comparing
 * the given bytes at the given offset.
 * @category Rpc
 */
export type RpcDataFilterMemcmp = {
    memcmp: {
        offset: number;
        bytes: Uint8Array;
    };
};
/**
 * Defines an RPC result that wraps the returned value
 * and provides the slot number as context.
 * @category Rpc
 */
export type RpcResultWithContext<Value> = {
    context: {
        slot: number;
    };
    value: Value;
};
/**
 * Defines the common options re-used by all
 * the methods defines in the RPC interface.
 * @category Rpc
 */
export type RpcBaseOptions = {
    /** An explicit RPC request identifier. */
    id?: string;
    /** An abort signal to prematurely cancel the request. */
    signal?: GenericAbortSignal;
    /** The commitment level to use when fetching data. */
    commitment?: Commitment;
    /** The minimum slot to use when fetching data. */
    minContextSlot?: number;
};
/**
 * The options to use when fetching an account.
 * @category Rpc
 */
export type RpcGetAccountOptions = RpcBaseOptions & {
    /** Select only a portion of the account's data. */
    dataSlice?: RpcDataSlice;
};
/**
 * The options to use when fetching multiple accounts.
 * @category Rpc
 */
export type RpcGetAccountsOptions = RpcBaseOptions & {
    /** For each account, select only a portion of their data. */
    dataSlice?: RpcDataSlice;
};
/**
 * The options to use when fetching program accounts.
 * @category Rpc
 */
export type RpcGetProgramAccountsOptions = RpcBaseOptions & {
    /** For each program account, select only a portion of their data. */
    dataSlice?: RpcDataSlice;
    /** A set of filters to narrow down the returned program accounts. Max 5 filters. */
    filters?: RpcDataFilter[];
};
/**
 * The options to use when fetching a block.
 * @category Rpc
 */
export type RpcGetVersionedBlockOptions = RpcBaseOptions & {
    /** The level of finality desired */
    commitment?: Commitment;
    maxSupportedTransactionVersion?: number;
    rewards?: boolean;
    transactionDetails?: 'accounts' | 'full' | 'none' | 'signatures';
};
/**
 * The options to use when getting the block time of a slot.
 * @category Rpc
 */
export type RpcGetBlockTimeOptions = RpcBaseOptions;
/**
 * The options to use when fetching the balance of an account.
 * @category Rpc
 */
export type RpcGetBalanceOptions = RpcBaseOptions;
/**
 * The options to use when fetching the rent exempt amount.
 * @category Rpc
 */
export type RpcGetRentOptions = RpcBaseOptions & {
    /** @defaultValue `false` */
    includesHeaderBytes?: boolean;
};
/**
 * The options to use when fetching the recent slot.
 * @category Rpc
 */
export type RpcGetSlotOptions = RpcBaseOptions;
/**
 * The options to use when fetching the latest blockhash.
 * @category Rpc
 */
export type RpcGetLatestBlockhashOptions = RpcBaseOptions;
/**
 * The options to use when fetching a transaction.
 * @category Rpc
 */
export type RpcGetTransactionOptions = RpcBaseOptions;
/**
 * The other fields of getTransaction response.
 * @category Rpc
 */
export type RpcGetTransactionResponseOther = {
    response: {
        blockTime?: bigint;
        slot: bigint;
        version?: TransactionVersion;
    };
};
/**
 * The options to use when fetching transaction statuses.
 * @category Rpc
 */
export type RpcGetSignatureStatusesOptions = RpcBaseOptions & {
    /**
     * Enable searching status history, not needed for recent transactions.
     * @defaultValue `false`
     */
    searchTransactionHistory?: boolean;
};
/**
 * The options to use when checking if an account exists.
 * @category Rpc
 */
export type RpcAccountExistsOptions = RpcBaseOptions;
/**
 * The options to use when airdropping SOL.
 * @category Rpc
 */
export type RpcAirdropOptions = Partial<RpcConfirmTransactionOptions>;
/**
 * The options to use when sending a custom RPC request.
 * @category Rpc
 */
export type RpcCallOptions = RpcBaseOptions & {
    /**
     * By default, the RPC client pushes an additional `options`
     * parameter to the RPC request when a commitment is specified.
     * This `extra` parameter can be used to add more data to the
     * `options` parameter.
     */
    extra?: object;
};
/**
 * The options to use when sending a transaction.
 * @category Rpc
 */
export type RpcSendTransactionOptions = RpcBaseOptions & {
    /** Whether to skip the preflight check. */
    skipPreflight?: boolean;
    /** The commitment level to use for the preflight check. */
    preflightCommitment?: Commitment;
    /** The maximum number of retries to use. */
    maxRetries?: number;
};
/**
 * The options to use when simulating a transaction.
 * @category Rpc
 */
export type RpcSimulateTransactionOptions = RpcBaseOptions & {
    /** Optional parameter used to specify a list of base58-encoded account addresses to return post simulation state */
    accounts?: PublicKey[];
    /** Optional parameter used to enable signature verification before simulation */
    verifySignatures?: boolean;
    /** Optional parameter used to replace the transaction's recent blockhash with the latest blockhash */
    replaceRecentBlockhash?: boolean;
};
/**
 * The options to use when confirming a transaction.
 * @category Rpc
 */
export type RpcConfirmTransactionOptions = RpcBaseOptions & {
    /** The confirm strategy to use. */
    strategy: RpcConfirmTransactionStrategy;
};
/**
 * Represents all the possible strategies to use when confirming a transaction.
 * @category Rpc
 */
export type RpcConfirmTransactionStrategy = {
    type: 'blockhash';
    blockhash: Blockhash;
    lastValidBlockHeight: number;
} | {
    type: 'durableNonce';
    minContextSlot: number;
    nonceAccountPubkey: PublicKey;
    nonceValue: string;
};
/**
 * Defines the result of a transaction simulation.
 * @category Rpc
 */
export type RpcSimulateTransactionResult = {
    err: TransactionError | null;
    unitsConsumed?: number;
    logs: Array<string> | null;
    accounts?: Array<RpcSimulateTransactionAccountInfo | null> | null;
    returnData?: RpcSimulateTransactionTransactionReturnData | null;
    replacementBlockhash?: RpcSimulateTransactionReplacementBlockhash | null;
};
/**
 * Defines the result of a transaction simulation accounts info.
 * @category Rpc
 */
export type RpcSimulateTransactionAccountInfo = {
    executable: boolean;
    owner: string;
    lamports: number;
    data: string[];
    rentEpoch?: number;
};
/**
 * Defines the result of a transaction confirmation.
 * @category Rpc
 */
export type RpcConfirmTransactionResult = RpcResultWithContext<{
    err: TransactionError | null;
}>;
/**
 * Defines the Transaction Return Data from Simulate Transaction.
 * @category Rpc
 */
export type RpcSimulateTransactionTransactionReturnData = {
    data: [string, 'base64'];
    programId: string;
};
/**
 * Defines the replacement blockhash information returned when replaceRecentBlockhash is used.
 * @category Rpc
 */
export type RpcSimulateTransactionReplacementBlockhash = {
    /** The replacement blockhash used for simulation */
    blockhash: string;
    /** The last valid block height for the replacement blockhash */
    lastValidBlockHeight: bigint;
};
/**
 * An implementation of the {@link RpcInterface} that throws an error when called.
 * @category Rpc
 */
export declare function createNullRpc(): RpcInterface;
