import { AuditDecryptedKeyParams, BaseCoin, BaseTransaction, BitGoBase, KeyPair, MultisigType, SignedTransaction, VerifyAddressOptions, VerifyTransactionOptions } from '@bitgo/sdk-core';
import { BaseCoin as StaticsBaseCoin, CoinFamily } from '@bitgo/statics';
import { ExplainTransactionOptions, StxSignTransactionOptions, StxTransactionExplanation } from './types';
import { TransactionBuilder } from './lib/transactionBuilder';
import { AddressDetails, NativeStxBalance, RecoveryInfo, RecoveryOptions, RecoveryTransaction, SingleFungibleTokenBalance, StxNonceResponse } from './lib/iface';
import { TransferBuilder } from './lib/transferBuilder';
import { FungibleTokenTransferBuilder } from './lib/fungibleTokenTransferBuilder';
export declare class Stx extends BaseCoin {
    protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;
    constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>);
    static createInstance(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>): BaseCoin;
    getChain(): string;
    getFamily(): CoinFamily;
    getFullName(): string;
    getBaseFactor(): string | number;
    getTransaction(coinConfig: Readonly<StaticsBaseCoin>): TransactionBuilder;
    /** inherited doc */
    getDefaultMultisigType(): MultisigType;
    verifyTransaction(params: VerifyTransactionOptions): Promise<boolean>;
    /**
     * Check if address is valid, then make sure it matches the base address.
     *
     * @param {VerifyAddressOptions} params
     * @param {String} params.address - the address to verify
     * @param {String} params.baseAddress - the base address from the wallet
     */
    isWalletAddress(params: VerifyAddressOptions): Promise<boolean>;
    /**
     * Generate Stacks key pair
     *
     * @param {Buffer} seed - Seed from which the new keypair should be generated, otherwise a random seed is used
     * @returns {Object} object with generated pub and prv
     */
    generateKeyPair(seed?: Buffer): 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;
    /**
     * Signs stacks transaction
     * @param params
     */
    signTransaction(params: StxSignTransactionOptions): Promise<SignedTransaction>;
    parseTransaction(params: any): Promise<any>;
    /**
     * Explain a Stacks transaction from txHex
     * @param params
     */
    explainTransaction(params: ExplainTransactionOptions): Promise<StxTransactionExplanation | undefined>;
    /**
     * Get URLs of some active public nodes
     * @returns {String} node url
     */
    getPublicNodeUrl(): string;
    /**
     * Get native stacks balance for an account
     * @param {String} address - stacks address
     * @returns {Promise<NativeStxBalance>}
     */
    protected getNativeStxBalanceFromNode({ address }: {
        address: string;
    }): Promise<NativeStxBalance>;
    /**
     * Get single fungible token balance for an account
     * @param {String} address - stacks address
     * @param {String} assetId - fungible token asset id
     * @returns {Promise<SingleFungibleTokenBalance>}
     */
    protected getSingleFungibleTokenBalanceFromNode({ address, assetId, }: {
        address: string;
        assetId: string;
    }): Promise<SingleFungibleTokenBalance>;
    /**
     * Get nonce data specific to an account from a public node
     * @param {String} address - stacks address
     * @returns {Promise<StxNonceResponse>}
     */
    protected getAccountNonceFromNode({ address }: {
        address: string;
    }): Promise<StxNonceResponse>;
    /**
     * Get stacks transaction estimated fee
     * @param {String} txHex - hex of stacks transaction payload
     * @param {Number} txHexLength - length of built serialized transaction
     * @returns {Promise<Number>} - fee estimate (taking the lowest)
     */
    protected getTransactionFeeEstimation({ txHex, txHexLength, }: {
        txHex: string;
        txHexLength: number;
    }): Promise<number>;
    /**
     * Format for offline vault signing
     * @param {BaseTransaction} tx - base transaction
     * @returns {Promise<RecoveryInfo>}
     */
    protected formatForOfflineVault(tx: BaseTransaction): Promise<RecoveryInfo>;
    /**
     * Get the recoverable amount & fee after subtracting the txn fee
     * @param {String} serializedHex - serialized txn hex
     * @param {Number} txHexLength - deserialized txn length
     * @param {String} balance - total account balance
     * @param {String} tokenBalance - total token balance
     * @returns {Promise<Record<string, string>>}
     */
    protected getRecoverableAmountAndFee(serializedHex: string, txHexLength: number, balance: string, tokenBalance?: string): Promise<Record<string, string>>;
    /**
     * Method to find the right builder for token or native coin transfer
     * @param {String} contractAddress - token contract address
     * @param {String} contractName - token contract name
     * @returns {TransferBuilder|FungibleTokenTransferBuilder}
     */
    protected getTokenOrNativeTransferBuilder(contractAddress?: string, contractName?: string): TransferBuilder | FungibleTokenTransferBuilder;
    /**
     * Method to build fungible token transfer transaction
     * @param {FungibleTokenTransferBuilder} builder - fungible token transfer builder
     * @param {String} contractAddress - token contract address
     * @param {String} contractName - token contract name
     * @param {String[]} pubs - account public keys
     * @param {Number} nonce - account nonce
     * @param {AddressDetails} rootAddressDetails - root address details
     * @param {AddressDetails} destinationAddressDetails - receive address details
     * @param {String} stxBalance - native stx balance
     * @returns {Promise<BaseTransaction>} - built transaction
     */
    protected buildTokenTransferTransaction({ builder, contractAddress, contractName, pubs, nonce, rootAddressDetails, destinationAddressDetails, stxBalance, }: {
        builder: FungibleTokenTransferBuilder;
        contractAddress: string;
        contractName: string;
        pubs: string[];
        nonce: number;
        rootAddressDetails: AddressDetails;
        destinationAddressDetails: AddressDetails;
        stxBalance: string;
    }): Promise<BaseTransaction>;
    /**
     * Method to build native transfer transaction
     * @param {TransferBuilder} builder - transfer builder
     * @param {String[]} pubs - account public keys
     * @param {Number} nonce - account nonce
     * @param {AddressDetails} destinationAddressDetails - receive address details
     * @param {String} stxBalance - native stx balance
     * @returns {Promise<BaseTransaction>} - built transaction
     */
    protected buildNativeTransferTransaction({ builder, pubs, nonce, destinationAddressDetails, stxBalance, }: {
        builder: TransferBuilder;
        pubs: string[];
        nonce: number;
        destinationAddressDetails: AddressDetails;
        stxBalance: string;
    }): Promise<BaseTransaction>;
    /**
     * Method that uses appropriate builder and builds transaction depending on token or native coin
     * @param {String[]} pubs - public keys
     * @param {AddressDetails} rootAddressDetails - sender address detail
     * @param {AddressDetails} destinationAddressDetails - receiver address detail
     * @param {Number} nonce - wallet nonce
     * @param {String} balance - wallet balance
     * @param {String | undefined} contractAddress - token contract address
     * @param {String | undefined} contractName - token contract name
     * @returns {Promise<BaseTransaction>} built transaction
     */
    protected getNativeOrTokenTransaction({ pubs, rootAddressDetails, destinationAddressDetails, nonce, stxBalance, contractAddressInput, contractName, }: {
        pubs: string[];
        rootAddressDetails: AddressDetails;
        destinationAddressDetails: AddressDetails;
        nonce: number;
        stxBalance: string;
        contractAddressInput?: string;
        contractName?: string;
    }): Promise<{
        tx: BaseTransaction;
        builder: TransferBuilder | FungibleTokenTransferBuilder;
    }>;
    /**
     * Method to recover native stx or sip10 tokens from bitgo hot & cold wallets
     * @param {String} params.backupKey - encrypted wallet backup key (public or private)
     * @param {String} params.userKey - encrypted wallet user key (public or private)
     * @param {String} params.rootAddress - wallet root address
     * @param {String} params.recoveryDestination - receive address
     * @param {String} params.bitgoKey - encrypted bitgo public key
     * @param {String} params.walletPassphrase - wallet password
     * @param {String} params.contractId - contract id of the token (mandatory for token recovery)
     * @returns {Promise<RecoveryInfo|RecoveryTransaction>} RecoveryTransaction.txHex - hex of serialized transaction (signed or unsigned)
     */
    recover(params: RecoveryOptions): Promise<RecoveryInfo | RecoveryTransaction>;
    /** @inheritDoc */
    auditDecryptedKey(params: AuditDecryptedKeyParams): void;
}
//# sourceMappingURL=stx.d.ts.map