Crate breez_sdk_core
source ·Expand description
§Breez SDK
The Breez SDK enables mobile developers to integrate Lightning and bitcoin payments into their apps with a very shallow learning curve. The use cases are endless – from social apps that want to integrate tipping between users to content-creation apps interested in adding bitcoin monetization. Crucially, this SDK is an end-to-end, non-custodial, drop-in solution powered by Greenlight, a built-in LSP, on-chain interoperability, third-party fiat on-ramps, and other services users and operators need.
The Breez SDK provides the following services:
- Sending payments (via various protocols such as: bolt11, keysend, lnurl-pay, lightning address, etc.)
- Receiving payments (via various protocols such as: bolt11, lnurl-withdraw, etc.)
- Fetching node status (e.g. balance, max allow to pay, max allow to receive, on-chain balance, etc.)
- Connecting to a new or existing node.
§Getting Started
First, make sure you have your API Key and Invite Code ready (see API Key and Invite Code section below).
The following code initialize the SDK and make it ready to be used:
let mnemonic = Mnemonic::generate_in(Language::English, 12)?;
let seed = mnemonic.to_seed("");
let invite_code = Some("...".into());
let mut config = BreezServices::default_config(
EnvironmentType::Production,
"your API key".into(),
breez_sdk_core::NodeConfig::Greenlight {
config: GreenlightNodeConfig { partner_credentials: None, invite_code },
},
);
// Customize the config object according to your needs
config.working_dir = "path to an existing directory".into();
// Connect to the Breez SDK make it ready for use
let sdk = BreezServices::connect(
config,
seed.to_vec(),
Box::new(AppEventListener {}),
)
.await?;
We can now receive payments
let invoice = sdk.receive_payment(3000, "Invoice for 3000 sats".into()).await?;
or make payments
let bolt11 = "...";
sdk.send_payment(bolt11.into(), Some(3000)).await?;
At any point we can fetch our balance from the Greenlight node
if let Some(node_state) = sdk.node_info()? {
let balance_ln = node_state.channels_balance_msat;
let balance_onchain = node_state.onchain_balance_msat;
}
or fetch other useful infos, like the current mempool RecommendedFees
let fees: RecommendedFees = sdk.recommended_fees().await?;
These different types of operations are described below in more detail.
§A. Initializing the SDK
There are two simple steps necessary to initialize the SDK:
- BreezServices::default_config to construct the sdk configuration
- BreezServices::connect to connect to your node and start all required Breez SDK services
The first step takes the EnvironmentType and NodeConfig as arguments. Although you can create your own config from scratch it is recommended to use the BreezServices::default_config method and customize it according to your needs. Once the NodeConfig is created it is passed to the BreezServices::connect method along with the seed and and implementation of EventListener which is used to notify the caller of SDK events.
Now your SDK is ready to be used.
§B. Sending and receiving Lightning payments
Supported BOLT11 operations are
- BreezServices::receive_payment to create an invoice
- BreezServices::send_payment to pay an invoice
- BreezServices::send_spontaneous_payment for keysend payments
§C. Receiving an on-chain transaction (swap-in)
- BreezServices::receive_onchain accepting an optional user-selected OpeningFeeParams for the case when the operation requires a new channel with the LSP
- BreezServices::in_progress_swap
- BreezServices::list_refundables to get a list of swaps
- BreezServices::refund to broadcast a transaction for failed or expired swaps
§D. Sending to an on-chain address (swap-out)
- BreezServices::fetch_reverse_swap_fees to get the current swap-out fees
- BreezServices::send_onchain to start the swap-out
- BreezServices::in_progress_reverse_swaps to see any in-progress swaps
§E. Using LNURL
- parse the LNURL endpoint URL to get the workflow parameters.
- After getting the user input or confirmation, complete the workflow with BreezServices::lnurl_pay or BreezServices::lnurl_withdraw.
§F. Supporting fiat currencies
- BreezServices::list_fiat_currencies to get the supported fiat currencies
- BreezServices::fetch_fiat_rates to get the current exchange rates
- BreezServices::recommended_fees for the recommended mempool fees
§G. Connecting to an LSP
- BreezServices::list_lsps to get a list of available LSPs
- BreezServices::connect_lsp to connect to a chosen LSP
- BreezServices::lsp_info to get LspInformation on the currently selected LSP
§H. Utilities
Use parse to parse generic input. The input can come from the user, from a clicked link or from a QR code. The resulting InputType will tell you what the input is and how to treat it, as well as present relevant payload data in a structured form.
§Bindings
- C#
- Dart
- Go
- Kotlin
- Python
- React-Native
- Swift
§API Key and Invite Code
You will need an API Key to use the SDK, as well as an Invite Code when you create a new node.
To get both of them, please contact Breez via email at contact@breez.technology or at https://breez.technology/#contact-us-form
§Support
Join this telegram group.
Re-exports§
pub use input_parser::parse;
pub use input_parser::BitcoinAddressData;
pub use input_parser::InputType;
pub use input_parser::LnUrlAuthRequestData;
pub use input_parser::LnUrlErrorData;
pub use input_parser::LnUrlPayRequestData;
pub use input_parser::LnUrlRequestData;
pub use input_parser::LnUrlWithdrawRequestData;
pub use input_parser::MetadataItem;
Modules§
- Bindings for the Dart integration
Macros§
Structs§
- Payload of the AES success action, as received from the LNURL endpoint
- Wrapper for the decrypted AesSuccessActionData payload
- BreezServices is a facade and the single entry point for the SDK.
- Lightning channel
- Request to check a message was signed by a specific node id.
- Response to a CheckMessageRequest
- Represents the funds that were on the user side of the channel at the time it was closed.
- Configuration for the Breez Services
- Represents a configure node request.
- Represents a connect request.
- Details about a supported currency in the fiat rate feed
- Wrapper around the CurrencyInfo of a fiat currency
- Details of past or ongoing reverse swaps, as stored in the Breez local DB
- Client-specific credentials to connect to and manage a Greenlight node in the cloud
- Details of an invoice that has been paid, included as payload in an emitted BreezEvent
- Wrapper for a BOLT11 LN invoice
- Represents a list payments request.
- Details of a LN payment, as included in a Payment
- Represents a LNURL-pay request.
- Locale-specific settings for the representation of a currency
- Localized name of a currency
- Internal SDK log entry
- Details of supported LSP
- A metadata filter which can be applied when retrieving the transaction list
- The node state of a Greenlight LN node running in the cloud.
- Dynamic fee parameters offered by the LSP for opening a new channel.
- Represents a payment, including its PaymentType and PaymentDetails
- Represents a payments external information.
- Represents a payment response.
- Contains fields describing the reverse swap parameters (see ReverseSwapPairInfo), as well as the resulting send and receive amounts.
- We need to prepare a redeem_onchain_funds transaction to know what fee will be charged in satoshis. This model holds the request data which consists of the address to redeem on-chain funds to and the fee rate in. satoshis per vbyte which will be converted to absolute satoshis.
- We need to prepare a redeem_onchain_funds transaction to know what a fee it will be charged in satoshis this model holds the response data, which consists of the weight and the absolute fee in sats
- Denominator in an exchange rate
- Represents a receive payment request.
- Represents a receive payment response.
- Wrapper containing the result of the recommended fees query, in sat/vByte, based on mempool.space data
- Simplified version of FullReverseSwapInfo, containing only the user-relevant fields
- Details about the reverse swap fees and parameters, at this point in time
- A route hint for a LN payment
- Details of a specific hop in a larger route hint
- Represents a send payment request.
- Represents a send payment response.
- Represents a send spontaneous payment request.
- Represents a service health check response.
- Request to sign a message with the node’s private key.
- Response to a SignMessageRequest.
- Summary of an ongoing swap
- Represents the details of an on-going swap.
- Settings for the symbol representation of a currency
- Internal response to a [crate::node_api::NodeAPI::pull_changed] call
- Represents a TLV entry for a keysend payment.
- UTXO known to the LN node
Enums§
- Result of decryption of AesSuccessActionData payload
- Event emitted by the SDK. To listen for and react to these events, use an EventListener when initializing the BreezServices.
- Different providers will demand different behaviours when the user is trying to buy bitcoin.
- State of a Lightning channel
- Indicates the different kinds of supported environments for crate::BreezServices.
- Different types of supported feerates
- Indicates the different service health check statuses.
- Contains the result of the entire LNURL interaction, as reported by the LNURL endpoint.
- Contains the result of the entire LNURL-pay interaction, as reported by the LNURL endpoint.
- LnUrlCallbackStatus specific to LNURL-withdraw, where the success case contains the invoice.
- The different supported bitcoin networks
- Wrapper for the different types of payments
- The status of a payment
- Different types of supported payments
- Different types of supported filters which can be applied when retrieving the transaction list
- Represents a report issue request.
- The possible statuses of a reverse swap, from the Breez SDK perspective.
- Supported success action types
- SuccessAction where contents are ready to be consumed by the caller
- The status of a swap
Constants§
Traits§
- Trait that can be used to react to various BreezEvents emitted by the SDK.
- Trait covering fiat-related functionality
- Trait covering LSP-related functionality
- Trait covering support-related functionality
- Trait covering functionality involving swaps
Functions§
- Attempts to convert the phrase to a mnemonic, then to a seed.
- Parse a BOLT11 payment request and return a structure contains the parsed fields.