@breeztech/react-native-breez-sdk/lib/module/index.js

React Native Breez SDK

import { NativeModules, Platform, NativeEventEmitter } from "react-native";
const LINKING_ERROR = `The package 'react-native-breez-sdk' doesn't seem to be linked. Make sure: \n\n` + Platform.select({
  ios: "- You have run 'pod install'\n",
  default: ""
}) + "- You rebuilt the app after installing the package\n" + "- You are not using Expo managed workflow\n";
const BreezSDK = NativeModules.RNBreezSDK ? NativeModules.RNBreezSDK : new Proxy({}, {
  get() {
    throw new Error(LINKING_ERROR);
  }
});
const BreezSDKEmitter = new NativeEventEmitter(BreezSDK);
export let AesSuccessActionDataResultVariant = /*#__PURE__*/function (AesSuccessActionDataResultVariant) {
  AesSuccessActionDataResultVariant["DECRYPTED"] = "decrypted";
  AesSuccessActionDataResultVariant["ERROR_STATUS"] = "errorStatus";
  return AesSuccessActionDataResultVariant;
}({});
export let BreezEventVariant = /*#__PURE__*/function (BreezEventVariant) {
  BreezEventVariant["NEW_BLOCK"] = "newBlock";
  BreezEventVariant["INVOICE_PAID"] = "invoicePaid";
  BreezEventVariant["SYNCED"] = "synced";
  BreezEventVariant["PAYMENT_SUCCEED"] = "paymentSucceed";
  BreezEventVariant["PAYMENT_FAILED"] = "paymentFailed";
  BreezEventVariant["BACKUP_STARTED"] = "backupStarted";
  BreezEventVariant["BACKUP_SUCCEEDED"] = "backupSucceeded";
  BreezEventVariant["BACKUP_FAILED"] = "backupFailed";
  BreezEventVariant["REVERSE_SWAP_UPDATED"] = "reverseSwapUpdated";
  BreezEventVariant["SWAP_UPDATED"] = "swapUpdated";
  return BreezEventVariant;
}({});
export let BuyBitcoinProvider = /*#__PURE__*/function (BuyBitcoinProvider) {
  BuyBitcoinProvider["MOONPAY"] = "moonpay";
  return BuyBitcoinProvider;
}({});
export let ChannelState = /*#__PURE__*/function (ChannelState) {
  ChannelState["PENDING_OPEN"] = "pendingOpen";
  ChannelState["OPENED"] = "opened";
  ChannelState["PENDING_CLOSE"] = "pendingClose";
  ChannelState["CLOSED"] = "closed";
  return ChannelState;
}({});
export let EnvironmentType = /*#__PURE__*/function (EnvironmentType) {
  EnvironmentType["PRODUCTION"] = "production";
  EnvironmentType["STAGING"] = "staging";
  return EnvironmentType;
}({});
export let FeeratePreset = /*#__PURE__*/function (FeeratePreset) {
  FeeratePreset["REGULAR"] = "regular";
  FeeratePreset["ECONOMY"] = "economy";
  FeeratePreset["PRIORITY"] = "priority";
  return FeeratePreset;
}({});
export let HealthCheckStatus = /*#__PURE__*/function (HealthCheckStatus) {
  HealthCheckStatus["OPERATIONAL"] = "operational";
  HealthCheckStatus["MAINTENANCE"] = "maintenance";
  HealthCheckStatus["SERVICE_DISRUPTION"] = "serviceDisruption";
  return HealthCheckStatus;
}({});
export let InputTypeVariant = /*#__PURE__*/function (InputTypeVariant) {
  InputTypeVariant["BITCOIN_ADDRESS"] = "bitcoinAddress";
  InputTypeVariant["BOLT11"] = "bolt11";
  InputTypeVariant["NODE_ID"] = "nodeId";
  InputTypeVariant["URL"] = "url";
  InputTypeVariant["LN_URL_PAY"] = "lnUrlPay";
  InputTypeVariant["LN_URL_WITHDRAW"] = "lnUrlWithdraw";
  InputTypeVariant["LN_URL_AUTH"] = "lnUrlAuth";
  InputTypeVariant["LN_URL_ERROR"] = "lnUrlError";
  return InputTypeVariant;
}({});
export let LnUrlCallbackStatusVariant = /*#__PURE__*/function (LnUrlCallbackStatusVariant) {
  LnUrlCallbackStatusVariant["OK"] = "ok";
  LnUrlCallbackStatusVariant["ERROR_STATUS"] = "errorStatus";
  return LnUrlCallbackStatusVariant;
}({});
export let LnUrlPayResultVariant = /*#__PURE__*/function (LnUrlPayResultVariant) {
  LnUrlPayResultVariant["ENDPOINT_SUCCESS"] = "endpointSuccess";
  LnUrlPayResultVariant["ENDPOINT_ERROR"] = "endpointError";
  LnUrlPayResultVariant["PAY_ERROR"] = "payError";
  return LnUrlPayResultVariant;
}({});
export let LnUrlWithdrawResultVariant = /*#__PURE__*/function (LnUrlWithdrawResultVariant) {
  LnUrlWithdrawResultVariant["OK"] = "ok";
  LnUrlWithdrawResultVariant["TIMEOUT"] = "timeout";
  LnUrlWithdrawResultVariant["ERROR_STATUS"] = "errorStatus";
  return LnUrlWithdrawResultVariant;
}({});
export let Network = /*#__PURE__*/function (Network) {
  Network["BITCOIN"] = "bitcoin";
  Network["TESTNET"] = "testnet";
  Network["SIGNET"] = "signet";
  Network["REGTEST"] = "regtest";
  return Network;
}({});
export let NodeConfigVariant = /*#__PURE__*/function (NodeConfigVariant) {
  NodeConfigVariant["GREENLIGHT"] = "greenlight";
  return NodeConfigVariant;
}({});
export let NodeCredentialsVariant = /*#__PURE__*/function (NodeCredentialsVariant) {
  NodeCredentialsVariant["GREENLIGHT"] = "greenlight";
  return NodeCredentialsVariant;
}({});
export let PaymentDetailsVariant = /*#__PURE__*/function (PaymentDetailsVariant) {
  PaymentDetailsVariant["LN"] = "ln";
  PaymentDetailsVariant["CLOSED_CHANNEL"] = "closedChannel";
  return PaymentDetailsVariant;
}({});
export let PaymentStatus = /*#__PURE__*/function (PaymentStatus) {
  PaymentStatus["PENDING"] = "pending";
  PaymentStatus["COMPLETE"] = "complete";
  PaymentStatus["FAILED"] = "failed";
  return PaymentStatus;
}({});
export let PaymentType = /*#__PURE__*/function (PaymentType) {
  PaymentType["SENT"] = "sent";
  PaymentType["RECEIVED"] = "received";
  PaymentType["CLOSED_CHANNEL"] = "closedChannel";
  return PaymentType;
}({});
export let PaymentTypeFilter = /*#__PURE__*/function (PaymentTypeFilter) {
  PaymentTypeFilter["SENT"] = "sent";
  PaymentTypeFilter["RECEIVED"] = "received";
  PaymentTypeFilter["CLOSED_CHANNEL"] = "closedChannel";
  return PaymentTypeFilter;
}({});
export let ReportIssueRequestVariant = /*#__PURE__*/function (ReportIssueRequestVariant) {
  ReportIssueRequestVariant["PAYMENT_FAILURE"] = "paymentFailure";
  return ReportIssueRequestVariant;
}({});
export let ReverseSwapStatus = /*#__PURE__*/function (ReverseSwapStatus) {
  ReverseSwapStatus["INITIAL"] = "initial";
  ReverseSwapStatus["IN_PROGRESS"] = "inProgress";
  ReverseSwapStatus["CANCELLED"] = "cancelled";
  ReverseSwapStatus["COMPLETED_SEEN"] = "completedSeen";
  ReverseSwapStatus["COMPLETED_CONFIRMED"] = "completedConfirmed";
  return ReverseSwapStatus;
}({});
export let SuccessActionProcessedVariant = /*#__PURE__*/function (SuccessActionProcessedVariant) {
  SuccessActionProcessedVariant["AES"] = "aes";
  SuccessActionProcessedVariant["MESSAGE"] = "message";
  SuccessActionProcessedVariant["URL"] = "url";
  return SuccessActionProcessedVariant;
}({});
export let SwapAmountType = /*#__PURE__*/function (SwapAmountType) {
  SwapAmountType["SEND"] = "send";
  SwapAmountType["RECEIVE"] = "receive";
  return SwapAmountType;
}({});
export let SwapStatus = /*#__PURE__*/function (SwapStatus) {
  SwapStatus["INITIAL"] = "initial";
  SwapStatus["WAITING_CONFIRMATION"] = "waitingConfirmation";
  SwapStatus["REDEEMABLE"] = "redeemable";
  SwapStatus["REDEEMED"] = "redeemed";
  SwapStatus["REFUNDABLE"] = "refundable";
  SwapStatus["COMPLETED"] = "completed";
  return SwapStatus;
}({});
export const connect = async (req, listener) => {
  const subscription = BreezSDKEmitter.addListener("breezSdkEvent", listener);
  await BreezSDK.connect(req);
  return subscription;
};
export const setLogStream = async logStream => {
  const subscription = BreezSDKEmitter.addListener("breezSdkLog", logStream);
  try {
    await BreezSDK.setLogStream();
  } catch {}
  return subscription;
};
export const parseInvoice = async invoice => {
  const response = await BreezSDK.parseInvoice(invoice);
  return response;
};
export const parseInput = async s => {
  const response = await BreezSDK.parseInput(s);
  return response;
};
export const mnemonicToSeed = async phrase => {
  const response = await BreezSDK.mnemonicToSeed(phrase);
  return response;
};
export const defaultConfig = async (envType, apiKey, nodeConfig) => {
  const response = await BreezSDK.defaultConfig(envType, apiKey, nodeConfig);
  return response;
};
export const staticBackup = async req => {
  const response = await BreezSDK.staticBackup(req);
  return response;
};
export const serviceHealthCheck = async apiKey => {
  const response = await BreezSDK.serviceHealthCheck(apiKey);
  return response;
};
export const disconnect = async () => {
  await BreezSDK.disconnect();
};
export const configureNode = async req => {
  await BreezSDK.configureNode(req);
};
export const sendPayment = async req => {
  const response = await BreezSDK.sendPayment(req);
  return response;
};
export const sendSpontaneousPayment = async req => {
  const response = await BreezSDK.sendSpontaneousPayment(req);
  return response;
};
export const receivePayment = async req => {
  const response = await BreezSDK.receivePayment(req);
  return response;
};
export const payLnurl = async req => {
  const response = await BreezSDK.payLnurl(req);
  return response;
};
export const withdrawLnurl = async request => {
  const response = await BreezSDK.withdrawLnurl(request);
  return response;
};
export const lnurlAuth = async reqData => {
  const response = await BreezSDK.lnurlAuth(reqData);
  return response;
};
export const reportIssue = async req => {
  await BreezSDK.reportIssue(req);
};
export const nodeCredentials = async () => {
  const response = await BreezSDK.nodeCredentials();
  return response;
};
export const nodeInfo = async () => {
  const response = await BreezSDK.nodeInfo();
  return response;
};
export const signMessage = async req => {
  const response = await BreezSDK.signMessage(req);
  return response;
};
export const checkMessage = async req => {
  const response = await BreezSDK.checkMessage(req);
  return response;
};
export const backupStatus = async () => {
  const response = await BreezSDK.backupStatus();
  return response;
};
export const backup = async () => {
  await BreezSDK.backup();
};
export const listPayments = async req => {
  const response = await BreezSDK.listPayments(req);
  return response;
};
export const paymentByHash = async hash => {
  const response = await BreezSDK.paymentByHash(hash);
  return response;
};
export const setPaymentMetadata = async (hash, metadata) => {
  await BreezSDK.setPaymentMetadata(hash, metadata);
};
export const redeemOnchainFunds = async req => {
  const response = await BreezSDK.redeemOnchainFunds(req);
  return response;
};
export const fetchFiatRates = async () => {
  const response = await BreezSDK.fetchFiatRates();
  return response;
};
export const listFiatCurrencies = async () => {
  const response = await BreezSDK.listFiatCurrencies();
  return response;
};
export const listLsps = async () => {
  const response = await BreezSDK.listLsps();
  return response;
};
export const connectLsp = async lspId => {
  await BreezSDK.connectLsp(lspId);
};
export const fetchLspInfo = async lspId => {
  const response = await BreezSDK.fetchLspInfo(lspId);
  return response;
};
export const openChannelFee = async req => {
  const response = await BreezSDK.openChannelFee(req);
  return response;
};
export const lspId = async () => {
  const response = await BreezSDK.lspId();
  return response;
};
export const lspInfo = async () => {
  const response = await BreezSDK.lspInfo();
  return response;
};
export const closeLspChannels = async () => {
  await BreezSDK.closeLspChannels();
};
export const registerWebhook = async webhookUrl => {
  await BreezSDK.registerWebhook(webhookUrl);
};
export const unregisterWebhook = async webhookUrl => {
  await BreezSDK.unregisterWebhook(webhookUrl);
};
export const receiveOnchain = async req => {
  const response = await BreezSDK.receiveOnchain(req);
  return response;
};
export const inProgressSwap = async () => {
  const response = await BreezSDK.inProgressSwap();
  return response;
};
export const rescanSwaps = async () => {
  await BreezSDK.rescanSwaps();
};
export const redeemSwap = async swapAddress => {
  await BreezSDK.redeemSwap(swapAddress);
};
export const listRefundables = async () => {
  const response = await BreezSDK.listRefundables();
  return response;
};
export const prepareRefund = async req => {
  const response = await BreezSDK.prepareRefund(req);
  return response;
};
export const refund = async req => {
  const response = await BreezSDK.refund(req);
  return response;
};
export const listSwaps = async req => {
  const response = await BreezSDK.listSwaps(req);
  return response;
};
export const fetchReverseSwapFees = async req => {
  const response = await BreezSDK.fetchReverseSwapFees(req);
  return response;
};
export const onchainPaymentLimits = async () => {
  const response = await BreezSDK.onchainPaymentLimits();
  return response;
};
export const prepareOnchainPayment = async req => {
  const response = await BreezSDK.prepareOnchainPayment(req);
  return response;
};
export const inProgressOnchainPayments = async () => {
  const response = await BreezSDK.inProgressOnchainPayments();
  return response;
};
export const claimReverseSwap = async lockupAddress => {
  await BreezSDK.claimReverseSwap(lockupAddress);
};
export const payOnchain = async req => {
  const response = await BreezSDK.payOnchain(req);
  return response;
};
export const executeDevCommand = async command => {
  const response = await BreezSDK.executeDevCommand(command);
  return response;
};
export const generateDiagnosticData = async () => {
  const response = await BreezSDK.generateDiagnosticData();
  return response;
};
export const sync = async () => {
  await BreezSDK.sync();
};
export const recommendedFees = async () => {
  const response = await BreezSDK.recommendedFees();
  return response;
};
export const buyBitcoin = async req => {
  const response = await BreezSDK.buyBitcoin(req);
  return response;
};
export const prepareRedeemOnchainFunds = async req => {
  const response = await BreezSDK.prepareRedeemOnchainFunds(req);
  return response;
};
//# sourceMappingURL=index.js.map