/**
 * @prettier
 */
/// <reference types="node" />
import { BaseCoin as StaticsBaseCoin, CoinFamily } from '@bitgo-beta/statics';
import { BaseCoin, BitGoBase, KeyPair, Memo, MPCAlgorithm, ParsedTransaction, ParseTransactionOptions as BaseParseTransactionOptions, PresignTransactionOptions, SignedTransaction, SignTransactionOptions, TokenEnablementConfig, TransactionExplanation, TransactionPrebuild as BaseTransactionPrebuild, TransactionRecipient, VerifyAddressOptions, VerifyTransactionOptions } from '@bitgo-beta/sdk-core';
import * as request from 'superagent';
export interface TransactionFee {
    fee: string;
}
export declare type SolTransactionExplanation = TransactionExplanation;
export interface ExplainTransactionOptions {
    txBase64: string;
    feeInfo: TransactionFee;
    tokenAccountRentExemptAmount?: string;
}
export interface TxInfo {
    recipients: TransactionRecipient[];
    from: string;
    txid: string;
}
export interface SolSignTransactionOptions extends SignTransactionOptions {
    txPrebuild: TransactionPrebuild;
    prv: string | string[];
    pubKeys?: string[];
}
export interface TransactionPrebuild extends BaseTransactionPrebuild {
    txBase64: string;
    txInfo: TxInfo;
    source: string;
}
export interface SolVerifyTransactionOptions extends VerifyTransactionOptions {
    memo?: Memo;
    feePayer: string;
    blockhash: string;
    durableNonce?: {
        walletNonceAddress: string;
        authWalletAddress: number;
    };
}
interface TransactionOutput {
    address: string;
    amount: number | string;
    tokenName?: string;
}
declare type TransactionInput = TransactionOutput;
export interface SolParsedTransaction extends ParsedTransaction {
    inputs: TransactionInput[];
    outputs: TransactionOutput[];
}
export interface SolParseTransactionOptions extends BaseParseTransactionOptions {
    txBase64: string;
    feeInfo: TransactionFee;
    tokenAccountRentExemptAmount?: string;
}
interface SolTx {
    serializedTx: string;
}
interface SolDurableNonceFromNode {
    authority: string;
    blockhash: string;
}
interface RecoveryOptions {
    userKey?: string;
    backupKey?: string;
    bitgoKey: string;
    recoveryDestination: string;
    walletPassphrase?: string;
    durableNonce?: {
        publicKey: string;
        secretKey: string;
    };
}
export declare class Sol extends BaseCoin {
    protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;
    constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>);
    static createInstance(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>): BaseCoin;
    allowsAccountConsolidations(): boolean;
    supportsTss(): boolean;
    getMPCAlgorithm(): MPCAlgorithm;
    supportsStaking(): boolean;
    getChain(): string;
    getFamily(): CoinFamily;
    getFullName(): string;
    getBaseFactor(): string | number;
    verifyTransaction(params: SolVerifyTransactionOptions): Promise<any>;
    isWalletAddress(params: VerifyAddressOptions): boolean;
    /**
     * Generate Solana key pair
     *
     * @param {Buffer} seed - Seed from which the new SolKeyPair should be generated, otherwise a random seed is used
     * @returns {Object} object with generated pub and prv
     */
    generateKeyPair(seed?: Buffer | undefined): KeyPair;
    /**
     * Return boolean indicating whether input is valid public key for the coin
     *
     * @param {string} pub the prv to be checked
     * @returns is it valid?
     */
    isValidPub(pub: string): boolean;
    /**
     * Return boolean indicating whether input is valid private key for the coin
     *
     * @param {string} prv the prv to be checked
     * @returns is it valid?
     */
    isValidPrv(prv: string): boolean;
    isValidAddress(address: string): boolean;
    signMessage(key: KeyPair, message: string | Buffer): Promise<Buffer>;
    /**
     * Signs Solana transaction
     * @param params
     * @param callback
     */
    signTransaction(params: SolSignTransactionOptions): Promise<SignedTransaction>;
    parseTransaction(params: SolParseTransactionOptions): Promise<SolParsedTransaction>;
    /**
     * Explain a Solana transaction from txBase64
     * @param params
     */
    explainTransaction(params: ExplainTransactionOptions): Promise<SolTransactionExplanation>;
    /** @inheritDoc */
    getSignablePayload(serializedTx: string): Promise<Buffer>;
    /** @inheritDoc */
    presignTransaction(params: PresignTransactionOptions): Promise<PresignTransactionOptions>;
    protected getPublicNodeUrl(): string;
    /**
     * Make a request to one of the public EOS nodes available
     * @param params.payload
     */
    protected getDataFromNode(params: {
        payload?: Record<string, unknown>;
    }): Promise<request.Response>;
    protected getBlockhash(): Promise<string>;
    /** TODO Update to getFeeForMessage and make necssary changes in fee calculation, GetFees is deprecated */
    protected getFees(): Promise<number>;
    protected getAccountBalance(pubKey: string): Promise<number>;
    protected getAccountInfo(pubKey?: string): Promise<SolDurableNonceFromNode>;
    /**
     * Builds a funds recovery transaction without BitGo
     * @param params
     */
    recover(params: RecoveryOptions): Promise<SolTx>;
    getTokenEnablementConfig(): TokenEnablementConfig;
    private getBuilder;
}
export {};
//# sourceMappingURL=sol.d.ts.map