@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;

(function (AesSuccessActionDataResultVariant) {
  AesSuccessActionDataResultVariant["DECRYPTED"] = "decrypted";
  AesSuccessActionDataResultVariant["ERROR_STATUS"] = "errorStatus";
})(AesSuccessActionDataResultVariant || (AesSuccessActionDataResultVariant = {}));

export let BreezEventVariant;

(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";
})(BreezEventVariant || (BreezEventVariant = {}));

export let BuyBitcoinProvider;

(function (BuyBitcoinProvider) {
  BuyBitcoinProvider["MOONPAY"] = "moonpay";
})(BuyBitcoinProvider || (BuyBitcoinProvider = {}));

export let ChannelState;

(function (ChannelState) {
  ChannelState["PENDING_OPEN"] = "pendingOpen";
  ChannelState["OPENED"] = "opened";
  ChannelState["PENDING_CLOSE"] = "pendingClose";
  ChannelState["CLOSED"] = "closed";
})(ChannelState || (ChannelState = {}));

export let EnvironmentType;

(function (EnvironmentType) {
  EnvironmentType["PRODUCTION"] = "production";
  EnvironmentType["STAGING"] = "staging";
  EnvironmentType["REGTEST"] = "regtest";
})(EnvironmentType || (EnvironmentType = {}));

export let FeeratePreset;

(function (FeeratePreset) {
  FeeratePreset["REGULAR"] = "regular";
  FeeratePreset["ECONOMY"] = "economy";
  FeeratePreset["PRIORITY"] = "priority";
})(FeeratePreset || (FeeratePreset = {}));

export let HealthCheckStatus;

(function (HealthCheckStatus) {
  HealthCheckStatus["OPERATIONAL"] = "operational";
  HealthCheckStatus["MAINTENANCE"] = "maintenance";
  HealthCheckStatus["SERVICE_DISRUPTION"] = "serviceDisruption";
})(HealthCheckStatus || (HealthCheckStatus = {}));

export let InputTypeVariant;

(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";
})(InputTypeVariant || (InputTypeVariant = {}));

export let LnUrlCallbackStatusVariant;

(function (LnUrlCallbackStatusVariant) {
  LnUrlCallbackStatusVariant["OK"] = "ok";
  LnUrlCallbackStatusVariant["ERROR_STATUS"] = "errorStatus";
})(LnUrlCallbackStatusVariant || (LnUrlCallbackStatusVariant = {}));

export let LnUrlPayResultVariant;

(function (LnUrlPayResultVariant) {
  LnUrlPayResultVariant["ENDPOINT_SUCCESS"] = "endpointSuccess";
  LnUrlPayResultVariant["ENDPOINT_ERROR"] = "endpointError";
  LnUrlPayResultVariant["PAY_ERROR"] = "payError";
})(LnUrlPayResultVariant || (LnUrlPayResultVariant = {}));

export let LnUrlWithdrawResultVariant;

(function (LnUrlWithdrawResultVariant) {
  LnUrlWithdrawResultVariant["OK"] = "ok";
  LnUrlWithdrawResultVariant["TIMEOUT"] = "timeout";
  LnUrlWithdrawResultVariant["ERROR_STATUS"] = "errorStatus";
})(LnUrlWithdrawResultVariant || (LnUrlWithdrawResultVariant = {}));

export let Network;

(function (Network) {
  Network["BITCOIN"] = "bitcoin";
  Network["TESTNET"] = "testnet";
  Network["SIGNET"] = "signet";
  Network["REGTEST"] = "regtest";
})(Network || (Network = {}));

export let NodeConfigVariant;

(function (NodeConfigVariant) {
  NodeConfigVariant["GREENLIGHT"] = "greenlight";
})(NodeConfigVariant || (NodeConfigVariant = {}));

export let NodeCredentialsVariant;

(function (NodeCredentialsVariant) {
  NodeCredentialsVariant["GREENLIGHT"] = "greenlight";
})(NodeCredentialsVariant || (NodeCredentialsVariant = {}));

export let PaymentDetailsVariant;

(function (PaymentDetailsVariant) {
  PaymentDetailsVariant["LN"] = "ln";
  PaymentDetailsVariant["CLOSED_CHANNEL"] = "closedChannel";
})(PaymentDetailsVariant || (PaymentDetailsVariant = {}));

export let PaymentStatus;

(function (PaymentStatus) {
  PaymentStatus["PENDING"] = "pending";
  PaymentStatus["COMPLETE"] = "complete";
  PaymentStatus["FAILED"] = "failed";
})(PaymentStatus || (PaymentStatus = {}));

export let PaymentType;

(function (PaymentType) {
  PaymentType["SENT"] = "sent";
  PaymentType["RECEIVED"] = "received";
  PaymentType["CLOSED_CHANNEL"] = "closedChannel";
})(PaymentType || (PaymentType = {}));

export let PaymentTypeFilter;

(function (PaymentTypeFilter) {
  PaymentTypeFilter["SENT"] = "sent";
  PaymentTypeFilter["RECEIVED"] = "received";
  PaymentTypeFilter["CLOSED_CHANNEL"] = "closedChannel";
})(PaymentTypeFilter || (PaymentTypeFilter = {}));

export let ReportIssueRequestVariant;

(function (ReportIssueRequestVariant) {
  ReportIssueRequestVariant["PAYMENT_FAILURE"] = "paymentFailure";
})(ReportIssueRequestVariant || (ReportIssueRequestVariant = {}));

export let ReverseSwapStatus;

(function (ReverseSwapStatus) {
  ReverseSwapStatus["INITIAL"] = "initial";
  ReverseSwapStatus["IN_PROGRESS"] = "inProgress";
  ReverseSwapStatus["CANCELLED"] = "cancelled";
  ReverseSwapStatus["COMPLETED_SEEN"] = "completedSeen";
  ReverseSwapStatus["COMPLETED_CONFIRMED"] = "completedConfirmed";
})(ReverseSwapStatus || (ReverseSwapStatus = {}));

export let SuccessActionProcessedVariant;

(function (SuccessActionProcessedVariant) {
  SuccessActionProcessedVariant["AES"] = "aes";
  SuccessActionProcessedVariant["MESSAGE"] = "message";
  SuccessActionProcessedVariant["URL"] = "url";
})(SuccessActionProcessedVariant || (SuccessActionProcessedVariant = {}));

export let SwapAmountType;

(function (SwapAmountType) {
  SwapAmountType["SEND"] = "send";
  SwapAmountType["RECEIVE"] = "receive";
})(SwapAmountType || (SwapAmountType = {}));

export let SwapStatus;

(function (SwapStatus) {
  SwapStatus["INITIAL"] = "initial";
  SwapStatus["WAITING_CONFIRMATION"] = "waitingConfirmation";
  SwapStatus["REDEEMABLE"] = "redeemable";
  SwapStatus["REDEEMED"] = "redeemed";
  SwapStatus["REFUNDABLE"] = "refundable";
  SwapStatus["COMPLETED"] = "completed";
})(SwapStatus || (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