import { Transaction } from "@scure/btc-signer";
import { BTC_NETWORK } from "@scure/btc-signer/utils";
import { SwapType } from "../enums/SwapType";
import { ChainIds, MultiChain, Swapper } from "./Swapper";
import { IBitcoinWallet } from "../bitcoin/wallet/IBitcoinWallet";
import { MinimalBitcoinWalletInterface } from "../types/wallets/MinimalBitcoinWalletInterface";
import { TokenAmount } from "../types/TokenAmount";
import { SCToken } from "../types/Token";
import { LNURLWithdraw } from "../types/lnurl/LNURLWithdraw";
import { LNURLPay } from "../types/lnurl/LNURLPay";
/**
 * Utility class providing helper methods for address parsing, token balances, serialization
 *  and other miscellaneous things.
 *
 * @category Core
 */
export declare class SwapperUtils<T extends MultiChain> {
    readonly bitcoinNetwork: BTC_NETWORK;
    private readonly root;
    constructor(root: Swapper<T>);
    /**
     * Checks whether a passed address is a valid address on the smart chain
     *
     * @param address Address
     * @param chainId Smart chain identifier string to check the address for
     */
    isValidSmartChainAddress(address: string, chainId?: ChainIds<T>): boolean;
    /**
     * Checks whether an address is a valid BOLT11 bitcoin lightning invoice
     *
     * @param address Address to check
     */
    isLightningInvoice(address: string): boolean;
    /**
     * Checks whether an address is a valid bitcoin address
     *
     * @param address Address to check
     */
    isValidBitcoinAddress(address: string): boolean;
    /**
     * Checks whether an address is a valid BOLT11 bitcoin lightning invoice WITH AMOUNT
     *
     * @param address Address to check
     */
    isValidLightningInvoice(address: string): boolean;
    /**
     * Checks whether an address is a valid LNURL (no checking on type is performed)
     *
     * @param address Address to check
     */
    isValidLNURL(address: string): boolean;
    /**
     * Returns type and data about an LNURL
     *
     * @param lnurl LNURL link to check, can be either `pay` or `withdraw` type
     * @param shouldRetry Optional whether HTTP requests should retried on failure
     */
    getLNURLTypeAndData(lnurl: string, shouldRetry?: boolean): Promise<LNURLPay | LNURLWithdraw | null>;
    /**
     * Returns satoshi value of BOLT11 bitcoin lightning invoice WITH AMOUNT, returns null otherwise
     *
     * @param lnpr
     */
    getLightningInvoiceValue(lnpr: string): bigint | null;
    private parseBitcoinAddress;
    private parseLNURLSync;
    private parseLNURL;
    private parseLightningInvoice;
    private parseSmartchainAddress;
    /**
     * General parser for bitcoin addresses, LNURLs, lightning invoices, smart chain addresses. Also fetches LNURL data
     *  (hence async and returns Promise).
     *
     * @param addressString Address to parse
     * @throws {Error} Error in address parsing
     * @returns Address data or `null` if address doesn't conform to any known format
     */
    parseAddress(addressString: string): Promise<{
        address: string;
        type: "BITCOIN" | "LIGHTNING" | "LNURL" | ChainIds<T>;
        swapType: SwapType.TO_BTC | SwapType.TO_BTCLN | SwapType.SPV_VAULT_FROM_BTC | SwapType.FROM_BTCLN | null;
        lnurl?: LNURLPay | LNURLWithdraw;
        min?: TokenAmount;
        max?: TokenAmount;
        amount?: TokenAmount;
    } | null>;
    /**
     * Synchronous general parser for bitcoin addresses, LNURLs, lightning invoices, smart chain addresses, doesn't fetch
     *  LNURL data, returns `swapType: null` instead to prevent returning a Promise
     *
     * @param addressString Address to parse
     * @throws {Error} Error in address parsing
     * @returns Address data or `null` if address doesn't conform to any known format
     */
    parseAddressSync(addressString: string): {
        address: string;
        type: "BITCOIN" | "LIGHTNING" | "LNURL" | ChainIds<T>;
        swapType: SwapType.TO_BTC | SwapType.TO_BTCLN | SwapType.SPV_VAULT_FROM_BTC | null;
        min?: TokenAmount;
        max?: TokenAmount;
        amount?: TokenAmount;
    } | null;
    /**
     * Strips the URL encoding around `bitcoin:` and `lightning:` addresses, leaving just the raw address
     *
     * @param addressString Address to strip
     *
     * @returns Raw clean address
     */
    stripAddress(addressString: string): string;
    /**
     * Returns a random PSBT that can be used for fee estimation for SPV vault (UTXO-controlled vault) based swaps
     *  {@link SwapType.SPV_VAULT_FROM_BTC}, the last output (the LP output) is omitted to allow for coinselection
     *  algorithm to determine maximum sendable amount there
     *
     * @param chainIdentifier Smart chain to swap to
     * @param includeGasToken Whether to return the PSBT also with the gas token amount (increases the vSize by 8)
     */
    getRandomSpvVaultPsbt<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier, includeGasToken?: boolean): Transaction;
    /**
     * Returns the spendable balance of a bitcoin wallet
     *
     * @param wallet Bitcoin wallet to check the spendable balance for, can either be a simple
     *  bitcoin address string or a wallet object
     * @param targetChain Destination smart chain for the swap, the ensures proper spendable balance
     *  is estimated taking into consideration different swap primitives available on different chains
     * @param options Additional options
     */
    getBitcoinSpendableBalance(wallet: string | IBitcoinWallet | MinimalBitcoinWalletInterface, targetChain?: ChainIds<T>, options?: {
        gasDrop?: boolean;
        feeRate?: number;
        minFeeRate?: number;
    }): Promise<{
        balance: TokenAmount;
        feeRate: number;
    }>;
    /**
     * Returns the maximum spendable balance of the smart chain wallet, deducting the fee needed
     *  to initiate a swap for native balances
     */
    getSpendableBalance<ChainIdentifier extends ChainIds<T>>(wallet: string | T[ChainIdentifier]["Signer"] | T[ChainIdentifier]["NativeSigner"], token: SCToken<ChainIdentifier>, options?: {
        feeMultiplier?: number;
        feeRate?: any;
    }): Promise<TokenAmount>;
    /**
     * Returns the address of the native currency of the smart chain
     */
    getNativeToken<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier): SCToken<ChainIdentifier>;
    /**
     * Returns whether when swapping to the provided token a gas drop can be requested
     *
     * @param token
     */
    destinationTokenSupportsGasDrop<ChainIdentifier extends ChainIds<T>>(token: SCToken<ChainIdentifier>): boolean;
    /**
     * Returns a random signer for a given smart chain
     *
     * @param chainIdentifier
     */
    randomSigner<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier): T[ChainIdentifier]["Signer"];
    /**
     * Returns a random address for a given smart chain or bitcoin
     *
     * @param chainIdentifier
     */
    randomAddress<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier | "BITCOIN"): string;
    /**
     * Signs and broadcasts the supplied smart chain transaction
     *
     * @param chainIdentifier Smart chain identifier string
     * @param signer Signer to use for signing the transactions
     * @param txs An array of transactions to sign
     * @param abortSignal Abort signal
     * @param onBeforePublish Callback invoked before a transaction is sent (invoked for every transaction to be sent)
     */
    sendAndConfirm<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier, signer: T[ChainIdentifier]["NativeSigner"] | T[ChainIdentifier]["Signer"], txs: T[ChainIdentifier]["TX"][], abortSignal?: AbortSignal, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<string[]>;
    /**
     * Broadcasts already signed smart chain transactions
     *
     * @param chainIdentifier Smart chain identifier string
     * @param txs An array of already signed transactions
     * @param abortSignal Abort signal
     * @param onBeforePublish Callback invoked before a transaction is sent (invoked for every transaction to be sent)
     */
    sendSignedAndConfirm<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier, txs: T[ChainIdentifier]["SignedTXType"][], abortSignal?: AbortSignal, onBeforePublish?: (txId: string, rawTx: string) => Promise<void>): Promise<string[]>;
    /**
     * Prepares a set of unsigned transactions for signing, by adding required nonces or recent blockhashes, might
     *  also add hints of account deployment on e.g. Starknet
     *
     * @param chainIdentifier A chain for which to prepare the txs
     * @param txs Transactions to prepare
     */
    prepareUnsignedTransactions<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier, txs: T[ChainIdentifier]["TX"][]): Promise<T[ChainIdentifier]["TX"][]>;
    /**
     * Serializes an unsigned smart chain transaction
     *
     * @param chainIdentifier Smart chain string identifier
     * @param tx An unsigned transaction to serialize
     */
    serializeUnsignedTransaction<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier, tx: T[ChainIdentifier]["TX"]): Promise<string>;
    /**
     * Deserializes an unsigned smart chain transaction
     *
     * @param chainIdentifier Smart chain string identifier
     * @param tx Serialized unsigned transaction
     */
    deserializeUnsignedTransaction<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier, tx: string): Promise<T[ChainIdentifier]["TX"]>;
    /**
     * Serializes a signed smart chain transaction
     *
     * @param chainIdentifier Smart chain string identifier
     * @param tx A signed transaction to serialize
     */
    serializeSignedTransaction<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier, tx: T[ChainIdentifier]["SignedTXType"]): Promise<string>;
    /**
     * Deserializes a signed smart chain transaction
     *
     * @param chainIdentifier Smart chain string identifier
     * @param tx Serialized signed transaction
     */
    deserializeSignedTransaction<ChainIdentifier extends ChainIds<T>>(chainIdentifier: ChainIdentifier, tx: string): Promise<T[ChainIdentifier]["SignedTXType"]>;
}