@breeztech/react-native-breez-sdk/lib/typescript/index.d.ts

React Native Breez SDK

import type { EmitterSubscription } from "react-native";
export interface AesSuccessActionDataDecrypted {
    description: string;
    plaintext: string;
}
export interface BackupFailedData {
    error: string;
}
export interface BackupStatus {
    backedUp: boolean;
    lastBackupTime?: number;
}
export interface BitcoinAddressData {
    address: string;
    network: Network;
    amountSat?: number;
    label?: string;
    message?: string;
}
export interface BuyBitcoinRequest {
    provider: BuyBitcoinProvider;
    openingFeeParams?: OpeningFeeParams;
    redirectUrl?: string;
}
export interface BuyBitcoinResponse {
    url: string;
    openingFeeParams?: OpeningFeeParams;
}
export interface CheckMessageRequest {
    message: string;
    pubkey: string;
    signature: string;
}
export interface CheckMessageResponse {
    isValid: boolean;
}
export interface ClosedChannelPaymentDetails {
    state: ChannelState;
    fundingTxid: string;
    shortChannelId?: string;
    closingTxid?: string;
}
export interface Config {
    breezserver: string;
    chainnotifierUrl: string;
    mempoolspaceUrl?: string;
    workingDir: string;
    network: Network;
    paymentTimeoutSec: number;
    defaultLspId?: string;
    apiKey?: string;
    maxfeePercent: number;
    exemptfeeMsat: number;
    nodeConfig: NodeConfig;
}
export interface ConfigureNodeRequest {
    closeToAddress?: string;
}
export interface ConnectRequest {
    config: Config;
    seed: number[];
    restoreOnly?: boolean;
}
export interface CurrencyInfo {
    name: string;
    fractionSize: number;
    spacing?: number;
    symbol?: SymbolType;
    uniqSymbol?: SymbolType;
    localizedName: LocalizedName[];
    localeOverrides: LocaleOverrides[];
}
export interface FiatCurrency {
    id: string;
    info: CurrencyInfo;
}
export interface GreenlightCredentials {
    developerKey: number[];
    developerCert: number[];
}
export interface GreenlightDeviceCredentials {
    device: number[];
}
export interface GreenlightNodeConfig {
    partnerCredentials?: GreenlightCredentials;
    inviteCode?: string;
}
export interface InvoicePaidDetails {
    paymentHash: string;
    bolt11: string;
    payment?: Payment;
}
export interface LnInvoice {
    bolt11: string;
    network: Network;
    payeePubkey: string;
    paymentHash: string;
    description?: string;
    descriptionHash?: string;
    amountMsat?: number;
    timestamp: number;
    expiry: number;
    routingHints: RouteHint[];
    paymentSecret: number[];
    minFinalCltvExpiryDelta: number;
}
export interface ListPaymentsRequest {
    filters?: PaymentTypeFilter[];
    metadataFilters?: MetadataFilter[];
    fromTimestamp?: number;
    toTimestamp?: number;
    includeFailures?: boolean;
    offset?: number;
    limit?: number;
}
export interface ListSwapsRequest {
    status?: SwapStatus[];
    fromTimestamp?: number;
    toTimestamp?: number;
    offset?: number;
    limit?: number;
}
export interface LnPaymentDetails {
    paymentHash: string;
    label: string;
    destinationPubkey: string;
    paymentPreimage: string;
    keysend: boolean;
    bolt11: string;
    openChannelBolt11?: string;
    lnurlSuccessAction?: SuccessActionProcessed;
    lnurlPayDomain?: string;
    lnurlPayComment?: string;
    lnurlMetadata?: string;
    lnAddress?: string;
    lnurlWithdrawEndpoint?: string;
    swapInfo?: SwapInfo;
    reverseSwapInfo?: ReverseSwapInfo;
    pendingExpirationBlock?: number;
}
export interface LnUrlAuthRequestData {
    k1: string;
    domain: string;
    url: string;
    action?: string;
}
export interface LnUrlErrorData {
    reason: string;
}
export interface LnUrlPayErrorData {
    paymentHash: string;
    reason: string;
}
export interface LnUrlPayRequest {
    data: LnUrlPayRequestData;
    amountMsat: number;
    useTrampoline: boolean;
    comment?: string;
    paymentLabel?: string;
    validateSuccessActionUrl?: boolean;
}
export interface LnUrlPayRequestData {
    callback: string;
    minSendable: number;
    maxSendable: number;
    metadataStr: string;
    commentAllowed: number;
    domain: string;
    allowsNostr: boolean;
    nostrPubkey?: string;
    lnAddress?: string;
}
export interface LnUrlPaySuccessData {
    successAction?: SuccessActionProcessed;
    payment: Payment;
}
export interface LnUrlWithdrawRequest {
    data: LnUrlWithdrawRequestData;
    amountMsat: number;
    description?: string;
}
export interface LnUrlWithdrawRequestData {
    callback: string;
    k1: string;
    defaultDescription: string;
    minWithdrawable: number;
    maxWithdrawable: number;
}
export interface LnUrlWithdrawSuccessData {
    invoice: LnInvoice;
}
export interface LocaleOverrides {
    locale: string;
    spacing?: number;
    symbol: SymbolType;
}
export interface LocalizedName {
    locale: string;
    name: string;
}
export interface LogEntry {
    line: string;
    level: string;
}
export interface LspInformation {
    id: string;
    name: string;
    widgetUrl: string;
    pubkey: string;
    host: string;
    baseFeeMsat: number;
    feeRate: number;
    timeLockDelta: number;
    minHtlcMsat: number;
    lspPubkey: number[];
    openingFeeParamsList: OpeningFeeParamsMenu;
}
export interface MessageSuccessActionData {
    message: string;
}
export interface MetadataFilter {
    jsonPath: string;
    jsonValue: string;
}
export interface MetadataItem {
    key: string;
    value: string;
}
export interface NodeState {
    id: string;
    blockHeight: number;
    channelsBalanceMsat: number;
    onchainBalanceMsat: number;
    pendingOnchainBalanceMsat: number;
    utxos: UnspentTransactionOutput[];
    maxPayableMsat: number;
    maxReceivableMsat: number;
    maxSinglePaymentAmountMsat: number;
    maxChanReserveMsats: number;
    connectedPeers: string[];
    maxReceivableSinglePaymentAmountMsat: number;
    totalInboundLiquidityMsats: number;
}
export interface OnchainPaymentLimitsResponse {
    minSat: number;
    maxSat: number;
    maxPayableSat: number;
}
export interface OpenChannelFeeRequest {
    amountMsat?: number;
    expiry?: number;
}
export interface OpenChannelFeeResponse {
    feeMsat?: number;
    feeParams: OpeningFeeParams;
}
export interface OpeningFeeParams {
    minMsat: number;
    proportional: number;
    validUntil: string;
    maxIdleTime: number;
    maxClientToSelfDelay: number;
    promise: string;
}
export interface OpeningFeeParamsMenu {
    values: OpeningFeeParams[];
}
export interface PayOnchainRequest {
    recipientAddress: string;
    prepareRes: PrepareOnchainPaymentResponse;
}
export interface PayOnchainResponse {
    reverseSwapInfo: ReverseSwapInfo;
}
export interface Payment {
    id: string;
    paymentType: PaymentType;
    paymentTime: number;
    amountMsat: number;
    feeMsat: number;
    status: PaymentStatus;
    error?: string;
    description?: string;
    details: PaymentDetails;
    metadata?: string;
}
export interface PaymentFailedData {
    error: string;
    nodeId: string;
    invoice?: LnInvoice;
    label?: string;
}
export interface PrepareOnchainPaymentRequest {
    amountSat: number;
    amountType: SwapAmountType;
    claimTxFeerate: number;
}
export interface PrepareOnchainPaymentResponse {
    feesHash: string;
    feesPercentage: number;
    feesLockup: number;
    feesClaim: number;
    senderAmountSat: number;
    recipientAmountSat: number;
    totalFees: number;
}
export interface PrepareRedeemOnchainFundsRequest {
    toAddress: string;
    satPerVbyte: number;
}
export interface PrepareRedeemOnchainFundsResponse {
    txWeight: number;
    txFeeSat: number;
}
export interface PrepareRefundRequest {
    swapAddress: string;
    toAddress: string;
    satPerVbyte: number;
    unilateral?: boolean;
}
export interface PrepareRefundResponse {
    refundTxWeight: number;
    refundTxFeeSat: number;
}
export interface Rate {
    coin: string;
    value: number;
}
export interface ReceiveOnchainRequest {
    openingFeeParams?: OpeningFeeParams;
}
export interface ReceivePaymentRequest {
    amountMsat: number;
    description: string;
    preimage?: number[];
    openingFeeParams?: OpeningFeeParams;
    useDescriptionHash?: boolean;
    expiry?: number;
    cltv?: number;
}
export interface ReceivePaymentResponse {
    lnInvoice: LnInvoice;
    openingFeeParams?: OpeningFeeParams;
    openingFeeMsat?: number;
}
export interface RecommendedFees {
    fastestFee: number;
    halfHourFee: number;
    hourFee: number;
    economyFee: number;
    minimumFee: number;
}
export interface RedeemOnchainFundsRequest {
    toAddress: string;
    satPerVbyte: number;
}
export interface RedeemOnchainFundsResponse {
    txid: number[];
}
export interface RefundRequest {
    swapAddress: string;
    toAddress: string;
    satPerVbyte: number;
    unilateral?: boolean;
}
export interface RefundResponse {
    refundTxId: string;
}
export interface ReportPaymentFailureDetails {
    paymentHash: string;
    comment?: string;
}
export interface ReverseSwapFeesRequest {
    sendAmountSat?: number;
    claimTxFeerate?: number;
}
export interface ReverseSwapInfo {
    id: string;
    claimPubkey: string;
    lockupTxid?: string;
    claimTxid?: string;
    onchainAmountSat: number;
    status: ReverseSwapStatus;
}
export interface ReverseSwapPairInfo {
    min: number;
    max: number;
    feesHash: string;
    feesPercentage: number;
    feesLockup: number;
    feesClaim: number;
    totalFees?: number;
}
export interface RouteHint {
    hops: RouteHintHop[];
}
export interface RouteHintHop {
    srcNodeId: string;
    shortChannelId: string;
    feesBaseMsat: number;
    feesProportionalMillionths: number;
    cltvExpiryDelta: number;
    htlcMinimumMsat?: number;
    htlcMaximumMsat?: number;
}
export interface SendPaymentRequest {
    bolt11: string;
    useTrampoline: boolean;
    amountMsat?: number;
    label?: string;
}
export interface SendPaymentResponse {
    payment: Payment;
}
export interface SendSpontaneousPaymentRequest {
    nodeId: string;
    amountMsat: number;
    extraTlvs?: TlvEntry[];
    label?: string;
}
export interface ServiceHealthCheckResponse {
    status: HealthCheckStatus;
}
export interface SignMessageRequest {
    message: string;
}
export interface SignMessageResponse {
    signature: string;
}
export interface StaticBackupRequest {
    workingDir: string;
}
export interface StaticBackupResponse {
    backup?: string[];
}
export interface SwapInfo {
    bitcoinAddress: string;
    createdAt: number;
    lockHeight: number;
    paymentHash: number[];
    preimage: number[];
    privateKey: number[];
    publicKey: number[];
    swapperPublicKey: number[];
    script: number[];
    bolt11?: string;
    paidMsat: number;
    unconfirmedSats: number;
    confirmedSats: number;
    totalIncomingTxs: number;
    status: SwapStatus;
    refundTxIds: string[];
    unconfirmedTxIds: string[];
    confirmedTxIds: string[];
    minAllowedDeposit: number;
    maxAllowedDeposit: number;
    maxSwapperPayable: number;
    lastRedeemError?: string;
    channelOpeningFees?: OpeningFeeParams;
    confirmedAt?: number;
}
export interface SymbolType {
    grapheme?: string;
    template?: string;
    rtl?: boolean;
    position?: number;
}
export interface TlvEntry {
    fieldNumber: number;
    value: number[];
}
export interface UnspentTransactionOutput {
    txid: number[];
    outnum: number;
    amountMillisatoshi: number;
    address: string;
    reserved: boolean;
}
export interface UrlSuccessActionData {
    description: string;
    url: string;
    matchesCallbackDomain: boolean;
}
export declare enum AesSuccessActionDataResultVariant {
    DECRYPTED = "decrypted",
    ERROR_STATUS = "errorStatus"
}
export type AesSuccessActionDataResult = {
    type: AesSuccessActionDataResultVariant.DECRYPTED;
    data: AesSuccessActionDataDecrypted;
} | {
    type: AesSuccessActionDataResultVariant.ERROR_STATUS;
    reason: string;
};
export declare enum BreezEventVariant {
    NEW_BLOCK = "newBlock",
    INVOICE_PAID = "invoicePaid",
    SYNCED = "synced",
    PAYMENT_SUCCEED = "paymentSucceed",
    PAYMENT_FAILED = "paymentFailed",
    BACKUP_STARTED = "backupStarted",
    BACKUP_SUCCEEDED = "backupSucceeded",
    BACKUP_FAILED = "backupFailed",
    REVERSE_SWAP_UPDATED = "reverseSwapUpdated",
    SWAP_UPDATED = "swapUpdated"
}
export type BreezEvent = {
    type: BreezEventVariant.NEW_BLOCK;
    block: number;
} | {
    type: BreezEventVariant.INVOICE_PAID;
    details: InvoicePaidDetails;
} | {
    type: BreezEventVariant.SYNCED;
} | {
    type: BreezEventVariant.PAYMENT_SUCCEED;
    details: Payment;
} | {
    type: BreezEventVariant.PAYMENT_FAILED;
    details: PaymentFailedData;
} | {
    type: BreezEventVariant.BACKUP_STARTED;
} | {
    type: BreezEventVariant.BACKUP_SUCCEEDED;
} | {
    type: BreezEventVariant.BACKUP_FAILED;
    details: BackupFailedData;
} | {
    type: BreezEventVariant.REVERSE_SWAP_UPDATED;
    details: ReverseSwapInfo;
} | {
    type: BreezEventVariant.SWAP_UPDATED;
    details: SwapInfo;
};
export declare enum BuyBitcoinProvider {
    MOONPAY = "moonpay"
}
export declare enum ChannelState {
    PENDING_OPEN = "pendingOpen",
    OPENED = "opened",
    PENDING_CLOSE = "pendingClose",
    CLOSED = "closed"
}
export declare enum EnvironmentType {
    PRODUCTION = "production",
    STAGING = "staging"
}
export declare enum FeeratePreset {
    REGULAR = "regular",
    ECONOMY = "economy",
    PRIORITY = "priority"
}
export declare enum HealthCheckStatus {
    OPERATIONAL = "operational",
    MAINTENANCE = "maintenance",
    SERVICE_DISRUPTION = "serviceDisruption"
}
export declare enum InputTypeVariant {
    BITCOIN_ADDRESS = "bitcoinAddress",
    BOLT11 = "bolt11",
    NODE_ID = "nodeId",
    URL = "url",
    LN_URL_PAY = "lnUrlPay",
    LN_URL_WITHDRAW = "lnUrlWithdraw",
    LN_URL_AUTH = "lnUrlAuth",
    LN_URL_ERROR = "lnUrlError"
}
export type InputType = {
    type: InputTypeVariant.BITCOIN_ADDRESS;
    address: BitcoinAddressData;
} | {
    type: InputTypeVariant.BOLT11;
    invoice: LnInvoice;
} | {
    type: InputTypeVariant.NODE_ID;
    nodeId: string;
} | {
    type: InputTypeVariant.URL;
    url: string;
} | {
    type: InputTypeVariant.LN_URL_PAY;
    data: LnUrlPayRequestData;
    bip353Address?: string;
} | {
    type: InputTypeVariant.LN_URL_WITHDRAW;
    data: LnUrlWithdrawRequestData;
} | {
    type: InputTypeVariant.LN_URL_AUTH;
    data: LnUrlAuthRequestData;
} | {
    type: InputTypeVariant.LN_URL_ERROR;
    data: LnUrlErrorData;
};
export declare enum LnUrlCallbackStatusVariant {
    OK = "ok",
    ERROR_STATUS = "errorStatus"
}
export type LnUrlCallbackStatus = {
    type: LnUrlCallbackStatusVariant.OK;
} | {
    type: LnUrlCallbackStatusVariant.ERROR_STATUS;
    data: LnUrlErrorData;
};
export declare enum LnUrlPayResultVariant {
    ENDPOINT_SUCCESS = "endpointSuccess",
    ENDPOINT_ERROR = "endpointError",
    PAY_ERROR = "payError"
}
export type LnUrlPayResult = {
    type: LnUrlPayResultVariant.ENDPOINT_SUCCESS;
    data: LnUrlPaySuccessData;
} | {
    type: LnUrlPayResultVariant.ENDPOINT_ERROR;
    data: LnUrlErrorData;
} | {
    type: LnUrlPayResultVariant.PAY_ERROR;
    data: LnUrlPayErrorData;
};
export declare enum LnUrlWithdrawResultVariant {
    OK = "ok",
    TIMEOUT = "timeout",
    ERROR_STATUS = "errorStatus"
}
export type LnUrlWithdrawResult = {
    type: LnUrlWithdrawResultVariant.OK;
    data: LnUrlWithdrawSuccessData;
} | {
    type: LnUrlWithdrawResultVariant.TIMEOUT;
    data: LnUrlWithdrawSuccessData;
} | {
    type: LnUrlWithdrawResultVariant.ERROR_STATUS;
    data: LnUrlErrorData;
};
export declare enum Network {
    BITCOIN = "bitcoin",
    TESTNET = "testnet",
    SIGNET = "signet",
    REGTEST = "regtest"
}
export declare enum NodeConfigVariant {
    GREENLIGHT = "greenlight"
}
export interface NodeConfig {
    type: NodeConfigVariant.GREENLIGHT;
    config: GreenlightNodeConfig;
}
export declare enum NodeCredentialsVariant {
    GREENLIGHT = "greenlight"
}
export interface NodeCredentials {
    type: NodeCredentialsVariant.GREENLIGHT;
    credentials: GreenlightDeviceCredentials;
}
export declare enum PaymentDetailsVariant {
    LN = "ln",
    CLOSED_CHANNEL = "closedChannel"
}
export type PaymentDetails = {
    type: PaymentDetailsVariant.LN;
    data: LnPaymentDetails;
} | {
    type: PaymentDetailsVariant.CLOSED_CHANNEL;
    data: ClosedChannelPaymentDetails;
};
export declare enum PaymentStatus {
    PENDING = "pending",
    COMPLETE = "complete",
    FAILED = "failed"
}
export declare enum PaymentType {
    SENT = "sent",
    RECEIVED = "received",
    CLOSED_CHANNEL = "closedChannel"
}
export declare enum PaymentTypeFilter {
    SENT = "sent",
    RECEIVED = "received",
    CLOSED_CHANNEL = "closedChannel"
}
export declare enum ReportIssueRequestVariant {
    PAYMENT_FAILURE = "paymentFailure"
}
export interface ReportIssueRequest {
    type: ReportIssueRequestVariant.PAYMENT_FAILURE;
    data: ReportPaymentFailureDetails;
}
export declare enum ReverseSwapStatus {
    INITIAL = "initial",
    IN_PROGRESS = "inProgress",
    CANCELLED = "cancelled",
    COMPLETED_SEEN = "completedSeen",
    COMPLETED_CONFIRMED = "completedConfirmed"
}
export declare enum SuccessActionProcessedVariant {
    AES = "aes",
    MESSAGE = "message",
    URL = "url"
}
export type SuccessActionProcessed = {
    type: SuccessActionProcessedVariant.AES;
    result: AesSuccessActionDataResult;
} | {
    type: SuccessActionProcessedVariant.MESSAGE;
    data: MessageSuccessActionData;
} | {
    type: SuccessActionProcessedVariant.URL;
    data: UrlSuccessActionData;
};
export declare enum SwapAmountType {
    SEND = "send",
    RECEIVE = "receive"
}
export declare enum SwapStatus {
    INITIAL = "initial",
    WAITING_CONFIRMATION = "waitingConfirmation",
    REDEEMABLE = "redeemable",
    REDEEMED = "redeemed",
    REFUNDABLE = "refundable",
    COMPLETED = "completed"
}
export type EventListener = (breezEvent: BreezEvent) => void;
export type LogStream = (logEntry: LogEntry) => void;
export declare const connect: (req: ConnectRequest, listener: EventListener) => Promise<EmitterSubscription>;
export declare const setLogStream: (logStream: LogStream) => Promise<EmitterSubscription>;
export declare const parseInvoice: (invoice: string) => Promise<LnInvoice>;
export declare const parseInput: (s: string) => Promise<InputType>;
export declare const mnemonicToSeed: (phrase: string) => Promise<number[]>;
export declare const defaultConfig: (envType: EnvironmentType, apiKey: string, nodeConfig: NodeConfig) => Promise<Config>;
export declare const staticBackup: (req: StaticBackupRequest) => Promise<StaticBackupResponse>;
export declare const serviceHealthCheck: (apiKey: string) => Promise<ServiceHealthCheckResponse>;
export declare const disconnect: () => Promise<void>;
export declare const configureNode: (req: ConfigureNodeRequest) => Promise<void>;
export declare const sendPayment: (req: SendPaymentRequest) => Promise<SendPaymentResponse>;
export declare const sendSpontaneousPayment: (req: SendSpontaneousPaymentRequest) => Promise<SendPaymentResponse>;
export declare const receivePayment: (req: ReceivePaymentRequest) => Promise<ReceivePaymentResponse>;
export declare const payLnurl: (req: LnUrlPayRequest) => Promise<LnUrlPayResult>;
export declare const withdrawLnurl: (request: LnUrlWithdrawRequest) => Promise<LnUrlWithdrawResult>;
export declare const lnurlAuth: (reqData: LnUrlAuthRequestData) => Promise<LnUrlCallbackStatus>;
export declare const reportIssue: (req: ReportIssueRequest) => Promise<void>;
export declare const nodeCredentials: () => Promise<NodeCredentials | null>;
export declare const nodeInfo: () => Promise<NodeState>;
export declare const signMessage: (req: SignMessageRequest) => Promise<SignMessageResponse>;
export declare const checkMessage: (req: CheckMessageRequest) => Promise<CheckMessageResponse>;
export declare const backupStatus: () => Promise<BackupStatus>;
export declare const backup: () => Promise<void>;
export declare const listPayments: (req: ListPaymentsRequest) => Promise<Payment[]>;
export declare const paymentByHash: (hash: string) => Promise<Payment | null>;
export declare const setPaymentMetadata: (hash: string, metadata: string) => Promise<void>;
export declare const redeemOnchainFunds: (req: RedeemOnchainFundsRequest) => Promise<RedeemOnchainFundsResponse>;
export declare const fetchFiatRates: () => Promise<Rate[]>;
export declare const listFiatCurrencies: () => Promise<FiatCurrency[]>;
export declare const listLsps: () => Promise<LspInformation[]>;
export declare const connectLsp: (lspId: string) => Promise<void>;
export declare const fetchLspInfo: (lspId: string) => Promise<LspInformation | null>;
export declare const openChannelFee: (req: OpenChannelFeeRequest) => Promise<OpenChannelFeeResponse>;
export declare const lspId: () => Promise<string | null>;
export declare const lspInfo: () => Promise<LspInformation>;
export declare const closeLspChannels: () => Promise<void>;
export declare const registerWebhook: (webhookUrl: string) => Promise<void>;
export declare const unregisterWebhook: (webhookUrl: string) => Promise<void>;
export declare const receiveOnchain: (req: ReceiveOnchainRequest) => Promise<SwapInfo>;
export declare const inProgressSwap: () => Promise<SwapInfo | null>;
export declare const rescanSwaps: () => Promise<void>;
export declare const redeemSwap: (swapAddress: string) => Promise<void>;
export declare const listRefundables: () => Promise<SwapInfo[]>;
export declare const prepareRefund: (req: PrepareRefundRequest) => Promise<PrepareRefundResponse>;
export declare const refund: (req: RefundRequest) => Promise<RefundResponse>;
export declare const listSwaps: (req: ListSwapsRequest) => Promise<SwapInfo[]>;
export declare const fetchReverseSwapFees: (req: ReverseSwapFeesRequest) => Promise<ReverseSwapPairInfo>;
export declare const onchainPaymentLimits: () => Promise<OnchainPaymentLimitsResponse>;
export declare const prepareOnchainPayment: (req: PrepareOnchainPaymentRequest) => Promise<PrepareOnchainPaymentResponse>;
export declare const inProgressOnchainPayments: () => Promise<ReverseSwapInfo[]>;
export declare const claimReverseSwap: (lockupAddress: string) => Promise<void>;
export declare const payOnchain: (req: PayOnchainRequest) => Promise<PayOnchainResponse>;
export declare const executeDevCommand: (command: string) => Promise<string>;
export declare const generateDiagnosticData: () => Promise<string>;
export declare const sync: () => Promise<void>;
export declare const recommendedFees: () => Promise<RecommendedFees>;
export declare const buyBitcoin: (req: BuyBitcoinRequest) => Promise<BuyBitcoinResponse>;
export declare const prepareRedeemOnchainFunds: (req: PrepareRedeemOnchainFundsRequest) => Promise<PrepareRedeemOnchainFundsResponse>;
//# sourceMappingURL=index.d.ts.map