Extract rust snippets and reference them

snippets/rust/src/buy_btc.rs

@@ -0,0 +1,14 @@
+use std::sync::Arc;
+
+use anyhow::Result;
+use breez_sdk_core::*;
+
+async fn buy(sdk: Arc<BreezServices>) -> Result<()> {
+    let res = sdk.buy_bitcoin(
+        BuyBitcoinRequest {
+            provider: BuyBitcoinProvider::Moonpay,
+            opening_fee_params: None})
+        .await?;
+
+    Ok(())
+}

snippets/rust/src/connecting_lsp.rs

@@ -0,0 +1,17 @@
+use std::sync::Arc;
+
+use anyhow::Result;
+use breez_sdk_core::*;
+
+async fn get_lsp_info(sdk: Arc<BreezServices>) -> Result<LspInformation> {
+    let lsp_id = sdk.lsp_id().await?;
+    let lsp_info = sdk.lsp_info().await?;
+
+    Ok(lsp_info)
+}
+
+async fn connect_lsp(sdk: Arc<BreezServices>, lsp_id: String) -> Result<()> {
+    sdk.connect_lsp(lsp_id).await?;
+
+    Ok(())
+}

snippets/rust/src/fiat_currencies.rs

@@ -0,0 +1,40 @@
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use anyhow::Result;
+use breez_sdk_core::*;
+
+async fn list_supported_fiat_currencies(sdk: Arc<BreezServices>) -> Result<()> {
+    let supported_fiat_currencies = sdk.list_fiat_currencies().await?;
+
+    Ok(())
+}
+
+async fn get_current_rates(sdk: Arc<BreezServices>) -> Result<()> {
+    let fiat_rates = sdk.fetch_fiat_rates().await?;
+
+    Ok(())
+}
+
+async fn get_fiat_currencies_and_rates(sdk: Arc<BreezServices>) -> Result<Vec<(FiatCurrency, Rate)>> {
+    let supported_fiat_currencies = sdk.list_fiat_currencies().await?;
+    let fiat_rates = sdk.fetch_fiat_rates().await?;
+
+    let mut rates_map : HashMap<String, Rate> = HashMap::new();
+    for rate in fiat_rates {
+        rates_map.insert(rate.coin.to_string().to_lowercase(), rate);
+    }
+
+    let mut sorted = supported_fiat_currencies.clone();
+    sorted.sort_by_key(|f| f.info.name);
+
+    let mut result : Vec<(FiatCurrency, Rate)> = Vec::new();
+    for currency in sorted {
+        let rate = rates_map.get(&currency.id.to_lowercase());
+        if let Some(rate) = rate.cloned() {
+            result.push((currency, rate));
+        }
+    }
+
+    Ok(result)
+}

snippets/rust/src/getting_started.rs

@@ -0,0 +1,47 @@
+use anyhow::Result;
+use bip39::{Language, Mnemonic};
+use breez_sdk_core::*;
+use std::sync::Arc;
+
+use crate::AppEventListener;
+
+async fn getting_started() -> Result<Arc<BreezServices>> {
+    let mnemonic = Mnemonic::generate_in(Language::English, 12)?;
+    let seed = mnemonic.to_seed("");
+    let invite_code = Some("<invite code>".into());
+    let api_key = "<api key>".into();
+
+    // Create the default config
+    let mut config = BreezServices::default_config(
+        EnvironmentType::Production,
+        api_key,
+        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?;
+
+    Ok(sdk)
+}
+
+async fn getting_started_node_info(sdk: Arc<BreezServices>) -> Result<()> {
+    if let Some(node_state) = sdk.node_info()? {
+        let balance_ln = node_state.channels_balance_msat;
+        let balance_onchain = node_state.onchain_balance_msat;
+    }
+
+    Ok(())
+}

snippets/rust/src/list_payments.rs

@@ -0,0 +1,30 @@
+use std::sync::Arc;
+
+use anyhow::Result;
+use breez_sdk_core::*;
+
+async fn list_payments(sdk: Arc<BreezServices>) -> Result<Vec<Payment>> {
+    let payments = sdk.list_payments(
+        ListPaymentRequest {
+            filter: PaymentTypeFilter::All,
+            from_timestamp: None,
+            to_timestamp: None,
+            include_failures: None,
+        }
+    ).await?;
+
+    Ok(payments)
+}
+
+async fn list_payments_filtered(sdk: Arc<BreezServices>) -> Result<Vec<Payment>> {
+    let payments = sdk.list_payments(
+        ListPaymentRequest {
+            filter: PaymentTypeFilter::Sent,
+            from_timestamp: 1696880000,
+            to_timestamp: None,
+            include_failures: true,
+        }
+    ).await?;
+
+    Ok(payments)
+}

snippets/rust/src/lnurl_auth.rs

@@ -0,0 +1,28 @@
+use std::sync::Arc;
+
+use anyhow::Result;
+use breez_sdk_core::*;
+use breez_sdk_core::InputType::LnUrlAuth;
+use log::{error, info};
+
+async fn auth(sdk: Arc<BreezServices>) -> Result<()> {
+    // Endpoint can also be of the form:
+    // keyauth://domain.com/auth?key=val
+    let lnurl_auth_url = "lnurl1dp68gurn8ghj7mr0vdskc6r0wd6z7mrww4excttvdankjm3lw3skw0tvdankjm3xdvcn6vtp8q6n2dfsx5mrjwtrxdjnqvtzv56rzcnyv3jrxv3sxqmkyenrvv6kve3exv6nqdtyv43nqcmzvdsnvdrzx33rsenxx5unqc3cxgeqgntfgu";
+
+    if let Ok(LnUrlAuth{data: ad}) = parse(lnurl_auth_url).await {
+        match sdk.lnurl_auth(ad).await {
+            Ok(LnUrlCallbackStatus::Ok) => {
+                info!("Successfully authenticated")
+            }
+            Ok(LnUrlCallbackStatus::ErrorStatus { data }) => {
+                error!("Failed to authenticate: {}", data.reason)
+            }
+            Err(e) => {
+                error!("Failed to connect: {e}")
+            }
+        }
+    }
+
+    Ok(())
+}

snippets/rust/src/lnurl_pay.rs

@@ -0,0 +1,22 @@
+use std::sync::Arc;
+
+use anyhow::Result;
+use breez_sdk_core::*;
+use breez_sdk_core::InputType::LnUrlPay;
+
+async fn pay(sdk: Arc<BreezServices>) -> Result<()> {
+    // Endpoint can also be of the form:
+    // lnurlp://domain.com/lnurl-pay?key=val
+    // lnurl1dp68gurn8ghj7mr0vdskc6r0wd6z7mrww4excttsv9un7um9wdekjmmw84jxywf5x43rvv35xgmr2enrxanr2cfcvsmnwe3jxcukvde48qukgdec89snwde3vfjxvepjxpjnjvtpxd3kvdnxx5crxwpjvyunsephsz36jf
+    let lnurl_pay_url = "lightning@address.com";
+
+    if let Ok(LnUrlPay{data: pd}) = parse(lnurl_pay_url).await {
+        // TODO Show payment details in UI, read user input
+        let amount_msat = pd.min_sendable;
+        let comment = "Test payment".to_string();
+
+        sdk.lnurl_pay(amount_msat, Some(comment), pd).await?;
+    }
+
+    Ok(())
+}

snippets/rust/src/lnurl_withdraw.rs

@@ -0,0 +1,19 @@
+use std::sync::Arc;
+
+use anyhow::Result;
+use breez_sdk_core::*;
+
+async fn withdraw(sdk: Arc<BreezServices>) -> Result<()> {
+    // Endpoint can also be of the form:
+    // lnurlw://domain.com/lnurl-withdraw?key=val
+    let lnurl_withdraw_url = "lnurl1dp68gurn8ghj7mr0vdskc6r0wd6z7mrww4exctthd96xserjv9mn7um9wdekjmmw843xxwpexdnxzen9vgunsvfexq6rvdecx93rgdmyxcuxverrvcursenpxvukzv3c8qunsdecx33nzwpnvg6ryc3hv93nzvecxgcxgwp3h33lxk";
+
+    if let Ok(LnUrlWithdraw{data: wd}) = parse(lnurl_withdraw_url).await {
+        let amount_msat = wd.min_withdrawable;
+        let description = "Test withdraw".to_string();
+
+        sdk.lnurl_withdraw(wd, amount_msat, Some(description)).await?;
+    }
+
+    Ok(())
+}

snippets/rust/src/main.rs

@@ -0,0 +1,32 @@
+mod getting_started;
+mod receive_payment;
+mod send_payment;
+mod send_spontaneous_payment;
+mod list_payments;
+mod connecting_lsp;
+mod receive_onchain;
+mod send_onchain;
+mod lnurl_pay;
+mod lnurl_withdraw;
+mod lnurl_auth;
+mod fiat_currencies;
+mod buy_btc;
+mod static_channel_backup;
+
+use std::str::FromStr;
+
+use anyhow::Result;
+use breez_sdk_core::*;
+use log::info;
+
+struct AppEventListener {}
+impl EventListener for AppEventListener {
+    fn on_event(&self, e: BreezEvent) {
+        info!("Received Breez event: {e:?}");
+    }
+}
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    Ok(())
+}

snippets/rust/src/receive_onchain.rs

@@ -0,0 +1,43 @@
+use std::sync::Arc;
+
+use anyhow::Result;
+use breez_sdk_core::*;
+
+async fn generate_receive_onchain_address(sdk: Arc<BreezServices>) -> Result<()> {
+    let swap_info = sdk.receive_onchain(
+        ReceiveOnchainRequest { opening_fee_params: None } )
+        .await?;
+
+    // Send your funds to the below bitcoin address
+    let address = swap_info.bitcoin_address;
+
+    Ok(())
+}
+
+async fn get_in_progress_swap(sdk: Arc<BreezServices>) -> Result<()> {
+    let swap_info = sdk.in_progress_swap().await?;
+
+    Ok(())
+}
+
+async fn list_refundables(sdk: Arc<BreezServices>) -> Result<()> {
+    let refundables = sdk.list_refundables().await?;
+
+    Ok(())
+}
+
+async fn execute_refund(sdk: Arc<BreezServices>, refund_tx_fee_rate: u32, refundable: SwapInfo) -> Result<()> {
+    let destination_address = "...".into();
+    let sat_per_vbyte = refund_tx_fee_rate;
+    sdk.refund(refundable.bitcoin_address, destination_address, sat_per_vbyte).await?;
+
+    Ok(())
+}
+
+async fn get_channel_opening_fees(sdk: Arc<BreezServices>, amount_msat: u64) -> Result<()> {
+    let channel_fees = sdk.open_channel_fee(
+        OpenChannelFeeRequest { amount_msat, expiry: None })
+        .await?;
+
+    Ok(())
+}

snippets/rust/src/receive_payment.rs

@@ -0,0 +1,20 @@
+use std::sync::Arc;
+
+use anyhow::Result;
+use breez_sdk_core::*;
+
+async fn receive_payment(sdk: Arc<BreezServices>) -> Result<()> {
+    let res = sdk.receive_payment(
+        ReceivePaymentRequest {
+            amount_sats: 3000,
+            description: "Invoice for 3000 sats".into(),
+            cltv: None,
+            expiry: None,
+            opening_fee_params: None,
+            preimage: None,
+            use_description_hash: None
+        })
+        .await?;
+
+    Ok(())
+}

snippets/rust/src/send_onchain.rs

@@ -0,0 +1,42 @@
+use std::sync::Arc;
+
+use anyhow::Result;
+use breez_sdk_core::*;
+use log::info;
+
+async fn get_current_fees(sdk: Arc<BreezServices>) -> Result<()> {
+    let current_fees = sdk.fetch_reverse_swap_fees(
+        ReverseSwapFeesRequest {
+            send_amount_sat: Some(50000),
+        })
+        .await?;
+
+    info!("Total estimated fees for reverse swap: {:?}", current_fees.total_estimated_fees);
+
+    Ok(())
+}
+
+async fn list_current_fees(sdk: Arc<BreezServices>, current_fees: ReverseSwapPairInfo) -> Result<()> {
+    info!("Minimum amount, in sats: {}", current_fees.min);
+    info!("Maximum amount, in sats: {}", current_fees.max);
+
+    Ok(())
+}
+
+async fn start_reverse_swap(sdk: Arc<BreezServices>, current_fees: ReverseSwapPairInfo, fee_rate: u64) -> Result<()> {
+    let destination_address = String::from("bc1..");
+    let amount_sat = current_fees.min;
+    let satPerVbyte = fee_rate;
+
+    sdk.send_onchain(amount_sat, destination_address, current_fees.fees_hash, satPerVbyte).await?;
+
+    Ok(())
+}
+
+async fn check_reverse_swap_status(sdk: Arc<BreezServices>) -> Result<()> {
+    for rs in sdk.in_progress_reverse_swaps().await? {
+        info!("Reverse swap {} in progress, status is {:?}", rs.id, rs.status);
+    }
+
+    Ok(())
+}

snippets/rust/src/send_payment.rs

@@ -0,0 +1,11 @@
+use std::sync::Arc;
+
+use anyhow::Result;
+use breez_sdk_core::*;
+
+async fn send_payment(sdk: Arc<BreezServices>) -> Result<()> {
+    let bolt11 = "...";
+    sdk.send_payment(bolt11.into(), None).await?;
+
+    Ok(())
+}

snippets/rust/src/send_spontaneous_payment.rs

@@ -0,0 +1,11 @@
+use std::sync::Arc;
+
+use anyhow::Result;
+use breez_sdk_core::*;
+
+async fn send_spontaneous_payment(sdk: Arc<BreezServices>) -> Result<()> {
+    let node_id = "...";
+    sdk.send_spontaneous_payment(node_id.into(), 3000).await?;
+
+    Ok(())
+}

snippets/rust/src/static_channel_backup.rs

@@ -0,0 +1,10 @@
+use anyhow::Result;
+use breez_sdk_core::*;
+
+async fn retrieve_backup_files() -> Result<()> {
+    let backup_data = BreezServices::static_backup(StaticBackupRequest {
+        working_dir: "<working directory>".into(),
+    })?;
+
+    Ok(())
+}