From d206646bab345ca5b9253d842c013c483131ae8c Mon Sep 17 00:00:00 2001
From: Aljaz Ceru <aljaz@ceru.si>
Date: Fri, 18 Apr 2025 17:04:01 +0200
Subject: [PATCH 1/2] llm context files

---
 .../breez-nodeless-dart-llms.md               |  813 ++++++++
 .../breez-nodeless-reactnative-llms.md        | 1832 +++++++++++++++++
 .../breez-nodeless-rust-llms.md               | 1398 +++++++++++++
 .../breez-nodeless-wasm-llms.md               | 1366 ++++++++++++
 4 files changed, 5409 insertions(+)
 create mode 100644 examples/breez-nodeless-llms/breez-nodeless-dart-llms.md
 create mode 100644 examples/breez-nodeless-llms/breez-nodeless-reactnative-llms.md
 create mode 100644 examples/breez-nodeless-llms/breez-nodeless-rust-llms.md
 create mode 100644 examples/breez-nodeless-llms/breez-nodeless-wasm-llms.md

diff --git a/examples/breez-nodeless-llms/breez-nodeless-dart-llms.md b/examples/breez-nodeless-llms/breez-nodeless-dart-llms.md
new file mode 100644
index 00000000..41e5923c
--- /dev/null
+++ b/examples/breez-nodeless-llms/breez-nodeless-dart-llms.md
@@ -0,0 +1,813 @@
+# Breez SDK Nodeless (Liquid implementation) Documentation
+
+This comprehensive document provides all the context needed to build applications with the Dart bindings of Breez SDK Nodeless, a toolkit for integrating Bitcoin, Lightning Network, and Liquid Network functionality into your applications.
+
+## Overview
+
+Breez SDK Nodeless (Liquid implementation) is a powerful library that allows developers to integrate Bitcoin, Lightning Network, and Liquid Network functionality into their applications. The SDK abstracts many of the complexities of working with these technologies, providing a simple interface for common operations such as sending and receiving payments, managing wallets, and interacting with both Lightning and Liquid networks.
+
+Key capabilities include:
+- Wallet management and balance tracking
+- Lightning Network payments
+- Liquid Network transactions
+- Onchain Bitcoin operations
+- LNURL support (auth, pay, withdraw)
+- Non-Bitcoin asset management
+- Webhook integration
+- Event handling with listeners
+
+## Getting Started
+
+### Installation
+
+```yaml
+# In your pubspec.yaml
+dependencies:
+  flutter_breez_liquid: 
+    git:
+      url: https://github.com/breez/breez-sdk-liquid-flutter
+      tag: 0.7.2
+```
+
+### Guidelines
+- **always make sure the sdk instance is synced before performing any actions**
+- **Add logging**: Add sufficient logging into your application to diagnose any issues users are having.
+- **Display pending payments**: Payments always contain a status field that can be used to determine if the payment was completed or not. Make sure you handle the case where the payment is still pending by showing the correct status to the user.
+- **Enable swap refunds**: Swaps that are the result of receiving an On-Chain Transaction may not be completed and change to `Refundable` state. Make sure you handle this case correctly by allowing the user to retry the refund with different fees as long as the refund is not confirmed.
+- **Expose swap fees**: When sending or receiving on-chain, make sure to clearly show the expected fees involved, as well as the send / receive amounts.
+
+### Initializing the SDK
+
+To get started with Breez SDK Nodeless (Liquid implementation), you need to initialize the SDK with your configuration:
+
+```dart
+import 'package:flutter_breez_liquid/flutter_breez_liquid.dart';
+
+Future<void> initializeSDK() async {
+  // Your mnemonic seed phrase for wallet recovery
+  String mnemonic = "<mnemonic words>";
+
+  // Create the default config, providing your Breez API key
+  Config config = defaultConfig(
+    network: LiquidNetwork.mainnet, 
+    breezApiKey: "<your-Breez-API-key>"
+  );
+
+  // Customize the config object according to your needs
+  config = config.copyWith(workingDir: "path to an existing directory");
+
+  ConnectRequest connectRequest = ConnectRequest(mnemonic: mnemonic, config: config);
+
+  try {
+    await breezSDKLiquid.connect(req: connectRequest);
+  } catch (error) {
+    print(error);
+    rethrow;
+  }
+}
+```
+
+### Custom Signer Support
+
+If you prefer to manage your own keys, you can use a custom signer:
+
+```dart
+import 'package:flutter_breez_liquid/flutter_breez_liquid.dart';
+
+class CustomSigner implements Signer {
+  @override
+  Future<String> sign(String message) async {
+    // Your custom signing implementation
+    return "<signed message>";
+  }
+}
+
+Future<void> connectWithCustomSigner() async {
+  CustomSigner signer = CustomSigner();
+  
+  // Create the default config, providing your Breez API key
+  Config config = defaultConfig(
+    network: LiquidNetwork.mainnet, 
+    breezApiKey: "<your-Breez-API-key>"
+  );
+
+  // Customize the config object according to your needs
+  config = config.copyWith(workingDir: "path to an existing directory");
+
+  try {
+    ConnectWithSignerRequest request = ConnectWithSignerRequest(config: config);
+    await breezSDKLiquid.connectWithSigner(req: request, signer: signer);
+  } catch (error) {
+    print(error);
+    rethrow;
+  }
+}
+```
+
+### Basic Operations
+
+#### Fetch Balance
+- **always make sure the sdk instance is synced before performing any actions**
+
+```dart
+Future<void> fetchBalance() async {
+  try {
+    GetInfoResponse? info = await breezSDKLiquid.instance!.getInfo();
+    BigInt balanceSat = info.walletInfo.balanceSat;
+    BigInt pendingSendSat = info.walletInfo.pendingSendSat;
+    BigInt pendingReceiveSat = info.walletInfo.pendingReceiveSat;
+  } catch (error) {
+    print(error);
+    rethrow;
+  }
+}
+```
+
+#### Logging and Event Handling
+
+```dart
+// Set up logging
+void initializeLogStream() {
+  // Initialize the log stream
+  Stream<LogEntry>? breezLogStream = breezLogStream().asBroadcastStream();
+  
+  // Subscribe to the log stream
+  breezLogStream?.listen((logEntry) {
+    print("${logEntry.level}: ${logEntry.line}");
+  }, onError: (error) {
+    print("Log stream error: $error");
+  });
+}
+
+// Define an event listener
+class SdkListener extends EventListener {
+  @override
+  void onEvent(SdkEvent sdkEvent) {
+    print("Received event: $sdkEvent");
+    
+    if (sdkEvent is SdkEvent_Synced) {
+      print("SDK is synced");
+    } else if (sdkEvent is SdkEvent_PaymentSucceeded) {
+      print("Payment succeeded: ${sdkEvent.details.paymentHash}");
+    } else if (sdkEvent is SdkEvent_PaymentFailed) {
+      print("Payment failed: ${sdkEvent.details.error}");
+    }
+  }
+}
+
+// Add an event listener
+Future<void> addEventListeners() async {
+  try {
+    SdkListener listener = SdkListener();
+    breezSDKLiquid.instance!.addEventListener().listen(listener.onEvent);
+  } catch (error) {
+    print(error);
+    rethrow;
+  }
+}
+```
+
+## Core Features
+
+### Buying Bitcoin
+
+```dart
+import 'package:flutter_breez_liquid/flutter_breez_liquid.dart';
+
+Future<OnchainPaymentLimitsResponse> fetchOnchainLimits() async {
+  try {
+    OnchainPaymentLimitsResponse currentLimits = await breezSDKLiquid.instance!.fetchOnchainLimits();
+    print("Minimum amount: ${currentLimits.receive.minSat} sats");
+    print("Maximum amount: ${currentLimits.receive.maxSat} sats");
+    return currentLimits;
+  } catch (error) {
+    print(error);
+    rethrow;
+  }
+}
+
+Future<PrepareBuyBitcoinResponse> prepareBuyBitcoin(OnchainPaymentLimitsResponse currentLimits) async {
+  try {
+    PrepareBuyBitcoinRequest req =
+        PrepareBuyBitcoinRequest(provider: BuyBitcoinProvider.moonpay, amountSat: currentLimits.receive.minSat);
+    PrepareBuyBitcoinResponse prepareRes = await breezSDKLiquid.instance!.prepareBuyBitcoin(req: req);
+
+    // Check the fees are acceptable before proceeding
+    BigInt receiveFeesSat = prepareRes.feesSat;
+    print("Fees: $receiveFeesSat sats");
+    return prepareRes;
+  } catch (error) {
+    print(error);
+    rethrow;
+  }
+}
+
+Future<String> buyBitcoin(PrepareBuyBitcoinResponse prepareResponse) async {
+  try {
+    BuyBitcoinRequest req = BuyBitcoinRequest(prepareResponse: prepareResponse);
+    String url = await breezSDKLiquid.instance!.buyBitcoin(req: req);
+    return url;
+  } catch (error) {
+    print(error);
+    rethrow;
+  }
+}
+```
+
+### Fiat Currencies
+
+```dart
+Future<List<FiatCurrency>> listFiatCurrencies() async {
+  try {
+    List<FiatCurrency> fiatCurrencyList = await breezSDKLiquid.instance!.listFiatCurrencies();
+    return fiatCurrencyList;
+  } catch (error) {
+    print(error);
+    rethrow;
+  }
+}
+
+Future<Map<String, Rate>> fetchFiatRates() async {
+  try {
+    final List<Rate> rates = await breezSDKLiquid.instance!.fetchFiatRates();
+    final fiatRatesMap = rates.fold<Map<String, Rate>>({}, (map, rate) {
+      map[rate.coin] = rate;
+      return map;
+    });
+    // print your desired rate
+    print(fiatRatesMap["USD"]?.value);
+    return fiatRatesMap;
+  } catch (error) {
+    print(error);
+    rethrow;
+  }
+}
+```
+
+### Sending Payments
+
+#### Lightning Payments
+
+Sending Lightning payments involves a submarine swap and two Liquid on-chain transactions. The process is as follows:
+
+1. User broadcasts an L-BTC transaction to a Liquid lockup address.
+2. Swapper pays the invoice, sending to the recipient, and then gets a preimage.
+3. Swapper broadcasts an L-BTC transaction to claim the funds from the Liquid lockup address.
+
+The fee a user pays to send a Lightning payment is composed of three parts:
+
+1. **Lockup Transaction Fee:** ~34 sats (0.1 sat/discount vbyte).
+2. **Claim Transaction Fee:** ~19 sats (0.1 sat/discount vbyte).
+3. **Swap Service Fee:** 0.1% fee on the amount sent.
+
+Note: swap service fee is dynamic and can change. Currently, it is 0.1%.
+
+> **Example**: If the user sends 10k sats, the fee would be:
+> 
+> - 34 sats [Lockup Transaction Fee] + 19 sats [Claim Transaction Fee] + 10 sats [Swapper Service Fee] = 63 sats
+
+```dart
+Future<PrepareSendResponse> prepareSendPaymentLightningBolt11() async {
+  // Set the bolt11 invoice you wish to pay
+  String destination = "<bolt11 invoice>";
+  
+  try {
+    PrepareSendResponse prepareSendResponse = await breezSDKLiquid.instance!.prepareSendPayment(
+      req: PrepareSendRequest(destination: destination),
+    );
+
+    // If the fees are acceptable, continue to create the Send Payment
+    BigInt sendFeesSat = prepareSendResponse.feesSat;
+    print("Fees: $sendFeesSat sats");
+    return prepareSendResponse;
+  } catch (error) {
+    print(error);
+    rethrow;
+  }
+}
+
+Future<PrepareSendResponse> prepareSendPaymentLightningBolt12() async {
+  // Set the bolt12 offer you wish to pay
+  String destination = "<bolt12 offer>";
+  
+  try {
+    PayAmount_Bitcoin optionalAmount = PayAmount_Bitcoin(receiverAmountSat: BigInt.from(5000));
+    PrepareSendResponse prepareSendResponse = await breezSDKLiquid.instance!.prepareSendPayment(
+      req: PrepareSendRequest(destination: destination, amount: optionalAmount),
+    );
+    return prepareSendResponse;
+  } catch (error) {
+    print(error);
+    rethrow;
+  }
+}
+```
+
+#### Liquid Payments
+
+```dart
+Future<PrepareSendResponse> prepareSendPaymentLiquid() async {
+  // Set the Liquid BIP21 or Liquid address you wish to pay
+  String destination = "<Liquid BIP21 or address>";
+  
+  try {
+    PayAmount_Bitcoin optionalAmount = PayAmount_Bitcoin(receiverAmountSat: BigInt.from(5000));
+    PrepareSendRequest prepareSendRequest = PrepareSendRequest(
+      destination: destination,
+      amount: optionalAmount,
+    );
+
+    PrepareSendResponse prepareSendResponse = await breezSDKLiquid.instance!.prepareSendPayment(
+      req: prepareSendRequest,
+    );
+
+    // If the fees are acceptable, continue to create the Send Payment
+    BigInt sendFeesSat = prepareSendResponse.feesSat;
+    print("Fees: $sendFeesSat sats");
+    return prepareSendResponse;
+  } catch (error) {
+    print(error);
+    rethrow;
+  }
+}
+
+Future<PrepareSendResponse> prepareSendPaymentLiquidDrain() async {
+  // Set the Liquid BIP21 or Liquid address you wish to pay
+  String destination = "<Liquid BIP21 or address>";
+  
+  try {
+    PayAmount_Drain optionalAmount = PayAmount_Drain();
+    PrepareSendRequest prepareSendRequest = PrepareSendRequest(
+      destination: destination,
+      amount: optionalAmount,
+    );
+
+    PrepareSendResponse prepareSendResponse = await breezSDKLiquid.instance!.prepareSendPayment(
+      req: prepareSendRequest,
+    );
+
+    // If the fees are acceptable, continue to create the Send Payment
+    BigInt sendFeesSat = prepareSendResponse.feesSat;
+    print("Fees: $sendFeesSat sats");
+    return prepareSendResponse;
+  } catch (error) {
+    print(error);
+    rethrow;
+  }
+}
+```
+
+#### Execute Payment
+- **always make sure the sdk instance is synced before performing any actions**
+
+```dart
+Future<SendPaymentResponse> sendPayment({required PrepareSendResponse prepareResponse}) async {
+  try {
+    SendPaymentResponse sendPaymentResponse = await breezSDKLiquid.instance!.sendPayment(
+      req: SendPaymentRequest(prepareResponse: prepareResponse),
+    );
+    Payment payment = sendPaymentResponse.payment;
+    return sendPaymentResponse;
+  } catch (error) {
+    print(error);
+    rethrow;
+  }
+}
+```
+
+### Receiving Payments
+**always make sure the sdk instance is synced before performing any actions**
+
+#### Lightning Payments
+
+Receiving Lightning payments involves a reverse submarine swap and requires two Liquid on-chain transactions. The process is as follows:
+
+1. Sender pays the Swapper invoice.
+2. Swapper broadcasts an L-BTC transaction to a Liquid lockup address.
+3. SDK claims the funds from the Liquid lockup address and then exposes the preimage.
+4. Swapper uses the preimage to claim the funds from the Liquid lockup address.
+
+The fee a user pays to receive a Lightning payment is composed of three parts:
+
+1. **Lockup Transaction Fee:** ~27 sats (0.1 sat/discount vbyte).
+2. **Claim Transaction Fee:** ~20 sats (0.1 sat/discount vbyte).
+3. **Swap Service Fee:** 0.25% fee on the amount received.
+
+Note: swap service fee is dynamic and can change. Currently, it is 0.25%.
+
+> **Example**: If the sender sends 10k sats, the fee for the end-user would be:
+> 
+> - 27 sats [Lockup Transaction Fee] + 20 sats [Claim Transaction Fee] + 25 sats [Swapper Service Fee] = 72 sats
+
+```dart
+Future<PrepareReceiveResponse> prepareReceivePaymentLightning() async {
+  try {
+    // Fetch the Receive lightning limits
+    LightningPaymentLimitsResponse currentLightningLimits =
+        await breezSDKLiquid.instance!.fetchLightningLimits();
+    print("Minimum amount: ${currentLightningLimits.receive.minSat} sats");
+    print("Maximum amount: ${currentLightningLimits.receive.maxSat} sats");
+
+    // Create an invoice and set the amount you wish the payer to send
+    ReceiveAmount_Bitcoin optionalAmount = ReceiveAmount_Bitcoin(payerAmountSat: BigInt.from(5000));
+    PrepareReceiveResponse prepareResponse = await breezSDKLiquid.instance!.prepareReceivePayment(
+      req: PrepareReceiveRequest(
+        paymentMethod: PaymentMethod.lightning,
+        amount: optionalAmount,
+      ),
+    );
+
+    // If the fees are acceptable, continue to create the Receive Payment
+    BigInt receiveFeesSat = prepareResponse.feesSat;
+    print("Fees: $receiveFeesSat sats");
+    return prepareResponse;
+  } catch (error) {
+    print(error);
+    rethrow;
+  }
+}
+```
+
+#### Onchain Payments
+
+```dart
+Future<PrepareReceiveResponse> prepareReceivePaymentOnchain() async {
+  try {
+    // Fetch the Receive onchain limits
+    OnchainPaymentLimitsResponse currentOnchainLimits = await breezSDKLiquid.instance!.fetchOnchainLimits();
+    print("Minimum amount: ${currentOnchainLimits.receive.minSat} sats");
+    print("Maximum amount: ${currentOnchainLimits.receive.maxSat} sats");
+
+    // Or create a cross-chain transfer (Liquid to Bitcoin) via chain swap
+    ReceiveAmount_Bitcoin optionalAmount = ReceiveAmount_Bitcoin(payerAmountSat: BigInt.from(5000));
+    PrepareReceiveResponse prepareResponse = await breezSDKLiquid.instance!.prepareReceivePayment(
+      req: PrepareReceiveRequest(
+        paymentMethod: PaymentMethod.bitcoinAddress,
+        amount: optionalAmount,
+      ),
+    );
+
+    // If the fees are acceptable, continue to create the Receive Payment
+    BigInt receiveFeesSat = prepareResponse.feesSat;
+    print("Fees: $receiveFeesSat sats");
+    return prepareResponse;
+  } catch (error) {
+    print(error);
+    rethrow;
+  }
+}
+```
+
+#### Liquid Payments
+
+```dart
+Future<PrepareReceiveResponse> prepareReceivePaymentLiquid() async {
+  try {
+    // Create a Liquid BIP21 URI/address to receive a payment to.
+    // There are no limits, but the payer amount should be greater than broadcast fees when specified
+    // Note: Not setting the amount will generate a plain Liquid address
+    ReceiveAmount_Bitcoin optionalAmount = ReceiveAmount_Bitcoin(payerAmountSat: BigInt.from(5000));
+    PrepareReceiveResponse prepareResponse = await breezSDKLiquid.instance!.prepareReceivePayment(
+      req: PrepareReceiveRequest(
+        paymentMethod: PaymentMethod.liquidAddress,
+        amount: optionalAmount,
+      ),
+    );
+
+    // If the fees are acceptable, continue to create the Receive Payment
+    BigInt receiveFeesSat = prepareResponse.feesSat;
+    print("Fees: $receiveFeesSat sats");
+    return prepareResponse;
+  } catch (error) {
+    print(error);
+    rethrow;
+  }
+}
+```
+
+#### Execute Receive
+
+```dart
+Future<ReceivePaymentResponse> receivePayment(PrepareReceiveResponse prepareResponse) async {
+  try {
+    String optionalDescription = "<description>";
+    ReceivePaymentResponse res = await breezSDKLiquid.instance!.receivePayment(
+      req: ReceivePaymentRequest(
+        description: optionalDescription,
+        prepareResponse: prepareResponse,
+      ),
+    );
+
+    String destination = res.destination;
+    print(destination);
+    return res;
+  } catch (error) {
+    print(error);
+    rethrow;
+  }
+}
+```
+
+### LNURL Operations
+
+#### LNURL Authentication
+
+```dart
+Future<void> lnurlAuth() async {
+  // Endpoint can also be of the form:
+  // keyauth://domain.com/auth?key=val
+  String lnurlAuthUrl =
+      "lnurl1dp68gurn8ghj7mr0vdskc6r0wd6z7mrww4excttvdankjm3lw3skw0tvdankjm3xdvcn6vtp8q6n2dfsx5mrjwtrxdjnqvtzv56rzcnyv3jrxv3sxqmkyenrvv6kve3exv6nqdtyv43nqcmzvdsnvdrzx33rsenxx5unqc3cxgeqgntfgu";
+
+  try {
+    InputType inputType = await breezSDKLiquid.instance!.parse(input: lnurlAuthUrl);
+    if (inputType is InputType_LnUrlAuth) {
+      LnUrlCallbackStatus result = await breezSDKLiquid.instance!.lnurlAuth(reqData: inputType.data);
+      if (result is LnUrlCallbackStatus_Ok) {
+        print("Successfully authenticated");
+      } else {
+        print("Failed to authenticate");
+      }
+    }
+  } catch (error) {
+    print(error);
+    rethrow;
+  }
+}
+```
+
+#### LNURL Pay
+
+```dart
+Future<void> prepareLnurlPay() async {
+  // Endpoint can also be of the form:
+  // lnurlp://domain.com/lnurl-pay?key=val
+  String lnurlPayUrl = "lightning@address.com";
+
+  try {
+    InputType inputType = await breezSDKLiquid.instance!.parse(input: lnurlPayUrl);
+    if (inputType is InputType_LnUrlPay) {
+      PayAmount_Bitcoin amount = PayAmount_Bitcoin(receiverAmountSat: BigInt.from(5000));
+      String optionalComment = "<comment>";
+      bool optionalValidateSuccessActionUrl = true;
+
+      PrepareLnUrlPayRequest req = PrepareLnUrlPayRequest(
+        data: inputType.data,
+        amount: amount,
+        bip353Address: inputType.bip353Address,
+        comment: optionalComment,
+        validateSuccessActionUrl: optionalValidateSuccessActionUrl,
+      );
+      PrepareLnUrlPayResponse prepareResponse = await breezSDKLiquid.instance!.prepareLnurlPay(req: req);
+
+      // If the fees are acceptable, continue to create the LNURL Pay
+      BigInt feesSat = prepareResponse.feesSat;
+      print("Fees: $feesSat sats");
+      return prepareResponse;
+    }
+  } catch (error) {
+    print(error);
+    rethrow;
+  }
+}
+
+Future<void> lnurlPay({required PrepareLnUrlPayResponse prepareResponse}) async {
+  try {
+    LnUrlPayResult result = await breezSDKLiquid.instance!.lnurlPay(
+      req: LnUrlPayRequest(prepareResponse: prepareResponse),
+    );
+    print(result);
+  } catch (error) {
+    print(error);
+    rethrow;
+  }
+}
+```
+
+#### LNURL Withdraw
+
+```dart
+Future<void> lnurlWithdraw() async {
+  // Endpoint can also be of the form:
+  // lnurlw://domain.com/lnurl-withdraw?key=val
+  String lnurlWithdrawUrl =
+      "lnurl1dp68gurn8ghj7mr0vdskc6r0wd6z7mrww4exctthd96xserjv9mn7um9wdekjmmw843xxwpexdnxzen9vgunsvfexq6rvdecx93rgdmyxcuxverrvcursenpxvukzv3c8qunsdecx33nzwpnvg6ryc3hv93nzvecxgcxgwp3h33lxk";
+
+  try {
+    InputType inputType = await breezSDKLiquid.instance!.parse(input: lnurlWithdrawUrl);
+    if (inputType is InputType_LnUrlWithdraw) {
+      BigInt amountMsat = inputType.data.minWithdrawable;
+      LnUrlWithdrawRequest req = LnUrlWithdrawRequest(
+        data: inputType.data,
+        amountMsat: amountMsat,
+        description: "<description>",
+      );
+      LnUrlWithdrawResult result = await breezSDKLiquid.instance!.lnurlWithdraw(req: req);
+      print(result.data);
+    }
+  } catch (error) {
+    print(error);
+    rethrow;
+  }
+}
+```
+
+### Onchain Operations
+
+#### Pay Onchain
+
+```dart
+Future<OnchainPaymentLimitsResponse> getCurrentLimits() async {
+  try {
+    OnchainPaymentLimitsResponse currentLimits = await breezSDKLiquid.instance!.fetchOnchainLimits();
+    print("Minimum amount: ${currentLimits.send.minSat} sats");
+    print("Maximum amount: ${currentLimits.send.maxSat} sats");
+    return currentLimits;
+  } catch (error) {
+    print(error);
+    rethrow;
+  }
+}
+
+Future<PreparePayOnchainResponse> preparePayOnchain() async {
+  try {
+    PreparePayOnchainRequest preparePayOnchainRequest = PreparePayOnchainRequest(
+      amount: PayAmount_Bitcoin(receiverAmountSat: BigInt.from(5000)),
+    );
+    PreparePayOnchainResponse prepareRes = await breezSDKLiquid.instance!.preparePayOnchain(
+      req: preparePayOnchainRequest,
+    );
+
+    // Check if the fees are acceptable before proceeding
+    BigInt totalFeesSat = prepareRes.totalFeesSat;
+    print(totalFeesSat);
+    return prepareRes;
+  } catch (error) {
+    print(error);
+    rethrow;
+  }
+}
+
+Future<PreparePayOnchainResponse> preparePayOnchainFeeRate() async {
+  try {
+    int optionalSatPerVbyte = 21;
+
+    PreparePayOnchainRequest preparePayOnchainRequest = PreparePayOnchainRequest(
+      amount: PayAmount_Bitcoin(receiverAmountSat: BigInt.from(5000)),
+      feeRateSatPerVbyte: optionalSatPerVbyte,
+    );
+    PreparePayOnchainResponse prepareRes = await breezSDKLiquid.instance!.preparePayOnchain(
+      req: preparePayOnchainRequest,
+    );
+
+    // Check if the fees are acceptable before proceeding
+    BigInt claimFeesSat = prepareRes.claimFeesSat;
+    BigInt totalFeesSat = prepareRes.totalFeesSat;
+    print(claimFeesSat);
+    print(totalFeesSat);
+    return prepareRes;
+  } catch (error) {
+    print(error);
+    rethrow;
+  }
+}
+
+Future<SendPaymentResponse> startReverseSwap({
+  required PreparePayOnchainResponse prepareRes,
+}) async {
+  try {
+    String destinationAddress = "bc1..";
+
+    PayOnchainRequest req = PayOnchainRequest(
+      address: destinationAddress,
+      prepareResponse: prepareRes,
+    );
+    SendPaymentResponse res = await breezSDKLiquid.instance!.payOnchain(req: req);
+    return res;
+  } catch (error) {
+    print(error);
+    rethrow;
+  }
+}
+```
+
+#### Drain Funds
+
+```dart
+Future<PreparePayOnchainResponse> preparePayOnchainDrain() async {
+  try {
+    PreparePayOnchainRequest preparePayOnchainRequest = PreparePayOnchainRequest(
+      amount: PayAmount_Drain(),
+    );
+    PreparePayOnchainResponse prepareRes = await breezSDKLiquid.instance!.preparePayOnchain(
+      req: preparePayOnchainRequest,
+    );
+
+    // Check if the fees are acceptable before proceeding
+    BigInt totalFeesSat = prepareRes.totalFeesSat;
+    print(totalFeesSat);
+    return prepareRes;
+  } catch (error) {
+    print(error);
+    rethrow;
+  }
+}
+```
+
+#### Receive Onchain
+
+```dart
+Future<List<RefundableSwap>> listRefundables() async {
+  try {
+    List<RefundableSwap> refundables = await breezSDKLiquid.instance!.listRefundables();
+    return refundables;
+  } catch (error) {
+    print(error);
+    rethrow;
+  }
+}
+
+Future<RefundResponse> executeRefund({
+  required int refundTxFeeRate,
+  required RefundableSwap refundable,
+}) async {
+  try {
+    String destinationAddress = "...";
+    int feeRateSatPerVbyte = refundTxFeeRate;
+
+    RefundRequest req = RefundRequest(
+      swapAddress: refundable.swapAddress,
+      refundAddress: destinationAddress,
+      feeRateSatPerVbyte: feeRateSatPerVbyte,
+    );
+    RefundResponse resp = await breezSDKLiquid.instance!.refund(req: req);
+    print(resp.refundTxId);
+    return resp;
+  } catch (error) {
+    print(error);
+    rethrow;
+  }
+}
+
+Future rescanSwaps() async {
+  try {
+    await breezSDKLiquid.instance!.rescanOnchainSwaps();
+  } catch (error) {
+    print(error);
+    rethrow;
+  }
+}
+
+Future recommendedFees() async {
+  try {
+    RecommendedFees fees = await breezSDKLiquid.instance!.recommendedFees();
+    print(fees);
+  } catch (error) {
+    print(error);
+    rethrow;
+  }
+}
+```
+
+#### Handle Fee Acceptance
+
+```dart
+Future<void> handlePaymentsWaitingFeeAcceptance() async {
+  try {
+    // Payments on hold waiting for fee acceptance have the state WaitingFeeAcceptance
+    List<Payment> paymentsWaitingFeeAcceptance = await breezSDKLiquid.instance!.listPayments(
+      req: ListPaymentsRequest(
+        states: [PaymentState.waitingFeeAcceptance],
+      ),
+    );
+
+    for (Payment payment in paymentsWaitingFeeAcceptance) {
+      if (payment.details is! PaymentDetails_Bitcoin) {
+        // Only Bitcoin payments can be `WaitingFeeAcceptance`
+        continue;
+      }
+
+      PaymentDetails_Bitcoin details = payment.details as PaymentDetails_Bitcoin;
+      FetchPaymentProposedFeesResponse fetchFeesResponse =
+          await breezSDKLiquid.instance!.fetchPaymentProposedFees(
+        req: FetchPaymentProposedFeesRequest(
+          swapId: details.swapId,
+        ),
+      );
+
+      print(
+        "Payer sent ${fetchFeesResponse.payerAmountSat} and currently proposed fees are ${fetchFeesResponse.feesSat}",
+      );
+
+      // If the user is ok with the fees, accept them, allowing the payment to proceed
+      await breezSDKLiquid.instance!.acceptPaymentProposedFees(
+        req: AcceptPaymentProposedFeesRequest(
+          response: fetchFeesResponse,
+        ),
+      );
+    }
+  } catch (error) {
+    print(error);
+    rethrow;
+  }
+}
\ No newline at end of file
diff --git a/examples/breez-nodeless-llms/breez-nodeless-reactnative-llms.md b/examples/breez-nodeless-llms/breez-nodeless-reactnative-llms.md
new file mode 100644
index 00000000..e043b82c
--- /dev/null
+++ b/examples/breez-nodeless-llms/breez-nodeless-reactnative-llms.md
@@ -0,0 +1,1832 @@
+# Breez SDK Nodeless (Liquid implementation) Documentation
+
+This comprehensive document provides all the context needed to build applications with the React Native bindings of Breez SDK Nodeless, a toolkit for integrating Bitcoin, Lightning Network, and Liquid Network functionality into your applications.
+
+## Overview
+
+Breez SDK Nodeless (Liquid implementation) is a powerful library that allows developers to integrate Bitcoin, Lightning Network, and Liquid Network functionality into their applications. The SDK abstracts many of the complexities of working with these technologies, providing a simple interface for common operations such as sending and receiving payments, managing wallets, and interacting with both Lightning and Liquid networks.
+
+Key capabilities include:
+- Wallet management and balance tracking
+- Lightning Network payments
+- Liquid Network transactions
+- Onchain Bitcoin operations
+- LNURL support (auth, pay, withdraw)
+- Non-Bitcoin asset management
+- Webhook integration
+- Event handling with listeners
+
+## Getting Started
+
+### Installation
+
+```bash
+yarn add @breeztech/react-native-breez-sdk-liquid
+```
+
+### Guidelines
+- **Always make sure the SDK instance is synced before performing any actions**
+- **Add logging**: Add sufficient logging into your application to diagnose any issues users are having.
+- **Display pending payments**: Payments always contain a status field that can be used to determine if the payment was completed or not. Make sure you handle the case where the payment is still pending by showing the correct status to the user.
+- **Enable swap refunds**: Swaps that are the result of receiving an On-Chain Transaction may not be completed and change to `Refundable` state. Make sure you handle this case correctly by allowing the user to retry the refund with different fees as long as the refund is not confirmed.
+- **Expose swap fees**: When sending or receiving on-chain, make sure to clearly show the expected fees involved, as well as the send/receive amounts.
+
+### Initializing the SDK
+
+To get started with Breez SDK Nodeless (Liquid implementation), you need to initialize the SDK with your configuration:
+
+```javascript
+import {
+  addEventListener,
+  defaultConfig,
+  connect,
+  LiquidNetwork,
+  type LogEntry,
+  getInfo,
+  removeEventListener,
+  disconnect,
+  type SdkEvent,
+  setLogger
+} from '@breeztech/react-native-breez-sdk-liquid'
+
+const initializeSDK = async () => {
+  // Your mnemonic seed phrase for wallet recovery
+  const mnemonic = '<mnemonics words>'
+
+  // Create the default config, providing your Breez API key
+  const config = await defaultConfig(
+    LiquidNetwork.MAINNET,
+    '<your-Breez-API-key>'
+  )
+
+  // By default in React Native the workingDir is set to:
+  // `/<APPLICATION_SANDBOX_DIRECTORY>/breezSdkLiquid`
+  // You can change this to another writable directory or a
+  // subdirectory of the workingDir if managing multiple mnemonics.
+  console.log(`Working directory: ${config.workingDir}`)
+  // config.workingDir = "path to writable directory"
+
+  await connect({ mnemonic, config })
+}
+```
+
+### Basic Operations
+
+#### Fetch Balance
+
+```javascript
+const fetchBalance = async () => {
+  try {
+    const info = await getInfo()
+    const balanceSat = info.walletInfo.balanceSat
+    const pendingSendSat = info.walletInfo.pendingSendSat
+    const pendingReceiveSat = info.walletInfo.pendingReceiveSat
+    
+    console.log(`Balance: ${balanceSat} sats`)
+    console.log(`Pending Send: ${pendingSendSat} sats`)
+    console.log(`Pending Receive: ${pendingReceiveSat} sats`)
+  } catch (err) {
+    console.error(err)
+  }
+}
+
+const fetchAssetBalance = async () => {
+  try {
+    const info = await getInfo()
+    const assetBalances = info.walletInfo.assetBalances
+    return assetBalances
+  } catch (err) {
+    console.error(err)
+  }
+}
+```
+
+### Messages and Signing
+
+```javascript
+import {
+  checkMessage,
+  getInfo,
+  signMessage
+} from '@breeztech/react-native-breez-sdk-liquid'
+
+const signMessageExample = async () => {
+  try {
+    const signMessageResponse = await signMessage({
+      message: '<message to sign>'
+    })
+
+    // Get the wallet info for your pubkey
+    const info = await getInfo()
+
+    const signature = signMessageResponse.signature
+    const pubkey = info.walletInfo.pubkey
+
+    console.log(`Pubkey: ${pubkey}`)
+    console.log(`Signature: ${signature}`)
+    return { signature, pubkey }
+  } catch (err) {
+    console.error(err)
+  }
+}
+
+const checkMessageExample = async () => {
+  try {
+    const checkMessageResponse = await checkMessage({
+      message: '<message>',
+      pubkey: '<pubkey of signer>',
+      signature: '<message signature>'
+    })
+    const isValid = checkMessageResponse.isValid
+
+    console.log(`Signature valid: ${isValid}`)
+    return isValid
+  } catch (err) {
+    console.error(err)
+  }
+}
+```
+
+### List Payments
+
+```javascript
+import {
+  getPayment,
+  GetPaymentRequestVariant,
+  ListPaymentDetailsVariant,
+  listPayments,
+  PaymentType
+} from '@breeztech/react-native-breez-sdk-liquid'
+
+const getPaymentExample = async () => {
+  try {
+    const paymentHash = '<payment hash>'
+    const paymentByHash = await getPayment({
+      type: GetPaymentRequestVariant.PAYMENT_HASH,
+      paymentHash
+    })
+
+    const swapId = '<swap id>'
+    const paymentBySwapId = await getPayment({
+      type: GetPaymentRequestVariant.SWAP_ID,
+      swapId
+    })
+    
+    return { paymentByHash, paymentBySwapId }
+  } catch (err) {
+    console.error(err)
+  }
+}
+
+const listAllPayments = async () => {
+  try {
+    const payments = await listPayments({})
+    return payments
+  } catch (err) {
+    console.error(err)
+  }
+}
+
+const listPaymentsFiltered = async () => {
+  try {
+    const payments = await listPayments({
+      filters: [PaymentType.SEND],
+      fromTimestamp: 1696880000,
+      toTimestamp: 1696959200,
+      offset: 0,
+      limit: 50
+    })
+    return payments
+  } catch (err) {
+    console.error(err)
+  }
+}
+
+const listPaymentsDetailsAddress = async () => {
+  try {
+    const payments = await listPayments({
+      details: {
+        type: ListPaymentDetailsVariant.BITCOIN,
+        address: '<Bitcoin address>'
+      }
+    })
+    return payments
+  } catch (err) {
+    console.error(err)
+  }
+}
+
+const listPaymentsDetailsDestination = async () => {
+  try {
+    const payments = await listPayments({
+      details: {
+        type: ListPaymentDetailsVariant.LIQUID,
+        destination: '<Liquid BIP21 or address>'
+      }
+    })
+    return payments
+  } catch (err) {
+    console.error(err)
+  }
+}
+```
+
+### Webhook Integration
+
+```javascript
+import { registerWebhook, unregisterWebhook } from '@breeztech/react-native-breez-sdk-liquid'
+
+const registerWebhookExample = async () => {
+  try {
+    await registerWebhook('https://your-nds-service.com/notify?platform=ios&token=<PUSH_TOKEN>')
+  } catch (err) {
+    console.error(err)
+  }
+}
+
+const unregisterWebhookExample = async () => {
+  try {
+    await unregisterWebhook()
+  } catch (err) {
+    console.error(err)
+  }
+}
+```
+
+### Input Parsing
+
+```javascript
+import {
+  InputTypeVariant,
+  parse
+} from '@breeztech/react-native-breez-sdk-liquid'
+
+const parseInputExample = async () => {
+  const input = 'an input to be parsed...'
+
+  try {
+    const parsed = await parse(input)
+
+    switch (parsed.type) {
+      case InputTypeVariant.BITCOIN_ADDRESS:
+        console.log(`Input is Bitcoin address ${parsed.address.address}`)
+        break
+
+      case InputTypeVariant.BOLT11:
+        console.log(
+          `Input is BOLT11 invoice for ${
+            parsed.invoice.amountMsat != null
+              ? parsed.invoice.amountMsat.toString()
+              : 'unknown'
+          } msats`
+        )
+        break
+
+      case InputTypeVariant.LN_URL_PAY:
+        console.log(
+          `Input is LNURL-Pay/Lightning address accepting min/max ${parsed.data.minSendable}/${parsed.data.maxSendable} msats - BIP353 was used: ${parsed.bip353Address != null}`
+        )
+        break
+
+      case InputTypeVariant.LN_URL_WITHDRAW:
+        console.log(
+          `Input is LNURL-Withdraw for min/max ${parsed.data.minWithdrawable}/${parsed.data.maxWithdrawable} msats`
+        )
+        break
+
+      default:
+        // Other input types are available
+        break
+    }
+    
+    return parsed
+  } catch (err) {
+    console.error(err)
+  }
+}
+
+const configureParsers = async () => {
+  try {
+    const mnemonic = '<mnemonics words>'
+
+    // Create the default config, providing your Breez API key
+    const config = await defaultConfig(
+      LiquidNetwork.MAINNET,
+      '<your-Breez-API-key>'
+    )
+
+    // Configure external parsers
+    config.externalInputParsers = [
+      {
+        providerId: 'provider_a',
+        inputRegex: '^provider_a',
+        parserUrl: 'https://parser-domain.com/parser?input=<input>'
+      },
+      {
+        providerId: 'provider_b',
+        inputRegex: '^provider_b',
+        parserUrl: 'https://parser-domain.com/parser?input=<input>'
+      }
+    ]
+
+    await connect({ mnemonic, config })
+  } catch (err) {
+    console.error(err)
+  }
+}
+```
+
+## React Native Component Example
+
+Here's a complete React Native component example that implements basic wallet functionality:
+
+```javascript
+import React, { useState, useEffect } from 'react';
+import { View, Text, ActivityIndicator, Button, StyleSheet, SafeAreaView, ScrollView, TextInput } from 'react-native';
+import {
+  connect,
+  defaultConfig,
+  disconnect,
+  getInfo,
+  LiquidNetwork,
+  PaymentMethod,
+  prepareReceivePayment,
+  receivePayment,
+  ReceiveAmountVariant,
+  prepareSendPayment,
+  sendPayment,
+  PayAmountVariant,
+  addEventListener,
+  removeEventListener
+} from '@breeztech/react-native-breez-sdk-liquid';
+
+const WalletApp = () => {
+  const [isLoading, setIsLoading] = useState(true);
+  const [walletInfo, setWalletInfo] = useState(null);
+  const [listenerId, setListenerId] = useState(null);
+  const [receiveAddress, setReceiveAddress] = useState('');
+  const [sendAddress, setSendAddress] = useState('');
+  const [amountSats, setAmountSats] = useState('1000');
+  const [error, setError] = useState('');
+  
+  useEffect(() => {
+    initializeSDK();
+    
+    return () => {
+      cleanupSDK();
+    };
+  }, []);
+  
+  const initializeSDK = async () => {
+    try {
+      setIsLoading(true);
+      
+      // Initialize the SDK
+      const config = await defaultConfig(
+        LiquidNetwork.TESTNET, // Use TESTNET for development
+        'your-api-key-here'
+      );
+      
+      // Use a sample mnemonic for testing - in production you'd want to get this securely
+      const mnemonic = 'sample mnemonic words here for testing only';
+      
+      await connect({ mnemonic, config });
+      
+      // Set up event listener
+      const onEvent = (e) => {
+        console.log(`Event received: ${e.type}`);
+        // Refresh wallet info when we get a relevant event
+        if (
+          e.type === 'PAYMENT_SUCCEEDED' || 
+          e.type === 'PAYMENT_FAILED' ||
+          e.type === 'SYNCED'
+        ) {
+          refreshWalletInfo();
+        }
+      };
+      
+      const id = await addEventListener(onEvent);
+      setListenerId(id);
+      
+      // Get initial wallet info
+      await refreshWalletInfo();
+      
+      setIsLoading(false);
+    } catch (err) {
+      console.error('Initialization error:', err);
+      setError(`Initialization error: ${err.message}`);
+      setIsLoading(false);
+    }
+  };
+  
+  const cleanupSDK = async () => {
+    try {
+      if (listenerId) {
+        await removeEventListener(listenerId);
+      }
+      await disconnect();
+    } catch (err) {
+      console.error('Cleanup error:', err);
+    }
+  };
+  
+  const refreshWalletInfo = async () => {
+    try {
+      const info = await getInfo();
+      setWalletInfo(info.walletInfo);
+    } catch (err) {
+      console.error('Error getting wallet info:', err);
+      setError(`Error fetching wallet info: ${err.message}`);
+    }
+  };
+  
+  const handleReceive = async () => {
+    try {
+      setIsLoading(true);
+      setError('');
+      
+      // Prepare receive request
+      const amount = {
+        type: ReceiveAmountVariant.BITCOIN,
+        payerAmountSat: parseInt(amountSats, 10)
+      };
+      
+      const prepareResponse = await prepareReceivePayment({
+        paymentMethod: PaymentMethod.LIGHTNING,
+        amount
+      });
+      
+      // Check fees
+      console.log(`Receive fees: ${prepareResponse.feesSat} sats`);
+      
+      // Create receive request
+      const receiveResponse = await receivePayment({
+        prepareResponse,
+        description: 'Payment request from React Native app'
+      });
+      
+      setReceiveAddress(receiveResponse.destination);
+      setIsLoading(false);
+    } catch (err) {
+      console.error('Error creating receive request:', err);
+      setError(`Error creating receive request: ${err.message}`);
+      setIsLoading(false);
+    }
+  };
+  
+  const handleSend = async () => {
+    try {
+      if (!sendAddress) {
+        setError('Please enter a destination address');
+        return;
+      }
+      
+      setIsLoading(true);
+      setError('');
+      
+      // Prepare send payment
+      const amount = {
+        type: PayAmountVariant.BITCOIN,
+        receiverAmountSat: parseInt(amountSats, 10)
+      };
+      
+      const prepareResponse = await prepareSendPayment({
+        destination: sendAddress,
+        amount
+      });
+      
+      // Check fees
+      console.log(`Send fees: ${prepareResponse.feesSat} sats`);
+      
+      // Confirm with user (in a real app)
+      // For this example, we'll just proceed
+      
+      // Send payment
+      const sendResponse = await sendPayment({
+        prepareResponse
+      });
+      
+      console.log('Payment sent:', sendResponse.payment);
+      
+      // Clear form fields
+      setSendAddress('');
+      
+      // Refresh wallet info
+      await refreshWalletInfo();
+      
+      setIsLoading(false);
+    } catch (err) {
+      console.error('Error sending payment:', err);
+      setError(`Error sending payment: ${err.message}`);
+      setIsLoading(false);
+    }
+  };
+  
+  if (isLoading) {
+    return (
+      <SafeAreaView style={styles.container}>
+        <ActivityIndicator size="large" color="#0000ff" />
+        <Text style={styles.loadingText}>Initializing wallet...</Text>
+      </SafeAreaView>
+    );
+  }
+  
+  return (
+    <SafeAreaView style={styles.container}>
+      <ScrollView contentContainerStyle={styles.scrollContainer}>
+        <Text style={styles.title}>Breez SDK Wallet</Text>
+        
+        {error ? <Text style={styles.errorText}>{error}</Text> : null}
+        
+        <View style={styles.balanceContainer}>
+          <Text style={styles.balanceLabel}>Balance:</Text>
+          <Text style={styles.balanceValue}>
+            {walletInfo ? `${walletInfo.balanceSat} sats` : 'Unknown'}
+          </Text>
+        </View>
+        
+        <View style={styles.section}>
+          <Text style={styles.sectionTitle}>Receive Payment</Text>
+          <TextInput
+            style={styles.input}
+            placeholder="Amount (sats)"
+            keyboardType="numeric"
+            value={amountSats}
+            onChangeText={setAmountSats}
+          />
+          <Button 
+            title="Generate Invoice" 
+            onPress={handleReceive} 
+          />
+          
+          {receiveAddress ? (
+            <View style={styles.addressContainer}>
+              <Text style={styles.addressLabel}>Your invoice:</Text>
+              <Text style={styles.address} selectable>{receiveAddress}</Text>
+            </View>
+          ) : null}
+        </View>
+        
+        <View style={styles.section}>
+          <Text style={styles.sectionTitle}>Send Payment</Text>
+          <TextInput
+            style={styles.input}
+            placeholder="Destination/Invoice"
+            value={sendAddress}
+            onChangeText={setSendAddress}
+          />
+          <TextInput
+            style={styles.input}
+            placeholder="Amount (sats)"
+            keyboardType="numeric"
+            value={amountSats}
+            onChangeText={setAmountSats}
+          />
+          <Button 
+            title="Send Payment" 
+            onPress={handleSend} 
+          />
+        </View>
+        
+        <Button 
+          title="Refresh Wallet Info" 
+          onPress={refreshWalletInfo} 
+        />
+      </ScrollView>
+    </SafeAreaView>
+  );
+};
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+    backgroundColor: '#F5F5F5'
+  },
+  scrollContainer: {
+    padding: 16
+  },
+  title: {
+    fontSize: 24,
+    fontWeight: 'bold',
+    marginBottom: 16,
+    textAlign: 'center'
+  },
+  loadingText: {
+    marginTop: 16,
+    textAlign: 'center',
+    color: '#666'
+  },
+  errorText: {
+    color: 'red',
+    marginBottom: 16
+  },
+  balanceContainer: {
+    flexDirection: 'row',
+    alignItems: 'center',
+    justifyContent: 'center',
+    marginBottom: 24,
+    backgroundColor: '#fff',
+    padding: 16,
+    borderRadius: 8,
+    elevation: 2,
+    shadowColor: '#000',
+    shadowOffset: { width: 0, height: 1 },
+    shadowOpacity: 0.2,
+    shadowRadius: 1.41
+  },
+  balanceLabel: {
+    fontSize: 18,
+    marginRight: 8
+  },
+  balanceValue: {
+    fontSize: 18,
+    fontWeight: 'bold'
+  },
+  section: {
+    backgroundColor: '#fff',
+    padding: 16,
+    borderRadius: 8,
+    marginBottom: 16,
+    elevation: 2,
+    shadowColor: '#000',
+    shadowOffset: { width: 0, height: 1 },
+    shadowOpacity: 0.2,
+    shadowRadius: 1.41
+  },
+  sectionTitle: {
+    fontSize: 18,
+    fontWeight: 'bold',
+    marginBottom: 12
+  },
+  input: {
+    borderWidth: 1,
+    borderColor: '#ddd',
+    borderRadius: 4,
+    padding: 8,
+    marginBottom: 12
+  },
+  addressContainer: {
+    marginTop: 12,
+    padding: 12,
+    backgroundColor: '#f9f9f9',
+    borderRadius: 4
+  },
+  addressLabel: {
+    fontWeight: 'bold',
+    marginBottom: 4
+  },
+  address: {
+    fontFamily: 'monospace'
+  }
+});
+
+export default WalletApp;
+```
+
+### End-User Fees
+
+#### Sending Lightning Payments
+
+Sending Lightning payments involves a submarine swap and two Liquid on-chain transactions. The process is as follows:
+
+1. User broadcasts an L-BTC transaction to a Liquid lockup address.
+2. Swapper pays the invoice, sending to the recipient, and then gets a preimage.
+3. Swapper broadcasts an L-BTC transaction to claim the funds from the Liquid lockup address.
+
+The fee a user pays to send a Lightning payment is composed of three parts:
+
+1. **Lockup Transaction Fee:** ~34 sats (0.1 sat/discount vbyte).
+2. **Claim Transaction Fee:** ~19 sats (0.1 sat/discount vbyte).
+3. **Swap Service Fee:** 0.1% fee on the amount sent.
+
+Note: swap service fee is dynamic and can change. Currently, it is 0.1%.
+
+> **Example**: If the user sends 10k sats, the fee would be:
+> 
+> - 34 sats [Lockup Transaction Fee] + 19 sats [Claim Transaction Fee] + 10 sats [Swapper Service Fee] = 63 sats
+
+#### Receiving Lightning Payments
+
+Receiving Lightning payments involves a reverse submarine swap and requires two Liquid on-chain transactions. The process is as follows:
+
+1. Sender pays the Swapper invoice.
+2. Swapper broadcasts an L-BTC transaction to a Liquid lockup address.
+3. SDK claims the funds from the Liquid lockup address and then exposes the preimage.
+4. Swapper uses the preimage to claim the funds from the Liquid lockup address.
+
+The fee a user pays to receive a Lightning payment is composed of three parts:
+
+1. **Lockup Transaction Fee:** ~27 sats (0.1 sat/discount vbyte).
+2. **Claim Transaction Fee:** ~20 sats (0.1 sat/discount vbyte).
+3. **Swap Service Fee:** 0.25% fee on the amount received.
+
+Note: swap service fee is dynamic and can change. Currently, it is 0.25%.
+
+> **Example**: If the sender sends 10k sats, the fee for the end-user would be:
+> 
+> - 27 sats [Lockup Transaction Fee] + 20 sats [Claim Transaction Fee] + 25 sats [Swapper Service Fee] = 72 sats
+
+#### Sending to a Bitcoin Address
+
+Sending to a BTC address involves a trustless chain swap, 2 Liquid on-chain transactions, and 2 BTC on-chain transactions. The process is as follows:
+
+1. SDK broadcasts an L-BTC transaction to a Liquid lockup address.
+2. Swapper broadcasts a BTC transaction to a Bitcoin lockup address.
+3. Recipient claims the funds from the Bitcoin lockup address.
+4. Swapper claims the funds from the Liquid lockup address.
+
+The fee to send to a BTC address is composed of four parts:
+
+1. **L-BTC Lockup Transaction Fee**: ~34 sats (0.1 sat/discount vbyte).
+2. **BTC Lockup Transaction Fee**: the swapper charges a mining fee based on the current bitcoin mempool usage.
+3. **Swap Service Fee:** 0.1% fee on the amount sent.
+4. **BTC Claim Transaction Fee:** the SDK fees to claim BTC funds to the destination address, based on the current Bitcoin mempool usage.
+
+Note: swap service fee is dynamic and can change. Currently, it is 0.1%.
+
+> **Example**: If the user sends 100k sats, the mining fees returned by the Swapper are 2000 sats, and the claim fees for the user are 1000 sats—the fee would be:
+> 
+> - 34 sats [Lockup Transaction Fee] + 2000 sats [BTC Claim Transaction Fee] + 100 sats [Swapper Service Fee] + 1000 sats [BTC Lockup Transaction Fee] = 3132 sats
+
+### Receiving from a BTC Address
+
+Receiving from a BTC address involves a trustless chain swap, 2 Liquid on-chain transactions, and 2 BTC on-chain transactions.
+
+The process is as follows:
+
+1. Sender broadcasts a BTC transaction to the Bitcoin lockup address.
+2. Swapper broadcasts an L-BTC transaction to a Liquid lockup address.
+3. SDK claims the funds from the Liquid lockup address.
+4. Swapper claims the funds from the Bitcoin lockup address.
+
+The fee to receive from a BTC address is composed of three parts:
+
+1. **L-BTC Claim Transaction Fee:** ~20 sats (0.1 sat/discount vbyte).
+2. **BTC Claim Transaction Fee:** the swapper charges a mining fee based on the Bitcoin mempool usage at the time of the swap.
+3. **Swapper Service Fee:** the swapper charges a 0.1% fee on the amount received.
+
+Note: swapper service fee is dynamic and can change. Currently, it is 0.1%.
+
+> **Example**: If the sender sends 100k sats and the mining fees returned by the Swapper are 2000 sats—the fee for the end-user would be:
+> 
+> - 20 sats [Claim Transaction Fee] + 100 sats [Swapper Service Fee] + 2000 sats [BTC Claim Transaction Fee] = 2120 sats
+
+## Best Practices
+
+### Syncing
+
+**Always make sure the SDK instance is synced before performing any actions:**
+
+```javascript
+import { addEventListener, SdkEventType } from '@breeztech/react-native-breez-sdk-liquid';
+
+// In a React component using the useEffect hook
+useEffect(() => {
+  let synced = false;
+  let listenerId;
+  
+  const setupListener = async () => {
+    const onEvent = (event) => {
+      if (event.type === 'SYNCED') {
+        synced = true;
+        // Now it's safe to perform actions
+        fetchWalletData();
+      }
+    };
+    
+    listenerId = await addEventListener(onEvent);
+  };
+  
+  setupListener();
+  
+  return () => {
+    // Cleanup when component unmounts
+    if (listenerId) {
+      removeEventListener(listenerId);
+    }
+  };
+}, []);
+```
+
+### Error Handling
+
+Always wrap your SDK method calls in try-catch blocks to properly handle errors:
+
+```javascript
+const sendPayment = async () => {
+  try {
+    // Call SDK method
+    const result = await someMethod();
+    // Process result
+  } catch (error) {
+    console.error('An error occurred:', error);
+    // Handle the error appropriately, e.g., show a user-friendly message
+    setErrorMessage(`Payment failed: ${error.message}`);
+  }
+};
+```
+
+### Connection Lifecycle
+
+Manage the connection lifecycle properly:
+
+```javascript
+import React, { useEffect } from 'react';
+import { connect, disconnect } from '@breeztech/react-native-breez-sdk-liquid';
+
+const WalletScreen = () => {
+  useEffect(() => {
+    const initializeSdk = async () => {
+      try {
+        // Initialize SDK
+        await connect({
+          mnemonic,
+          config
+        });
+        
+        // SDK is ready to use
+      } catch (error) {
+        console.error('Failed to initialize SDK:', error);
+      }
+    };
+    
+    initializeSdk();
+    
+    // Cleanup function
+    return () => {
+      const cleanupSdk = async () => {
+        try {
+          await disconnect();
+        } catch (error) {
+          console.error('Error disconnecting:', error);
+        }
+      };
+      
+      cleanupSdk();
+    };
+  }, []);
+  
+  // Rest of the component
+};
+```
+
+### Fee Handling
+
+Always check fees before executing payments and get user confirmation:
+
+```javascript
+const executePayment = async () => {
+  try {
+    // Get fee information
+    const prepareResponse = await prepareSendPayment({
+      destination,
+      amount
+    });
+    
+    const feesSat = prepareResponse.feesSat;
+    
+    // Ask user to confirm the fee (using an Alert or a custom modal)
+    const userConfirmed = await showFeeConfirmationDialog(feesSat);
+    
+    if (userConfirmed) {
+      // Execute payment
+      const paymentResponse = await sendPayment({ prepareResponse });
+      // Handle successful payment
+    } else {
+      // User rejected the fee
+      console.log('Payment canceled by user due to fees');
+    }
+  } catch (error) {
+    console.error('Payment error:', error);
+  }
+};
+```
+
+### Event Handling
+
+Implement a robust event listener system:
+
+```javascript
+import { useEffect, useState } from 'react';
+import { 
+  addEventListener, 
+  removeEventListener
+} from '@breeztech/react-native-breez-sdk-liquid';
+
+function useSdkEvents() {
+  const [paymentEvents, setPaymentEvents] = useState([]);
+  const [syncStatus, setSyncStatus] = useState(false);
+  
+  useEffect(() => {
+    let listenerId;
+    
+    const setupListener = async () => {
+      const handleEvent = (event) => {
+        console.log('SDK Event:', event);
+        
+        switch (event.type) {
+          case 'PAYMENT_SUCCEEDED':
+            setPaymentEvents(prev => [...prev, event]);
+            break;
+          case 'SYNCED':
+            setSyncStatus(true);
+            break;
+          case 'SYNCING':
+            setSyncStatus(false);
+            break;
+          // Handle other event types
+        }
+      };
+      
+      listenerId = await addEventListener(handleEvent);
+    };
+    
+    setupListener();
+    
+    return () => {
+      if (listenerId) {
+        removeEventListener(listenerId).catch(err => {
+          console.error('Failed to remove event listener:', err);
+        });
+      }
+    };
+  }, []);
+  
+  return { paymentEvents, syncStatus };
+}
+```
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Connection Problems**
+   - Check your API key
+   - Verify network selection (MAINNET vs TESTNET)
+   - Confirm working directory permissions
+
+2. **Payment Issues**
+   - Verify amount is within allowed limits
+   - Check fee settings
+   - Ensure destination is valid
+   - Verify sufficient balance
+
+3. **Event Listener Not Triggering**
+   - Confirm listener is registered with `addEventListener`
+   - Check event type matching in your handler
+   - Add debug logging to trace events
+
+### Debugging
+
+Use the SDK's built-in logging system:
+
+```javascript
+import { setLogger } from '@breeztech/react-native-breez-sdk-liquid';
+
+const setupLogging = async () => {
+  try {
+    const logHandler = (logEntry) => {
+      if (logEntry.level !== 'TRACE') {
+        console.log(`[${logEntry.level}] ${logEntry.line}`);
+      }
+    };
+    
+    await setLogger(logHandler);
+  } catch (error) {
+    console.error('Failed to set logger:', error);
+  }
+};
+```
+
+## Security Considerations
+
+1. **Protecting Mnemonics**
+   - Never hardcode mnemonics in your code
+   - Store securely using React Native's secure storage solutions
+   - Consider using a custom signer for production apps
+
+2. **API Key Security**
+   - Store API keys using environment variables or a secure configuration system
+   - Don't commit API keys to source control
+   - Use different keys for production and testing
+
+3. **Validating Inputs**
+   - Always validate payment destinations
+   - Check amounts are within reasonable limits
+   - Sanitize and validate all external inputs
+    console.error(err)
+  }
+}
+```
+
+#### Logging and Event Handling
+
+```javascript
+// Set up logging
+const setupLogging = async () => {
+  try {
+    // Define a log handler function
+    const onLogEntry = (l: LogEntry) => {
+      console.log(`Received log [${l.level}]: ${l.line}`)
+    }
+
+    const subscription = await setLogger(onLogEntry)
+  } catch (err) {
+    console.error(err)
+  }
+}
+
+// Add an event listener
+const setupEventListener = async () => {
+  try {
+    // Define an event handler function
+    const onEvent = (e: SdkEvent) => {
+      console.log(`Received event: ${e.type}`)
+    }
+
+    const listenerId = await addEventListener(onEvent)
+    return listenerId
+  } catch (err) {
+    console.error(err)
+  }
+}
+
+// Remove an event listener
+const removeListener = async (listenerId: string) => {
+  try {
+    await removeEventListener(listenerId)
+  } catch (err) {
+    console.error(err)
+  }
+}
+
+// Clean up and disconnect
+const cleanupSdk = async () => {
+  try {
+    await disconnect()
+  } catch (err) {
+    console.error(err)
+  }
+}
+```
+
+## Core Features
+
+### Buying Bitcoin
+
+```javascript
+import {
+  buyBitcoin,
+  BuyBitcoinProvider,
+  fetchOnchainLimits,
+  type OnchainPaymentLimitsResponse,
+  type PrepareBuyBitcoinResponse,
+  prepareBuyBitcoin
+} from '@breeztech/react-native-breez-sdk-liquid'
+
+const fetchOnchainLimits = async () => {
+  try {
+    const currentLimits = await fetchOnchainLimits()
+
+    console.log(`Minimum amount, in sats: ${currentLimits.receive.minSat}`)
+    console.log(`Maximum amount, in sats: ${currentLimits.receive.maxSat}`)
+    return currentLimits
+  } catch (err) {
+    console.error(err)
+  }
+}
+
+const prepareBuyBtc = async (currentLimits: OnchainPaymentLimitsResponse) => {
+  try {
+    const prepareRes = await prepareBuyBitcoin({
+      provider: BuyBitcoinProvider.MOONPAY,
+      amountSat: currentLimits.receive.minSat
+    })
+
+    // Check the fees are acceptable before proceeding
+    const receiveFeesSat = prepareRes.feesSat
+    console.log(`Fees: ${receiveFeesSat} sats`)
+    return prepareRes
+  } catch (err) {
+    console.error(err)
+  }
+}
+
+const buyBtc = async (prepareResponse: PrepareBuyBitcoinResponse) => {
+  try {
+    const url = await buyBitcoin({
+      prepareResponse
+    })
+    // Open URL in a WebView or external browser
+  } catch (err) {
+    console.error(err)
+  }
+}
+```
+
+### Fiat Currencies
+
+```javascript
+import {
+  listFiatCurrencies,
+  fetchFiatRates
+} from '@breeztech/react-native-breez-sdk-liquid'
+
+const getFiatCurrencies = async () => {
+  try {
+    const fiatCurrencies = await listFiatCurrencies()
+    return fiatCurrencies
+  } catch (err) {
+    console.error(err)
+  }
+}
+
+const getFiatRates = async () => {
+  try {
+    const fiatRates = await fetchFiatRates()
+    return fiatRates
+  } catch (err) {
+    console.error(err)
+  }
+}
+```
+
+### Sending Payments
+
+#### Lightning Payments
+
+Sending Lightning payments involves a submarine swap and two Liquid on-chain transactions. The process is as follows:
+
+1. User broadcasts an L-BTC transaction to a Liquid lockup address.
+2. Swapper pays the invoice, sending to the recipient, and then gets a preimage.
+3. Swapper broadcasts an L-BTC transaction to claim the funds from the Liquid lockup address.
+
+The fee a user pays to send a Lightning payment is composed of three parts:
+
+1. **Lockup Transaction Fee:** ~34 sats (0.1 sat/discount vbyte).
+2. **Claim Transaction Fee:** ~19 sats (0.1 sat/discount vbyte).
+3. **Swap Service Fee:** 0.1% fee on the amount sent.
+
+Note: swap service fee is dynamic and can change. Currently, it is 0.1%.
+
+> **Example**: If the user sends 10k sats, the fee would be:
+> 
+> - 34 sats [Lockup Transaction Fee] + 19 sats [Claim Transaction Fee] + 10 sats [Swapper Service Fee] = 63 sats
+
+```javascript
+import {
+  prepareSendPayment,
+  sendPayment,
+  type PayAmount,
+  PayAmountVariant,
+  type PrepareSendResponse
+} from '@breeztech/react-native-breez-sdk-liquid'
+
+const prepareSendPaymentLightningBolt11 = async () => {
+  // Set the bolt11 invoice you wish to pay
+  try {
+    const prepareResponse = await prepareSendPayment({
+      destination: '<bolt11 invoice>'
+    })
+
+    // If the fees are acceptable, continue to create the Send Payment
+    const sendFeesSat = prepareResponse.feesSat
+    console.log(`Fees: ${sendFeesSat} sats`)
+    return prepareResponse
+  } catch (err) {
+    console.error(err)
+  }
+}
+
+const prepareSendPaymentLightningBolt12 = async () => {
+  // Set the bolt12 offer you wish to pay
+  try {
+    const optionalAmount: PayAmount = {
+      type: PayAmountVariant.BITCOIN,
+      receiverAmountSat: 5_000
+    }
+
+    const prepareResponse = await prepareSendPayment({
+      destination: '<bolt12 offer>',
+      amount: optionalAmount
+    })
+    
+    return prepareResponse
+  } catch (err) {
+    console.error(err)
+  }
+}
+```
+
+#### Liquid Payments
+
+```javascript
+const prepareSendPaymentLiquid = async () => {
+  // Set the Liquid BIP21 or Liquid address you wish to pay
+  try {
+    const optionalAmount: PayAmount = {
+      type: PayAmountVariant.BITCOIN,
+      receiverAmountSat: 5_000
+    }
+
+    const prepareResponse = await prepareSendPayment({
+      destination: '<Liquid BIP21 or address>',
+      amount: optionalAmount
+    })
+
+    // If the fees are acceptable, continue to create the Send Payment
+    const sendFeesSat = prepareResponse.feesSat
+    console.log(`Fees: ${sendFeesSat} sats`)
+    return prepareResponse
+  } catch (err) {
+    console.error(err)
+  }
+}
+
+const prepareSendPaymentLiquidDrain = async () => {
+  // Set the Liquid BIP21 or Liquid address you wish to pay
+  try {
+    const optionalAmount: PayAmount = {
+      type: PayAmountVariant.DRAIN
+    }
+
+    const prepareResponse = await prepareSendPayment({
+      destination: '<Liquid BIP21 or address>',
+      amount: optionalAmount
+    })
+
+    // If the fees are acceptable, continue to create the Send Payment
+    const sendFeesSat = prepareResponse.feesSat
+    console.log(`Fees: ${sendFeesSat} sats`)
+    return prepareResponse
+  } catch (err) {
+    console.error(err)
+  }
+}
+```
+
+#### Execute Payment
+
+```javascript
+const sendPayment = async (prepareResponse: PrepareSendResponse) => {
+  try {
+    const sendResponse = await sendPayment({
+      prepareResponse
+    })
+    const payment = sendResponse.payment
+    return payment
+  } catch (err) {
+    console.error(err)
+  }
+}
+```
+
+### Receiving Payments
+
+#### Lightning Payments
+
+Receiving Lightning payments involves a reverse submarine swap and requires two Liquid on-chain transactions. The process is as follows:
+
+1. Sender pays the Swapper invoice.
+2. Swapper broadcasts an L-BTC transaction to a Liquid lockup address.
+3. SDK claims the funds from the Liquid lockup address and then exposes the preimage.
+4. Swapper uses the preimage to claim the funds from the Liquid lockup address.
+
+The fee a user pays to receive a Lightning payment is composed of three parts:
+
+1. **Lockup Transaction Fee:** ~27 sats (0.1 sat/discount vbyte).
+2. **Claim Transaction Fee:** ~20 sats (0.1 sat/discount vbyte).
+3. **Swap Service Fee:** 0.25% fee on the amount received.
+
+Note: swap service fee is dynamic and can change. Currently, it is 0.25%.
+
+> **Example**: If the sender sends 10k sats, the fee for the end-user would be:
+> 
+> - 27 sats [Lockup Transaction Fee] + 20 sats [Claim Transaction Fee] + 25 sats [Swapper Service Fee] = 72 sats
+
+```javascript
+import {
+  PaymentMethod,
+  type PrepareReceiveResponse,
+  fetchLightningLimits,
+  prepareReceivePayment,
+  type ReceiveAmount,
+  ReceiveAmountVariant,
+  receivePayment
+} from '@breeztech/react-native-breez-sdk-liquid'
+
+const prepareReceiveLightning = async () => {
+  try {
+    // Fetch the Receive lightning limits
+    const currentLimits = await fetchLightningLimits()
+    console.log(`Minimum amount, in sats: ${currentLimits.receive.minSat}`)
+    console.log(`Maximum amount, in sats: ${currentLimits.receive.maxSat}`)
+
+    // Set the amount you wish the payer to send via lightning, which should be within the above limits
+    const optionalAmount: ReceiveAmount = {
+      type: ReceiveAmountVariant.BITCOIN,
+      payerAmountSat: 5_000
+    }
+
+    const prepareResponse = await prepareReceivePayment({
+      paymentMethod: PaymentMethod.LIGHTNING,
+      amount: optionalAmount
+    })
+
+    // If the fees are acceptable, continue to create the Receive Payment
+    const receiveFeesSat = prepareResponse.feesSat
+    console.log(`Fees: ${receiveFeesSat} sats`)
+    return prepareResponse
+  } catch (err) {
+    console.error(err)
+  }
+}
+```
+
+#### Onchain Payments
+
+```javascript
+const prepareReceiveOnchain = async () => {
+  try {
+    // Fetch the Onchain lightning limits
+    const currentLimits = await fetchOnchainLimits()
+    console.log(`Minimum amount, in sats: ${currentLimits.receive.minSat}`)
+    console.log(`Maximum amount, in sats: ${currentLimits.receive.maxSat}`)
+
+    // Set the onchain amount you wish the payer to send, which should be within the above limits
+    const optionalAmount: ReceiveAmount = {
+      type: ReceiveAmountVariant.BITCOIN,
+      payerAmountSat: 5_000
+    }
+
+    const prepareResponse = await prepareReceivePayment({
+      paymentMethod: PaymentMethod.BITCOIN_ADDRESS,
+      amount: optionalAmount
+    })
+
+    // If the fees are acceptable, continue to create the Receive Payment
+    const receiveFeesSat = prepareResponse.feesSat
+    console.log(`Fees: ${receiveFeesSat} sats`)
+    return prepareResponse
+  } catch (err) {
+    console.error(err)
+  }
+}
+```
+
+#### Liquid Payments
+
+```javascript
+const prepareReceiveLiquid = async () => {
+  try {
+    // Create a Liquid BIP21 URI/address to receive a payment to.
+    // There are no limits, but the payer amount should be greater than broadcast fees when specified
+    // Note: Not setting the amount will generate a plain Liquid address
+    const optionalAmount: ReceiveAmount = {
+      type: ReceiveAmountVariant.BITCOIN,
+      payerAmountSat: 5_000
+    }
+
+    const prepareResponse = await prepareReceivePayment({
+      paymentMethod: PaymentMethod.LIQUID_ADDRESS,
+      amount: optionalAmount
+    })
+
+    // If the fees are acceptable, continue to create the Receive Payment
+    const receiveFeesSat = prepareResponse.feesSat
+    console.log(`Fees: ${receiveFeesSat} sats`)
+    return prepareResponse
+  } catch (err) {
+    console.error(err)
+  }
+}
+```
+
+#### Execute Receive
+
+```javascript
+const receivePaymentFromPrepared = async (prepareResponse: PrepareReceiveResponse) => {
+  try {
+    const optionalDescription = '<description>'
+    const res = await receivePayment({
+      prepareResponse,
+      description: optionalDescription
+    })
+
+    const destination = res.destination
+    return destination
+  } catch (err) {
+    console.error(err)
+  }
+}
+```
+
+### LNURL Operations
+
+#### LNURL Authentication
+
+```javascript
+import {
+  InputTypeVariant,
+  lnurlAuth,
+  LnUrlCallbackStatusVariant,
+  parse
+} from '@breeztech/react-native-breez-sdk-liquid'
+
+const lnurlAuthenticate = async () => {
+  // Endpoint can also be of the form:
+  // keyauth://domain.com/auth?key=val
+  const lnurlAuthUrl =
+        'lnurl1dp68gurn8ghj7mr0vdskc6r0wd6z7mrww4excttvdankjm3lw3skw0tvdankjm3xdvcn6vtp8q6n2dfsx5mrjwtrxdjnqvtzv56rzcnyv3jrxv3sxqmkyenrvv6kve3exv6nqdtyv43nqcmzvdsnvdrzx33rsenxx5unqc3cxgeqgntfgu'
+
+  try {
+    const input = await parse(lnurlAuthUrl)
+    if (input.type === InputTypeVariant.LN_URL_AUTH) {
+      const result = await lnurlAuth(input.data)
+      if (result.type === LnUrlCallbackStatusVariant.OK) {
+        console.log('Successfully authenticated')
+      } else {
+        console.log('Failed to authenticate')
+      }
+    }
+  } catch (err) {
+    console.error(err)
+  }
+}
+```
+
+#### LNURL Pay
+
+```javascript
+import {
+  InputTypeVariant,
+  lnurlPay,
+  type LnUrlPayRequestData,
+  parse,
+  type PayAmount,
+  PayAmountVariant,
+  prepareLnurlPay,
+  type PrepareLnUrlPayResponse
+} from '@breeztech/react-native-breez-sdk-liquid'
+
+const prepareLnurlPayment = async () => {
+  // Endpoint can also be of the
+  // lnurlp://domain.com/lnurl-pay?key=val
+  // lnurl1dp68gurn8ghj7mr0vdskc6r0wd6z7mrww4excttsv9un7um9wdekjmmw84jxywf5x43rvv35xgmr2enrxanr2cfcvsmnwe3jxcukvde48qukgdec89snwde3vfjxvepjxpjnjvtpxd3kvdnxx5crxwpjvyunsephsz36jf
+  const lnurlPayUrl = 'lightning@address.com'
+
+  try {
+    const input = await parse(lnurlPayUrl)
+    if (input.type === InputTypeVariant.LN_URL_PAY) {
+      const amount: PayAmount = {
+        type: PayAmountVariant.BITCOIN,
+        receiverAmountSat: 5_000
+      }
+      const optionalComment = '<comment>'
+      const optionalValidateSuccessActionUrl = true
+
+      const prepareResponse = await prepareLnurlPay({
+        data: input.data,
+        amount,
+        bip353Address: input.bip353Address,
+        comment: optionalComment,
+        validateSuccessActionUrl: optionalValidateSuccessActionUrl
+      })
+
+      // If the fees are acceptable, continue to create the LNURL Pay
+      const feesSat = prepareResponse.feesSat
+      console.log(`Fees: ${feesSat} sats`)
+      return prepareResponse
+    }
+  } catch (err) {
+    console.error(err)
+  }
+}
+
+const executeLnurlPay = async (prepareResponse: PrepareLnUrlPayResponse) => {
+  try {
+    const result = await lnurlPay({
+      prepareResponse
+    })
+    return result
+  } catch (err) {
+    console.error(err)
+  }
+}
+```
+
+#### LNURL Withdraw
+
+```javascript
+import {
+  InputTypeVariant,
+  lnurlWithdraw,
+  parse
+} from '@breeztech/react-native-breez-sdk-liquid'
+
+const executeLnurlWithdraw = async () => {
+  // Endpoint can also be of the form:
+  // lnurlw://domain.com/lnurl-withdraw?key=val
+  const lnurlWithdrawUrl =
+        'lnurl1dp68gurn8ghj7mr0vdskc6r0wd6z7mrww4exctthd96xserjv9mn7um9wdekjmmw843xxwpexdnxzen9vgunsvfexq6rvdecx93rgdmyxcuxverrvcursenpxvukzv3c8qunsdecx33nzwpnvg6ryc3hv93nzvecxgcxgwp3h33lxk'
+
+  try {
+    const input = await parse(lnurlWithdrawUrl)
+    if (input.type === InputTypeVariant.LN_URL_WITHDRAW) {
+      const amountMsat = input.data.minWithdrawable
+      const lnUrlWithdrawResult = await lnurlWithdraw({
+        data: input.data,
+        amountMsat,
+        description: 'comment'
+      })
+      return lnUrlWithdrawResult
+    }
+  } catch (err) {
+    console.error(err)
+  }
+}
+```
+
+### Onchain Operations
+
+#### Pay Onchain
+
+```javascript
+import {
+  type PreparePayOnchainResponse,
+  fetchOnchainLimits,
+  preparePayOnchain,
+  payOnchain,
+  PayAmountVariant
+} from '@breeztech/react-native-breez-sdk-liquid'
+
+const checkPayOnchainLimits = async () => {
+  try {
+    const currentLimits = await fetchOnchainLimits()
+
+    console.log(`Minimum amount, in sats: ${currentLimits.send.minSat}`)
+    console.log(`Maximum amount, in sats: ${currentLimits.send.maxSat}`)
+    return currentLimits
+  } catch (err) {
+    console.error(err)
+  }
+}
+
+const prepareOnchainPayment = async () => {
+  try {
+    const prepareResponse = await preparePayOnchain({
+      amount: {
+        type: PayAmountVariant.BITCOIN,
+        receiverAmountSat: 5_000
+      }
+    })
+
+    // Check if the fees are acceptable before proceeding
+    const totalFeesSat = prepareResponse.totalFeesSat
+    console.log(`Total fees: ${totalFeesSat} sats`)
+    return prepareResponse
+  } catch (err) {
+    console.error(err)
+  }
+}
+
+const prepareOnchainPaymentWithFeeRate = async () => {
+  try {
+    const optionalSatPerVbyte = 21
+
+    const prepareResponse = await preparePayOnchain({
+      amount: {
+        type: PayAmountVariant.BITCOIN,
+        receiverAmountSat: 5_000
+      },
+      feeRateSatPerVbyte: optionalSatPerVbyte
+    })
+
+    // Check if the fees are acceptable before proceeding
+    const claimFeesSat = prepareResponse.claimFeesSat
+    const totalFeesSat = prepareResponse.totalFeesSat
+    console.log(`Claim fees: ${claimFeesSat} sats, Total fees: ${totalFeesSat} sats`)
+    return prepareResponse
+  } catch (err) {
+    console.error(err)
+  }
+}
+
+const executePayOnchain = async (prepareResponse: PreparePayOnchainResponse) => {
+  try {
+    const destinationAddress = 'bc1..'
+
+    const payOnchainRes = await payOnchain({
+      address: destinationAddress,
+      prepareResponse
+    })
+    return payOnchainRes
+  } catch (err) {
+    console.error(err)
+  }
+}
+```
+
+#### Drain Funds
+
+```javascript
+const preparePayOnchainDrain = async () => {
+  try {
+    const prepareResponse = await preparePayOnchain({
+      amount: {
+        type: PayAmountVariant.DRAIN
+      }
+    })
+
+    // Check if the fees are acceptable before proceeding
+    const totalFeesSat = prepareResponse.totalFeesSat
+    console.log(`Total fees: ${totalFeesSat} sats`)
+    return prepareResponse
+  } catch (err) {
+    console.error(err)
+  }
+}
+```
+
+#### Receive Onchain
+
+```javascript
+import {
+  listRefundables,
+  rescanOnchainSwaps,
+  type RefundableSwap,
+  refund,
+  recommendedFees,
+  listPayments,
+  fetchPaymentProposedFees,
+  acceptPaymentProposedFees,
+  PaymentState,
+  PaymentDetailsVariant
+} from '@breeztech/react-native-breez-sdk-liquid'
+
+const getRefundables = async () => {
+  try {
+    const refundables = await listRefundables()
+    return refundables
+  } catch (err) {
+    console.error(err)
+  }
+}
+
+const executeRefund = async (refundable: RefundableSwap, refundTxFeeRate: number) => {
+  try {
+    const destinationAddress = '...'
+    const feeRateSatPerVbyte = refundTxFeeRate
+
+    const refundResponse = await refund({
+      swapAddress: refundable.swapAddress,
+      refundAddress: destinationAddress,
+      feeRateSatPerVbyte
+    })
+    return refundResponse
+  } catch (err) {
+    console.error(err)
+  }
+}
+
+const rescanSwaps = async () => {
+  try {
+    await rescanOnchainSwaps()
+  } catch (err) {
+    console.error(err)
+  }
+}
+
+const getRecommendedFees = async () => {
+  try {
+    const fees = await recommendedFees()
+    return fees
+  } catch (err) {
+    console.error(err)
+  }
+}
+```
+
+#### Handle Fee Acceptance
+
+```javascript
+const handlePaymentsWaitingFeeAcceptance = async () => {
+  try {
+    // Payments on hold waiting for fee acceptance have the state WAITING_FEE_ACCEPTANCE
+    const paymentsWaitingFeeAcceptance = await listPayments({
+      states: [PaymentState.WAITING_FEE_ACCEPTANCE]
+    })
+
+    for (const payment of paymentsWaitingFeeAcceptance) {
+      if (payment.details.type !== PaymentDetailsVariant.BITCOIN) {
+        // Only Bitcoin payments can be `WAITING_FEE_ACCEPTANCE`
+        continue
+      }
+
+      const fetchFeesResponse = await fetchPaymentProposedFees({
+        swapId: payment.details.swapId
+      })
+
+      console.info(
+        `Payer sent ${fetchFeesResponse.payerAmountSat} and currently proposed fees are ${fetchFeesResponse.feesSat}`
+      )
+
+      // If the user is ok with the fees, accept them, allowing the payment to proceed
+      await acceptPaymentProposedFees({
+        response: fetchFeesResponse
+      })
+    }
+  } catch (err) {
+    console.error(err)
+  }
+}
+```
+
+### Non-Bitcoin Assets
+
+```javascript
+import {
+  defaultConfig,
+  getInfo,
+  LiquidNetwork,
+  PaymentMethod,
+  type PayAmount,
+  PayAmountVariant,
+  prepareSendPayment,
+  prepareReceivePayment,
+  type ReceiveAmount,
+  ReceiveAmountVariant
+} from '@breeztech/react-native-breez-sdk-liquid'
+
+const prepareAssetPayment = async () => {
+  try {
+    // Create a Liquid BIP21 URI/address to receive an asset payment to.
+    // Note: Not setting the amount will generate an amountless BIP21 URI.
+    const usdtAssetId = 'ce091c998b83c78bb71a632313ba3760f1763d9cfcffae02258ffa9865a37bd2'
+    const optionalAmount: ReceiveAmount = {
+      type: ReceiveAmountVariant.ASSET,
+      assetId: usdtAssetId,
+      payerAmount: 1.50
+    }
+
+    const prepareResponse = await prepareReceivePayment({
+      paymentMethod: PaymentMethod.LIQUID_ADDRESS,
+      amount: optionalAmount
+    })
+
+    // If the fees are acceptable, continue to create the Receive Payment
+    const receiveFeesSat = prepareResponse.feesSat
+    console.log(`Fees: ${receiveFeesSat} sats`)
+    return prepareResponse
+  } catch (err) {
+    console.error(err)
+  }
+}
+
+const prepareSendPaymentAsset = async () => {
+  try {
+    // Set the Liquid BIP21 or Liquid address you wish to pay
+    const destination = '<Liquid BIP21 or address>'
+    // If the destination is an address or an amountless BIP21 URI,
+    // you must specifiy an asset amount
+
+    const usdtAssetId = 'ce091c998b83c78bb71a632313ba3760f1763d9cfcffae02258ffa9865a37bd2'
+    const optionalAmount: PayAmount = {
+      type: PayAmountVariant.ASSET,
+      assetId: usdtAssetId,
+      receiverAmount: 1.50
+    }
+
+    const prepareResponse = await prepareSendPayment({
+      destination,
+      amount: optionalAmount
+    })
+
+    // If the fees are acceptable, continue to create the Send Payment
+    const sendFeesSat = prepareResponse.feesSat
+    console.log(`Fees: ${sendFeesSat} sats`)
+    return prepareResponse
+  } catch (err) {
+    console.error(err)
+  }
+}
+
+const configureAssetMetadata = async () => {
+  try {
+    // Create the default config
+    const config = await defaultConfig(
+      LiquidNetwork.MAINNET,
+      '<your-Breez-API-key>'
+    )
+
+    // Configure asset metadata
+    config.assetMetadata = [
+      {
+        assetId: '18729918ab4bca843656f08d4dd877bed6641fbd596a0a963abbf199cfeb3cec',
+        name: 'PEGx EUR',
+        ticker: 'EURx',
+        precision: 8
+      }
+    ]
+    return config
+  } catch (err) {
\ No newline at end of file
diff --git a/examples/breez-nodeless-llms/breez-nodeless-rust-llms.md b/examples/breez-nodeless-llms/breez-nodeless-rust-llms.md
new file mode 100644
index 00000000..c4ee5bf3
--- /dev/null
+++ b/examples/breez-nodeless-llms/breez-nodeless-rust-llms.md
@@ -0,0 +1,1398 @@
+# Breez SDK Nodeless  Documentation
+
+This comprehensive document provides all the context needed to build applications with the Rust bindings of Breez SDK Nodeless, a toolkit for integrating Bitcoin, Lightning Network, and Liquid Network functionality into your applications.
+
+## Overview
+
+Breez SDK Nodeless is a powerful library that allows developers to integrate Bitcoin, Lightning Network, and Liquid Network functionality into their applications. The SDK abstracts many of the complexities of working with these technologies, providing a simple interface for common operations such as sending and receiving payments, managing wallets, and interacting with both Lightning and Liquid networks.
+
+Key capabilities include:
+- Wallet management and balance tracking
+- Lightning Network payments
+- Liquid Network transactions
+- Onchain Bitcoin operations
+- LNURL support (auth, pay, withdraw)
+- Non-Bitcoin asset management
+- Webhook integration
+- Event handling with listeners
+
+## Getting Started
+
+### Installation
+
+```toml
+# Add to your Cargo.toml
+[dependencies]
+breez-sdk-liquid = { git = "https://github.com/breez/breez-sdk-liquid", tag = "0.7.2" }
+```
+
+### Guidelines
+- **Always make sure the SDK instance is synced before performing any actions**
+- **Add logging**: Add sufficient logging into your application to diagnose any issues users are having.
+- **Display pending payments**: Payments always contain a status field that can be used to determine if the payment was completed or not. Make sure you handle the case where the payment is still pending by showing the correct status to the user.
+- **Enable swap refunds**: Swaps that are the result of receiving an On-Chain Transaction may not be completed and change to `Refundable` state. Make sure you handle this case correctly by allowing the user to retry the refund with different fees as long as the refund is not confirmed.
+- **Expose swap fees**: When sending or receiving on-chain, make sure to clearly show the expected fees involved, as well as the send/receive amounts.
+
+### Initializing the SDK
+
+To get started with Breez SDK Nodeless (Liquid implementation), you need to initialize the SDK with your configuration:
+
+```rust
+use std::sync::Arc;
+use anyhow::Result;
+use bip39::{Language, Mnemonic};
+use breez_sdk_liquid::prelude::*;
+use log::info;
+
+async fn getting_started() -> Result<Arc<LiquidSdk>> {
+    let mnemonic = Mnemonic::generate_in(Language::English, 12)?;
+
+    // Create the default config, providing your Breez API key
+    let mut config = LiquidSdk::default_config(
+        LiquidNetwork::Mainnet,
+        Some("<your-Breez-API-key>".to_string()),
+    )?;
+
+    // Customize the config object according to your needs
+    config.working_dir = "path to an existing directory".into();
+
+    let connect_request = ConnectRequest {
+        config,
+        mnemonic: Some(mnemonic.to_string()),
+        passphrase: None,
+        seed: None,
+    };
+    let sdk = LiquidSdk::connect(connect_request).await?;
+    
+    Ok(sdk)
+}
+```
+
+### Custom Signer Support
+
+If you prefer to manage your own keys, you can use a custom signer:
+
+```rust
+use std::sync::Arc;
+use anyhow::Result;
+use breez_sdk_liquid::prelude::*;
+
+async fn connect_with_self_signer(signer: Signer) -> Result<Arc<LiquidSdk>> {  
+    // Create the default config, providing your Breez API key
+    let mut config = LiquidSdk::default_config(LiquidNetwork::Mainnet, Some("<your-Breez-API-key>".to_string()))?;
+
+    // Customize the config object according to your needs
+    config.working_dir = "path to an existing directory".into();
+
+    let connect_request = ConnectWithSignerRequest {      
+        config,
+    };
+    let sdk = LiquidSdk::connect_with_signer(connect_request, signer).await?;
+
+    Ok(sdk)
+}
+```
+
+### Basic Operations
+
+#### Fetch Balance
+- **Always make sure the SDK instance is synced before performing any actions**
+
+```rust
+async fn fetch_balance(sdk: Arc<LiquidSdk>) -> Result<()> {
+    let info = sdk.get_info().await?;
+    let balance_sat = info.wallet_info.balance_sat;
+    let pending_send_sat = info.wallet_info.pending_send_sat;
+    let pending_receive_sat = info.wallet_info.pending_receive_sat;
+    
+    Ok(())
+}
+```
+
+#### Logging and Event Handling
+
+```rust
+// Define an event listener
+struct CliEventListener {}
+impl EventListener for CliEventListener {
+    fn on_event(&self, e: SdkEvent) {
+        info!("Received event: {:?}", e);
+    }
+}
+
+async fn add_event_listener(
+    sdk: Arc<LiquidSdk>,
+    listener: Box<CliEventListener>,
+) -> Result<String> {
+    let listener_id = sdk.add_event_listener(listener).await?;
+    Ok(listener_id)
+}
+
+// Remove an event listener
+async fn remove_event_listener(sdk: Arc<LiquidSdk>, listener_id: String) -> Result<()> {
+    sdk.remove_event_listener(listener_id).await?;
+    Ok(())
+}
+
+// Disconnect from the SDK
+async fn disconnect(sdk: Arc<LiquidSdk>) -> Result<()> {
+    sdk.disconnect().await?;
+    Ok(())
+}
+```
+
+## Core Features
+
+### Buying Bitcoin
+
+```rust
+async fn fetch_onchain_limits(sdk: Arc<LiquidSdk>) -> Result<OnchainPaymentLimitsResponse> {
+    let current_limits = sdk.fetch_onchain_limits().await?;
+
+    info!("Minimum amount: {} sats", current_limits.receive.min_sat);
+    info!("Maximum amount: {} sats", current_limits.receive.max_sat);
+    
+    Ok(current_limits)
+}
+
+async fn prepare_buy_bitcoin(
+    sdk: Arc<LiquidSdk>,
+    current_limits: OnchainPaymentLimitsResponse,
+) -> Result<PrepareBuyBitcoinResponse> {
+    let prepare_response = sdk
+        .prepare_buy_bitcoin(PrepareBuyBitcoinRequest {
+            provider: BuyBitcoinProvider::Moonpay,
+            amount_sat: current_limits.receive.min_sat,
+        })
+        .await?;
+
+    // Check the fees are acceptable before proceeding
+    let receive_fees_sat = prepare_response.fees_sat;
+    info!("Fees: {} sats", receive_fees_sat);
+    
+    Ok(prepare_response)
+}
+
+async fn buy_bitcoin(
+    sdk: Arc<LiquidSdk>,
+    prepare_response: PrepareBuyBitcoinResponse,
+) -> Result<String> {
+    let url = sdk.buy_bitcoin(BuyBitcoinRequest {
+        prepare_response,
+        redirect_url: None,
+    })
+    .await?;
+    
+    Ok(url)
+}
+```
+
+### Fiat Currencies
+
+```rust
+async fn list_supported_fiat_currencies(sdk: Arc<LiquidSdk>) -> Result<()> {
+    let supported_fiat_currencies = sdk.list_fiat_currencies().await?;
+    Ok(())
+}
+
+async fn get_current_rates(sdk: Arc<LiquidSdk>) -> Result<()> {
+    let fiat_rates = sdk.fetch_fiat_rates().await?;
+    Ok(())
+}
+```
+
+### Sending Payments
+
+#### Lightning Payments
+
+Sending Lightning payments involves a submarine swap and two Liquid on-chain transactions. The process is as follows:
+
+1. User broadcasts an L-BTC transaction to a Liquid lockup address.
+2. Swapper pays the invoice, sending to the recipient, and then gets a preimage.
+3. Swapper broadcasts an L-BTC transaction to claim the funds from the Liquid lockup address.
+
+The fee a user pays to send a Lightning payment is composed of three parts:
+
+1. **Lockup Transaction Fee:** ~34 sats (0.1 sat/discount vbyte).
+2. **Claim Transaction Fee:** ~19 sats (0.1 sat/discount vbyte).
+3. **Swap Service Fee:** 0.1% fee on the amount sent.
+
+Note: swap service fee is dynamic and can change. Currently, it is 0.1%.
+
+> **Example**: If the user sends 10k sats, the fee would be:
+> 
+> - 34 sats [Lockup Transaction Fee] + 19 sats [Claim Transaction Fee] + 10 sats [Swapper Service Fee] = 63 sats
+
+```rust
+async fn prepare_send_payment_lightning_bolt11(sdk: Arc<LiquidSdk>) -> Result<()> {
+    // Set the bolt11 invoice you wish to pay
+    let prepare_response = sdk
+        .prepare_send_payment(&PrepareSendRequest {
+            destination: "<bolt11 invoice>".to_string(),
+            amount: None,
+        })
+        .await?;
+
+    // If the fees are acceptable, continue to create the Send Payment
+    let send_fees_sat = prepare_response.fees_sat;
+    info!("Fees: {} sats", send_fees_sat);
+    
+    Ok(())
+}
+
+async fn prepare_send_payment_lightning_bolt12(sdk: Arc<LiquidSdk>) -> Result<()> {
+    // Set the bolt12 offer you wish to pay to
+    let optional_amount = Some(PayAmount::Bitcoin {
+        receiver_amount_sat: 5_000,
+    });
+    let prepare_response = sdk
+        .prepare_send_payment(&PrepareSendRequest {
+            destination: "<bolt12 offer>".to_string(),
+            amount: optional_amount,
+        })
+        .await?;
+        
+    Ok(())
+}
+```
+
+#### Liquid Payments
+
+```rust
+async fn prepare_send_payment_liquid(sdk: Arc<LiquidSdk>) -> Result<()> {
+    // Set the Liquid BIP21 or Liquid address you wish to pay
+    let optional_amount = Some(PayAmount::Bitcoin {
+        receiver_amount_sat: 5_000,
+    });
+    let prepare_response = sdk
+        .prepare_send_payment(&PrepareSendRequest {
+            destination: "<Liquid BIP21 or address>".to_string(),
+            amount: optional_amount,
+        })
+        .await?;
+
+    // If the fees are acceptable, continue to create the Send Payment
+    let send_fees_sat = prepare_response.fees_sat;
+    info!("Fees: {} sats", send_fees_sat);
+    
+    Ok(())
+}
+
+async fn prepare_send_payment_liquid_drain(sdk: Arc<LiquidSdk>) -> Result<()> {
+    // Set the Liquid BIP21 or Liquid address you wish to pay
+    let optional_amount = Some(PayAmount::Drain);
+    let prepare_response = sdk
+        .prepare_send_payment(&PrepareSendRequest {
+            destination: "<Liquid BIP21 or address>".to_string(),
+            amount: optional_amount,
+        })
+        .await?;
+
+    // If the fees are acceptable, continue to create the Send Payment
+    let send_fees_sat = prepare_response.fees_sat;
+    info!("Fees: {} sats", send_fees_sat);
+    
+    Ok(())
+}
+```
+
+#### Execute Payment
+- **Always make sure the SDK instance is synced before performing any actions**
+
+```rust
+async fn send_payment(sdk: Arc<LiquidSdk>, prepare_response: PrepareSendResponse) -> Result<()> {
+    let send_response = sdk
+        .send_payment(&SendPaymentRequest { prepare_response })
+        .await?;
+    let payment = send_response.payment;
+    
+    Ok(())
+}
+```
+
+### Receiving Payments
+**Always make sure the SDK instance is synced before performing any actions**
+
+#### Lightning Payments
+Receiving Lightning payments involves a reverse submarine swap and requires two Liquid on-chain transactions. The process is as follows:
+
+1. Sender pays the Swapper invoice.
+2. Swapper broadcasts an L-BTC transaction to a Liquid lockup address.
+3. SDK claims the funds from the Liquid lockup address and then exposes the preimage.
+4. Swapper uses the preimage to claim the funds from the Liquid lockup address.
+
+The fee a user pays to receive a Lightning payment is composed of three parts:
+
+1. **Lockup Transaction Fee:** ~27 sats (0.1 sat/discount vbyte).
+2. **Claim Transaction Fee:** ~20 sats (0.1 sat/discount vbyte).
+3. **Swap Service Fee:** 0.25% fee on the amount received.
+
+Note: swap service fee is dynamic and can change. Currently, it is 0.25%.
+
+> **Example**: If the sender sends 10k sats, the fee for the end-user would be:
+> 
+> - 27 sats [Lockup Transaction Fee] + 20 sats [Claim Transaction Fee] + 25 sats [Swapper Service Fee] = 72 sats
+
+```rust
+async fn prepare_receive_lightning(sdk: Arc<LiquidSdk>) -> Result<()> {
+    // Fetch the Receive lightning limits
+    let current_limits = sdk.fetch_lightning_limits().await?;
+    info!("Minimum amount: {} sats", current_limits.receive.min_sat);
+    info!("Maximum amount: {} sats", current_limits.receive.max_sat);
+
+    // Set the invoice amount you wish the payer to send, which should be within the above limits
+    let optional_amount = Some(ReceiveAmount::Bitcoin {
+        payer_amount_sat: 5_000,
+    });
+    let prepare_response = sdk
+        .prepare_receive_payment(&PrepareReceiveRequest {
+            payment_method: PaymentMethod::Lightning,
+            amount: optional_amount,
+        })
+        .await?;
+
+    // If the fees are acceptable, continue to create the Receive Payment
+    let receive_fees_sat = prepare_response.fees_sat;
+    info!("Fees: {} sats", receive_fees_sat);
+    
+    Ok(())
+}
+```
+
+#### Onchain Payments
+
+```rust
+async fn prepare_receive_onchain(sdk: Arc<LiquidSdk>) -> Result<()> {
+    // Fetch the Receive onchain limits
+    let current_limits = sdk.fetch_onchain_limits().await?;
+    info!("Minimum amount: {} sats", current_limits.receive.min_sat);
+    info!("Maximum amount: {} sats", current_limits.receive.max_sat);
+
+    // Set the onchain amount you wish the payer to send, which should be within the above limits
+    let optional_amount = Some(ReceiveAmount::Bitcoin {
+        payer_amount_sat: 5_000,
+    });
+    let prepare_response = sdk
+        .prepare_receive_payment(&PrepareReceiveRequest {
+            payment_method: PaymentMethod::BitcoinAddress,
+            amount: optional_amount,
+        })
+        .await?;
+
+    // If the fees are acceptable, continue to create the Receive Payment
+    let receive_fees_sat = prepare_response.fees_sat;
+    info!("Fees: {} sats", receive_fees_sat);
+    
+    Ok(())
+}
+```
+
+#### Liquid Payments
+
+```rust
+async fn prepare_receive_liquid(sdk: Arc<LiquidSdk>) -> Result<()> {
+    // Create a Liquid BIP21 URI/address to receive a payment to.
+    // There are no limits, but the payer amount should be greater than broadcast fees when specified
+    // Note: Not setting the amount will generate a plain Liquid address
+    let optional_amount = Some(ReceiveAmount::Bitcoin {
+        payer_amount_sat: 5_000,
+    });
+    let prepare_response = sdk
+        .prepare_receive_payment(&PrepareReceiveRequest {
+            payment_method: PaymentMethod::LiquidAddress,
+            amount: optional_amount,
+        })
+        .await?;
+
+    // If the fees are acceptable, continue to create the Receive Payment
+    let receive_fees_sat = prepare_response.fees_sat;
+    info!("Fees: {} sats", receive_fees_sat);
+    
+    Ok(())
+}
+```
+
+#### Execute Receive
+
+```rust
+async fn receive_payment(sdk: Arc<LiquidSdk>, prepare_response: PrepareReceiveResponse) -> Result<()> {
+    let optional_description = Some("<description>".to_string());
+    let res = sdk
+        .receive_payment(&ReceivePaymentRequest {
+            prepare_response,
+            description: optional_description,
+            use_description_hash: None,
+        })
+        .await?;
+
+    let destination = res.destination;
+    
+    Ok(())
+}
+```
+
+### LNURL Operations
+
+#### LNURL Authentication
+
+```rust
+async fn auth(sdk: Arc<LiquidSdk>) -> Result<()> {
+    // Endpoint can also be of the form:
+    // keyauth://domain.com/auth?key=val
+    let lnurl_auth_url = "lnurl1dp68gurn8ghj7mr0vdskc6r0wd6z7mrww4excttvdankjm3lw3skw0tvdankjm3xdvcn6vtp8q6n2dfsx5mrjwtrxdjnqvtzv56rzcnyv3jrxv3sxqmkyenrvv6kve3exv6nqdtyv43nqcmzvdsnvdrzx33rsenxx5unqc3cxgeqgntfgu";
+
+    if let Ok(InputType::LnUrlAuth { data: ad }) = sdk.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(())
+}
+```
+
+#### LNURL Pay
+
+```rust
+async fn prepare_pay(sdk: Arc<LiquidSdk>) -> Result<()> {
+    // Endpoint can also be of the form:
+    // lnurlp://domain.com/lnurl-pay?key=val
+    let lnurl_pay_url = "lightning@address.com";
+
+    if let Ok(InputType::LnUrlPay { data, bip353_address }) = sdk.parse(lnurl_pay_url).await {
+        let amount = PayAmount::Bitcoin {
+            receiver_amount_sat: 5_000,
+        };
+        let optional_comment = Some("<comment>".to_string());
+        let optional_validate_success_action_url = Some(true);
+
+        let prepare_response = sdk
+            .prepare_lnurl_pay(PrepareLnUrlPayRequest {
+                data,
+                amount,
+                bip353_address,
+                comment: optional_comment,
+                validate_success_action_url: optional_validate_success_action_url,
+            })
+            .await?;
+
+        // If the fees are acceptable, continue to create the LNURL Pay
+        let fees_sat = prepare_response.fees_sat;
+        info!("Fees: {} sats", fees_sat);
+    }
+    
+    Ok(())
+}
+
+async fn pay(sdk: Arc<LiquidSdk>, prepare_response: PrepareLnUrlPayResponse) -> Result<()> {
+    let result = sdk.lnurl_pay(LnUrlPayRequest { prepare_response }).await?;
+    
+    Ok(())
+}
+```
+
+#### LNURL Withdraw
+
+```rust
+async fn withdraw(sdk: Arc<LiquidSdk>) -> Result<()> {
+    // Endpoint can also be of the form:
+    // lnurlw://domain.com/lnurl-withdraw?key=val
+    let lnurl_withdraw_url = "lnurl1dp68gurn8ghj7mr0vdskc6r0wd6z7mrww4exctthd96xserjv9mn7um9wdekjmmw843xxwpexdnxzen9vgunsvfexq6rvdecx93rgdmyxcuxverrvcursenpxvukzv3c8qunsdecx33nzwpnvg6ryc3hv93nzvecxgcxgwp3h33lxk";
+
+    if let Ok(InputType::LnUrlWithdraw { data: wd }) = sdk.parse(lnurl_withdraw_url).await {
+        let amount_msat = wd.min_withdrawable;
+        let description = "Test withdraw".to_string();
+
+        sdk.lnurl_withdraw(LnUrlWithdrawRequest {
+            data: wd,
+            amount_msat,
+            description: Some(description),
+        })
+        .await?;
+    }
+    
+    Ok(())
+}
+```
+
+### Onchain Operations
+
+#### Pay Onchain
+
+```rust
+async fn get_current_limits(sdk: Arc<LiquidSdk>) -> Result<()> {
+    let current_limits = sdk.fetch_onchain_limits().await?;
+
+    info!("Minimum amount: {} sats", current_limits.send.min_sat);
+    info!("Maximum amount: {} sats", current_limits.send.max_sat);
+
+    Ok(())
+}
+
+async fn prepare_pay_onchain(sdk: Arc<LiquidSdk>) -> Result<()> {
+    let prepare_res = sdk
+        .prepare_pay_onchain(&PreparePayOnchainRequest {
+            amount: PayAmount::Bitcoin {
+                receiver_amount_sat: 5_000,
+            },
+            fee_rate_sat_per_vbyte: None,
+        })
+        .await?;
+
+    // Check if the fees are acceptable before proceeding
+    let total_fees_sat = prepare_res.total_fees_sat;
+    
+    Ok(())
+}
+
+async fn prepare_pay_onchain_fee_rate(sdk: Arc<LiquidSdk>) -> Result<()> {
+    let optional_sat_per_vbyte = Some(21);
+
+    let prepare_res = sdk
+        .prepare_pay_onchain(&PreparePayOnchainRequest {
+            amount: PayAmount::Bitcoin {
+                receiver_amount_sat: 5_000,
+            },
+            fee_rate_sat_per_vbyte: optional_sat_per_vbyte,
+        })
+        .await?;
+
+    // Check if the fees are acceptable before proceeding
+    let claim_fees_sat = prepare_res.claim_fees_sat;
+    let total_fees_sat = prepare_res.total_fees_sat;
+    
+    Ok(())
+}
+
+async fn start_pay_onchain(
+    sdk: Arc<LiquidSdk>,
+    prepare_response: PreparePayOnchainResponse,
+) -> Result<()> {
+    let destination_address = String::from("bc1..");
+
+    sdk.pay_onchain(&PayOnchainRequest {
+        address: destination_address,
+        prepare_response,
+    })
+    .await?;
+    
+    Ok(())
+}
+```
+
+#### Drain Funds
+
+```rust
+async fn prepare_pay_onchain_drain(sdk: Arc<LiquidSdk>) -> Result<()> {
+    let prepare_res = sdk
+        .prepare_pay_onchain(&PreparePayOnchainRequest {
+            amount: PayAmount::Drain,
+            fee_rate_sat_per_vbyte: None,
+        })
+        .await?;
+
+    // Check if the fees are acceptable before proceeding
+    let total_fees_sat = prepare_res.total_fees_sat;
+    
+    Ok(())
+}
+```
+
+#### Receive Onchain
+
+```rust
+async fn list_refundables(sdk: Arc<LiquidSdk>) -> Result<()> {
+    let refundables = sdk.list_refundables().await?;
+    
+    Ok(())
+}
+
+async fn execute_refund(
+    sdk: Arc<LiquidSdk>,
+    refund_tx_fee_rate: u32,
+    refundable: RefundableSwap,
+) -> Result<()> {
+    let destination_address = "...".into();
+    let fee_rate_sat_per_vbyte = refund_tx_fee_rate;
+
+    sdk.refund(&RefundRequest {
+        swap_address: refundable.swap_address,
+        refund_address: destination_address,
+        fee_rate_sat_per_vbyte,
+    })
+    .await?;
+    
+    Ok(())
+}
+
+async fn rescan_swaps(sdk: Arc<LiquidSdk>) -> Result<()> {
+    sdk.rescan_onchain_swaps().await?;
+    
+    Ok(())
+}
+
+async fn recommended_fees(sdk: Arc<LiquidSdk>) -> Result<()> {
+    let fees = sdk.recommended_fees().await?;
+    
+    Ok(())
+}
+```
+
+#### Handle Fee Acceptance
+
+```rust
+async fn handle_payments_waiting_fee_acceptance(sdk: Arc<LiquidSdk>) -> Result<()> {
+    // Payments on hold waiting for fee acceptance have the state WaitingFeeAcceptance
+    let payments_waiting_fee_acceptance = sdk
+        .list_payments(&ListPaymentsRequest {
+            states: Some(vec![PaymentState::WaitingFeeAcceptance]),
+            ..Default::default()
+        })
+        .await?;
+
+    for payment in payments_waiting_fee_acceptance {
+        let PaymentDetails::Bitcoin { swap_id, .. } = payment.details else {
+            // Only Bitcoin payments can be `WaitingFeeAcceptance`
+            continue;
+        };
+
+        let fetch_fees_response = sdk
+            .fetch_payment_proposed_fees(&FetchPaymentProposedFeesRequest { swap_id })
+            .await?;
+
+        info!(
+            "Payer sent {} and currently proposed fees are {}",
+            fetch_fees_response.payer_amount_sat, fetch_fees_response.fees_sat
+        );
+
+        // If the user is ok with the fees, accept them, allowing the payment to proceed
+        sdk.accept_payment_proposed_fees(&AcceptPaymentProposedFeesRequest {
+            response: fetch_fees_response,
+        })
+        .await?;
+    }
+    
+    Ok(())
+}
+```
+
+### Non-Bitcoin Assets
+
+```rust
+async fn prepare_receive_asset(sdk: Arc<LiquidSdk>) -> Result<()> {
+    // Create a Liquid BIP21 URI/address to receive an asset payment to.
+    // Note: Not setting the amount will generate an amountless BIP21 URI.
+    let usdt_asset_id = "ce091c998b83c78bb71a632313ba3760f1763d9cfcffae02258ffa9865a37bd2".to_string();
+    let optional_amount = Some(ReceiveAmount::Asset {
+        asset_id: usdt_asset_id,
+        payer_amount: Some(1.50),
+    });
+    let prepare_response = sdk
+        .prepare_receive_payment(&PrepareReceiveRequest {
+            payment_method: PaymentMethod::LiquidAddress,
+            amount: optional_amount,
+        })
+        .await?;
+
+    // If the fees are acceptable, continue to create the Receive Payment
+    let receive_fees_sat = prepare_response.fees_sat;
+    info!("Fees: {} sats", receive_fees_sat);
+    
+    Ok(())
+}
+
+async fn prepare_send_payment_asset(sdk: Arc<LiquidSdk>) -> Result<()> {
+    // Set the Liquid BIP21 or Liquid address you wish to pay
+    // If the destination is an address or an amountless BIP21 URI,
+    // you must specifiy an asset amount
+    let usdt_asset_id = "ce091c998b83c78bb71a632313ba3760f1763d9cfcffae02258ffa9865a37bd2".to_string();
+    let optional_amount = Some(PayAmount::Asset {
+        asset_id: usdt_asset_id,
+        receiver_amount: Some(1.50),
+        estimate_asset_fees: None,
+    });
+    let prepare_response = sdk
+        .prepare_send_payment(&PrepareSendRequest {
+            destination: "<Liquid BIP21 or address>".to_string(),
+            amount: optional_amount,
+        })
+        .await?;
+
+    // If the fees are acceptable, continue to create the Send Payment
+    let send_fees_sat = prepare_response.fees_sat;
+    info!("Fees: {} sats", send_fees_sat);
+    
+    Ok(())
+}
+
+fn configure_asset_metadata() -> Result<LiquidNetwork, Config> {
+    // Create the default config
+    let mut config = LiquidSdk::default_config(
+        LiquidNetwork::Mainnet,
+        Some("<your-Breez-API-key>".to_string()),
+    )?;
+
+    // Configure asset metadata
+    config.asset_metadata = Some(vec![
+        AssetMetadata {
+            asset_id: "18729918ab4bca843656f08d4dd877bed6641fbd596a0a963abbf199cfeb3cec".to_string(),
+            name: "PEGx EUR".to_string(),
+            ticker: "EURx".to_string(),
+            precision: 8,
+        },
+    ]);
+    
+    Ok(config)
+}
+
+async fn fetch_asset_balance(sdk: Arc<LiquidSdk>) -> Result<()> {
+    let info = sdk.get_info().await?;
+    let asset_balances = info.wallet_info.asset_balances;
+    
+    Ok(())
+}
+```
+
+### Messages and Signing
+
+```rust
+async fn sign_message(sdk: Arc<LiquidSdk>) -> Result<()> {
+    let sign_message_request = SignMessageRequest {
+        message: "<message to sign>".to_string(),
+    };
+    let sign_message_response = sdk
+        .sign_message(&sign_message_request)?;
+
+    // Get the wallet info for your pubkey
+    let info = sdk.get_info().await?;
+
+    let signature = sign_message_response.signature;
+    let pubkey = info.wallet_info.pubkey;
+
+    info!("Pubkey: {}", pubkey);
+    info!("Signature: {}", signature);
+    
+    Ok(())
+}
+
+fn check_message(sdk: Arc<LiquidSdk>) -> Result<()> {
+    let check_message_request = CheckMessageRequest {
+        message: "<message>".to_string(),
+        pubkey: "<pubkey of signer>".to_string(),
+        signature: "<message signature>".to_string(),
+    };
+    let check_message_response = sdk
+        .check_message(&check_message_request)?;
+
+    let is_valid = check_message_response.is_valid;
+
+    info!("Signature valid: {}", is_valid);
+    
+    Ok(())
+}
+```
+
+### List Payments
+
+```rust
+async fn get_payment(sdk: Arc<LiquidSdk>) -> Result<Option<Payment>> {
+    let payment_hash = "<payment hash>".to_string();
+    let payment = sdk
+        .get_payment(&GetPaymentRequest::PaymentHash { payment_hash })
+        .await?;
+
+    let swap_id = "<swap id>".to_string();
+    let payment = sdk
+        .get_payment(&GetPaymentRequest::SwapId { swap_id })
+        .await?;
+        
+    Ok(payment)
+}
+
+async fn list_payments(sdk: Arc<LiquidSdk>) -> Result<Vec<Payment>> {
+    let payments = sdk.list_payments(&ListPaymentsRequest::default()).await?;
+    
+    Ok(payments)
+}
+
+async fn list_payments_filtered(sdk: Arc<LiquidSdk>) -> Result<Vec<Payment>> {
+    let payments = sdk
+        .list_payments(&ListPaymentsRequest {
+            filters: Some(vec![PaymentType::Send]),
+            states: None,
+            from_timestamp: Some(1696880000),
+            to_timestamp: Some(1696959200),
+            offset: Some(0),
+            limit: Some(50),
+            details: None,
+            sort_ascending: None,
+        })
+        .await?;
+        
+    Ok(payments)
+}
+
+async fn list_payments_details_address(sdk: Arc<LiquidSdk>) -> Result<Vec<Payment>> {
+    let address = Some("<Bitcoin address>".to_string());
+    let payments = sdk
+        .list_payments(&ListPaymentsRequest {
+            filters: None,
+            states: None,
+            from_timestamp: None,
+            to_timestamp: None,
+            offset: None,
+            limit: None,
+            details: Some(ListPaymentDetails::Bitcoin { address }),
+            sort_ascending: None,
+        })
+        .await?;
+        
+    Ok(payments)
+}
+
+async fn list_payments_details_destination(sdk: Arc<LiquidSdk>) -> Result<Vec<Payment>> {
+    let destination = Some("<Liquid BIP21 or address>".to_string());
+    let payments = sdk
+        .list_payments(&ListPaymentsRequest {
+            filters: None,
+            states: None,
+            from_timestamp: None,
+            to_timestamp: None,
+            offset: None,
+            limit: None,
+            details: Some(ListPaymentDetails::Liquid {
+                asset_id: None,
+                destination,
+            }),
+            sort_ascending: None,
+        })
+        .await?;
+        
+    Ok(payments)
+}
+```
+
+### Webhook Integration
+
+```rust
+async fn register_webhook(sdk: Arc<LiquidSdk>) -> Result<()> {
+    sdk.register_webhook(
+        "https://your-nds-service.com/notify?platform=ios&token=<PUSH_TOKEN>".to_string(),
+    )
+    .await?;
+    
+    Ok(())
+}
+
+async fn unregister_webhook(sdk: Arc<LiquidSdk>) -> Result<()> {
+    sdk.unregister_webhook().await?;
+    
+    Ok(())
+}
+```
+
+### Input Parsing
+
+```rust
+async fn parse_input(sdk: Arc<LiquidSdk>) -> Result<()> {
+    let input = "an input to be parsed...";
+
+    match sdk.parse(input).await? {
+        InputType::BitcoinAddress { address } => {
+            println!("Input is Bitcoin address {}", address.address);
+        }
+        InputType::Bolt11 { invoice } => {
+            println!(
+                "Input is BOLT11 invoice for {} msats",
+                invoice
+                    .amount_msat
+                    .map_or("unknown".to_string(), |a| a.to_string())
+            );
+        }
+        InputType::LnUrlPay { data, bip353_address } => {
+            println!(
+                "Input is LNURL-Pay/Lightning address accepting min/max {}/{} msats - BIP353 was used: {}",
+                data.min_sendable, data.max_sendable, bip353_address.is_some()
+            );
+        }
+        InputType::LnUrlWithdraw { data } => {
+            println!(
+                "Input is LNURL-Withdraw for min/max {}/{} msats",
+                data.min_withdrawable, data.max_withdrawable
+            );
+        }
+        // Other input types are available
+        _ => {}
+    }
+    
+    Ok(())
+}
+
+async fn configure_parsers() -> Result<Arc<LiquidSdk>> {
+    let mnemonic = Mnemonic::generate_in(Language::English, 12)?;
+
+    // Create the default config, providing your Breez API key
+    let mut config = LiquidSdk::default_config(
+        LiquidNetwork::Mainnet,
+        Some("<your-Breez-API-key>".to_string()),
+    )?;
+
+    // Configure external parsers
+    config.external_input_parsers = Some(vec![
+        ExternalInputParser {
+            provider_id: "provider_a".to_string(),
+            input_regex: "^provider_a".to_string(),
+            parser_url: "https://parser-domain.com/parser?input=<input>".to_string(),
+        },
+        ExternalInputParser {
+            provider_id: "provider_b".to_string(),
+            input_regex: "^provider_b".to_string(),
+            parser_url: "https://parser-domain.com/parser?input=<input>".to_string(),
+        },
+    ]);
+
+    let connect_request = ConnectRequest {
+        config,
+        mnemonic: Some(mnemonic.to_string()),
+        passphrase: None,
+        seed: None,
+    };
+    let sdk = LiquidSdk::connect(connect_request).await?;
+    
+    Ok(sdk)
+}
+```
+
+## Complete CLI Example
+
+The SDK includes a complete CLI example that shows how to build a functional application. Here is a simplified version:
+
+```rust
+// main.rs
+use std::sync::Arc;
+use anyhow::Result;
+use breez_sdk_liquid::prelude::*;
+use tokio::time;
+use clap::{Parser, Subcommand};
+
+struct AppEventListener {
+    synced: bool,
+    paid_destinations: Vec<String>,
+}
+
+impl EventListener for AppEventListener {
+    fn on_event(&self, e: SdkEvent) {
+        match e {
+            SdkEvent::Synced => println!("SDK is synced"),
+            SdkEvent::PaymentSucceeded { details } => {
+                println!("Payment succeeded: {:?}", details.payment_hash);
+            },
+            SdkEvent::PaymentFailed { details } => {
+                println!("Payment failed: {:?}", details.payment_hash);
+            },
+            // Handle other events
+            _ => println!("Received event: {:?}", e),
+        }
+    }
+}
+
+#[derive(Parser)]
+#[command(name = "breez-sdk-cli")]
+struct Cli {
+    #[command(subcommand)]
+    command: Commands,
+}
+
+#[derive(Subcommand)]
+enum Commands {
+    /// Get wallet info
+    Info,
+    /// Send a payment
+    Send {
+        #[arg(short, long)]
+        destination: String,
+        #[arg(short, long)]
+        amount_sat: Option<u64>,
+    },
+    /// Receive a payment
+    Receive {
+        #[arg(short, long)]
+        method: String,
+        #[arg(short, long)]
+        amount_sat: Option<u64>,
+    },
+    /// List payments
+    List,
+}
+
+async fn initialize_sdk() -> Result<Arc<LiquidSdk>> {
+    // Load or generate mnemonic
+    let mnemonic = "your mnemonic words here";
+    
+    // Create config
+    let mut config = LiquidSdk::default_config(
+        LiquidNetwork::Mainnet,
+        Some("your-breez-api-key".to_string()),
+    )?;
+    config.working_dir = "./.breez_data".into();
+    
+    // Connect to SDK
+    let sdk = LiquidSdk::connect(ConnectRequest {
+        config,
+        mnemonic: Some(mnemonic.to_string()),
+        passphrase: None,
+        seed: None,
+    }).await?;
+    
+    // Add event listener
+    let listener = Box::new(AppEventListener {
+        synced: false,
+        paid_destinations: vec![],
+    });
+    sdk.add_event_listener(listener).await?;
+    
+    // Wait for sync
+    time::sleep(time::Duration::from_secs(2)).await;
+    
+    Ok(sdk)
+}
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    let cli = Cli::parse();
+    let sdk = initialize_sdk().await?;
+    
+    match cli.command {
+        Commands::Info => {
+            let info = sdk.get_info().await?;
+            println!("Balance: {} sats", info.wallet_info.balance_sat);
+            println!("Pending send: {} sats", info.wallet_info.pending_send_sat);
+            println!("Pending receive: {} sats", info.wallet_info.pending_receive_sat);
+        },
+        Commands::Send { destination, amount_sat } => {
+            let amount = amount_sat.map(|amt| PayAmount::Bitcoin { receiver_amount_sat: amt });
+            
+            // Prepare payment
+            let prepare_response = sdk.prepare_send_payment(&PrepareSendRequest {
+                destination,
+                amount,
+            }).await?;
+            
+            // Send payment
+            let response = sdk.send_payment(&SendPaymentRequest {
+                prepare_response,
+                use_asset_fees: None,
+            }).await?;
+            
+            println!("Payment sent: {:?}", response.payment);
+        },
+        Commands::Receive { method, amount_sat } => {
+            let payment_method = match method.as_str() {
+                "lightning" => PaymentMethod::Lightning,
+                "bitcoin" => PaymentMethod::BitcoinAddress,
+                "liquid" => PaymentMethod::LiquidAddress,
+                _ => return Err(anyhow::anyhow!("Invalid payment method")),
+            };
+            
+            let amount = amount_sat.map(|amt| ReceiveAmount::Bitcoin { payer_amount_sat: amt });
+            
+            // Prepare receive
+            let prepare_response = sdk.prepare_receive_payment(&PrepareReceiveRequest {
+                payment_method,
+                amount,
+            }).await?;
+            
+            // Receive payment
+            let response = sdk.receive_payment(&ReceivePaymentRequest {
+                prepare_response,
+                description: Some("Payment received via CLI".to_string()),
+                use_description_hash: None,
+            }).await?;
+            
+            println!("Payment destination: {}", response.destination);
+        },
+        Commands::List => {
+            let payments = sdk.list_payments(&ListPaymentsRequest::default()).await?;
+            for payment in payments {
+                println!("{}: {} sats, status: {:?}", 
+                         payment.payment_type,
+                         payment.amount_sat,
+                         payment.status);
+            }
+        },
+    }
+    
+    // Disconnect SDK when done
+    sdk.disconnect().await?;
+    
+    Ok(())
+}
+```
+
+### End-User fees
+#### Sending Lightning Payments
+
+Sending Lightning payments involves a submarine swap and two Liquid on-chain transactions. The process is as follows:
+
+1.  User broadcasts an L-BTC transaction to a Liquid lockup address.
+2.  Swapper pays the invoice, sending to the recipient, and then gets a preimage.
+3.  Swapper broadcasts an L-BTC transaction to claim the funds from the Liquid lockup address.
+
+The fee a user pays to send a Lightning payment is composed of three parts:
+
+1.  **Lockup Transaction Fee:** ~34 sats (0.1 sat/discount vbyte).
+2.  **Claim Transaction Fee:** ~19 sats (0.1 sat/discount vbyte).
+3.  **Swap Service Fee:** 0.1% fee on the amount sent.
+
+Note: swap service fee is dynamic and can change. Currently, it is 0.1%.
+
+> **Example**: If the user sends 10k sats, the fee would be:
+> 
+> -   34 sats \[Lockup Transaction Fee\] + 19 sats \[Claim Transaction Fee\] + 10 sats \[Swapper Service Fee\] = 63 sats
+
+#### Receiving Lightning Payments
+
+Receiving Lightning payments involves a reverse submarine swap and requires two Liquid on-chain transactions. The process is as follows:
+
+1.  Sender pays the Swapper invoice.
+2.  Swapper broadcasts an L-BTC transaction to a Liquid lockup address.
+3.  SDK claims the funds from the Liquid lockup address and then exposes the preimage.
+4.  Swapper uses the preimage to claim the funds from the Liquid lockup address.
+
+The fee a user pays to receive a Lightning payment is composed of three parts:
+
+1.  **Lockup Transaction Fee:** ~27 sats (0.1 sat/discount vbyte).
+2.  **Claim Transaction Fee:** ~20 sats (0.1 sat/discount vbyte).
+3.  **Swap Service Fee:** 0.25% fee on the amount received.
+
+Note: swap service fee is dynamic and can change. Currently, it is 0.25%.
+
+> **Example**: If the sender sends 10k sats, the fee for the end-user would be:
+> 
+> -   27 sats \[Lockup Transaction Fee\] + 20 sats \[Claim Transaction Fee\] + 25 sats \[Swapper Service Fee\] = 72 sats
+
+#### Sending to a bitcoin address
+
+Sending to a BTC address involves a trustless chain swap, 2 Liquid on-chain transactions, and 2 BTC on-chain transactions. The process is as follows:
+
+1.  SDK broadcasts an L-BTC transaction to a Liquid lockup address.
+2.  Swapper broadcasts a BTC transaction to a Bitcoin lockup address.
+3.  Recipient claims the funds from the Bitcoin lockup address.
+4.  Swapper claims the funds from the Liquid lockup address.
+
+The fee to send to a BTC address is composed of four parts:
+
+1.  **L-BTC Lockup Transaction Fee**: ~34 sats (0.1 sat/discount vbyte).
+2.  **BTC Lockup Transaction Fee**: the swapper charges a mining fee based on the current bitcoin mempool usage.
+3.  **Swap Service Fee:** 0.1% fee on the amount sent.
+4.  **BTC Claim Transaction Fee:** the SDK fees to claim BTC funds to the destination address, based on the current Bitcoin mempool usage.
+
+Note: swap service fee is dynamic and can change. Currently, it is 0.1%.
+
+> **Example**: If the user sends 100k sats, the mining fees returned by the Swapper are 2000 sats, and the claim fees for the user are 1000 sats—the fee would be:
+> 
+> -   34 sats \[Lockup Transaction Fee\] + 2000 sats \[BTC Claim Transaction Fee\] + 100 sats \[Swapper Service Fee\] + 1000 sats \[BTC Lockup Transaction Fee\] = 3132 sats
+
+### Receiving from a BTC Address
+
+Receiving from a BTC address involves a trustless chain swap, 2 Liquid on-chain transactions, and 2 BTC on-chain transactions.
+
+The process is as follows:
+
+1.  Sender broadcasts a BTC transaction to the Bitcoin lockup address.
+2.  Swapper broadcasts an L-BTC transaction to a Liquid lockup address.
+3.  SDK claims the funds from the Liquid lockup address.
+4.  Swapper claims the funds from the Bitcoin lockup address.
+
+The fee to receive from a BTC address is composed of three parts:
+
+1.  **L-BTC Claim Transaction Fee:** ~20 sats (0.1 sat/discount vbyte).
+2.  **BTC Claim Transaction Fee:** the swapper charges a mining fee based on the Bitcoin mempool usage at the time of the swap.
+3.  **Swapper Service Fee:** the swapper charges a 0.1% fee on the amount received.
+
+Note: swapper service see is dynamic and can change. Currently, it is 0.1%.
+
+> **Example**: If the sender sends 100k sats and the mining fees returned by the Swapper are 2000 sats—the fee for the end-user would be:
+> 
+> -   20 sats \[Claim Transaction Fee\] + 100 sats \[Swapper Service Fee\] + 2000 sats \[BTC Claim Transaction Fee\] = 2120 sats
+
+## Best Practices
+
+### Syncing
+- **Always make sure the SDK instance is synced before performing any actions**
+
+```rust
+async fn wait_for_synced(sdk: Arc<LiquidSdk>) {
+    let mut events_stream = sdk.event_manager.subscribe();
+    
+    loop {
+        match events_stream.recv().await {
+            Ok(SdkEvent::Synced) => break,
+            Ok(_) => continue,
+            Err(_) => break,
+        }
+    }
+}
+
+async fn main() {
+    let sdk = initialize_sdk().await.unwrap();
+    wait_for_synced(sdk.clone()).await;
+    
+    // Now the SDK is synced and ready to use
+    let info = sdk.get_info().await.unwrap();
+    println!("Balance: {} sats", info.wallet_info.balance_sat);
+}
+```
+
+### Error Handling
+
+Always wrap your SDK method calls in proper error handling:
+
+```rust
+async fn safe_operation(sdk: Arc<LiquidSdk>) -> Result<()> {
+    match sdk.get_info().await {
+        Ok(info) => {
+            println!("Successfully retrieved balance: {} sats", info.wallet_info.balance_sat);
+            Ok(())
+        },
+        Err(e) => {
+            log::error!("Failed to get wallet info: {}", e);
+            Err(anyhow::anyhow!("Operation failed: {}", e))
+        }
+    }
+}
+```
+
+### Connection Lifecycle
+
+Manage the connection lifecycle properly:
+
+1. Initialize only once per session
+2. Properly handle events
+3. Disconnect when done
+
+```rust
+async fn session() -> Result<()> {
+    // Initialize SDK
+    let sdk = initialize_sdk().await?;
+    
+    // Use SDK
+    let info = sdk.get_info().await?;
+    println!("Balance: {} sats", info.wallet_info.balance_sat);
+    
+    // Disconnect
+    sdk.disconnect().await?;
+    
+    Ok(())
+}
+```
+
+### Fee Handling
+
+Always check fees before executing payments:
+
+```rust
+async fn safe_payment(sdk: Arc<LiquidSdk>, destination: String, amount_sat: u64, max_fee_sat: u64) -> Result<()> {
+    let prepare_response = sdk.prepare_send_payment(&PrepareSendRequest {
+        destination,
+        amount: Some(PayAmount::Bitcoin { receiver_amount_sat: amount_sat }),
+    }).await?;
+    
+    // Check if fees are acceptable
+    if let Some(fees_sat) = prepare_response.fees_sat {
+        if fees_sat <= max_fee_sat {
+            // Execute payment
+            sdk.send_payment(&SendPaymentRequest { prepare_response }).await?;
+            Ok(())
+        } else {
+            // Fees too high
+            Err(anyhow::anyhow!("Fees too high: {} sats (max: {} sats)", fees_sat, max_fee_sat))
+        }
+    } else {
+        Err(anyhow::anyhow!("Fees not available"))
+    }
+}
+```
+
+### Event Handling
+
+Implement a robust event listener to handle asynchronous events:
+
+```rust
+struct AppEventListener {
+    synced: bool,
+    payments: Vec<String>,
+}
+
+impl EventListener for AppEventListener {
+    fn on_event(&self, e: SdkEvent) {
+        match e {
+            SdkEvent::Synced => {
+                println!("SDK is synced");
+            },
+            SdkEvent::PaymentSucceeded { details } => {
+                println!("Payment succeeded: {}", details.payment_hash.unwrap_or_default());
+            },
+            SdkEvent::PaymentFailed { details } => {
+                println!("Payment failed: {}", details.error.unwrap_or_default());
+            },
+            // Handle other events
+            _ => println!("Received event: {:?}", e),
+        }
+    }
+}
+```
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Connection Problems**
+   - Check your API key
+   - Verify network selection (MAINNET vs TESTNET)
+   - Confirm working directory permissions
+
+2. **Payment Issues**
+   - Verify amount is within allowed limits
+   - Check fee settings
+   - Ensure destination is valid
+   - Verify sufficient balance
+
+3. **Event Listener Not Triggering**
+   - Confirm listener is registered with `add_event_listener`
+   - Check event type matching in your handler
+   - Add debug logging to trace events
+
+### Debugging
+
+Use the SDK's built-in logging system:
+
+```rust
+// Initialize SDK logging
+LiquidSdk::init_logging(&data_dir_path, None)?;
+```
+
+## Security Considerations
+
+1. **Protecting Mnemonics**
+   - Never hardcode mnemonics in your code
+   - Store encrypted or in secure storage
+   - Consider using a custom signer for production apps
+
+2. **API Key Security**
+   - Store API keys in environment variables
+   - Don't commit API keys to source control
+   - Use different keys for production and testing
+
+3. **Validating Inputs**
+   - Always validate payment destinations
+   - Check amounts are within reasonable limits
+   - Sanitize and validate all external inputs
\ No newline at end of file
diff --git a/examples/breez-nodeless-llms/breez-nodeless-wasm-llms.md b/examples/breez-nodeless-llms/breez-nodeless-wasm-llms.md
new file mode 100644
index 00000000..1496f6fe
--- /dev/null
+++ b/examples/breez-nodeless-llms/breez-nodeless-wasm-llms.md
@@ -0,0 +1,1366 @@
+# Breez SDK Nodeless (Liquid implementation) Documentation for WebAssembly
+
+This comprehensive document provides all the context needed to build web applications with the WebAssembly bindings of Breez SDK Nodeless, a toolkit for integrating Bitcoin, Lightning Network, and Liquid Network functionality.
+
+## Overview
+
+Breez SDK Nodeless (Liquid implementation) allows developers to integrate Bitcoin, Lightning Network, and Liquid Network functionality into web applications. The SDK abstracts many complexities, providing a simple interface for common operations such as sending and receiving payments, managing wallets, and interacting with both Lightning and Liquid networks.
+
+Key capabilities include:
+- Wallet management and balance tracking
+- Lightning Network payments
+- Liquid Network transactions
+- Onchain Bitcoin operations
+- LNURL support (auth, pay, withdraw)
+- Non-Bitcoin asset management
+- Webhook integration
+- Event handling with listeners
+
+## Getting Started
+
+### Installation
+
+```bash
+npm install @breeztech/breez-sdk-liquid
+```
+
+### Initializing the SDK
+
+To get started with Breez SDK Nodeless (Liquid implementation) in the browser, you need to initialize the WASM module and connect with your configuration:
+
+```typescript
+import init, { defaultConfig, connect } from '@breeztech/breez-sdk-liquid/web';
+
+const initWallet = async () => {
+  // Initialize the WASM module first
+  await init();
+
+  // Your mnemonic seed phrase for wallet recovery
+  const mnemonic = "<mnemonic words>";
+
+  // Create the default config, providing your Breez API key
+  const config = defaultConfig('mainnet', '<your-Breez-API-key>');
+
+  // Customize the config object according to your needs
+  // The workingDir doesn't need to be set in web environments
+  config.workingDir = 'path to writable directory';
+
+  try {
+    const sdk = await connect({ 
+      config, 
+      mnemonic 
+    });
+    return sdk;
+  } catch (error) {
+    console.error(error);
+    throw error;
+  }
+};
+```
+
+### Custom Signer Support
+
+If you prefer to manage your own keys, you can use a custom signer:
+
+```typescript
+import { connectWithSigner, defaultConfig } from '@breeztech/breez-sdk-liquid/web';
+
+const connectWithCustomSigner = async () => {
+  // Fully implement the Signer interface
+  class JsSigner {
+    xpub = (): number[] => { return [] }
+    deriveXpub = (derivationPath: string): number[] => { return [] }
+    signEcdsa = (msg: number[], derivationPath: string): number[] => { return [] }
+    signEcdsaRecoverable = (msg: number[]): number[] => { return [] }
+    slip77MasterBlindingKey = (): number[] => { return [] }
+    hmacSha256 = (msg: number[], derivationPath: string): number[] => { return [] }
+    eciesEncrypt = (msg: number[]): number[] => { return [] }
+    eciesDecrypt = (msg: number[]): number[] => { return [] }
+  }
+
+  const signer = new JsSigner();
+
+  // Create the default config, providing your Breez API key
+  const config = defaultConfig('mainnet', '<your-Breez-API-key>');
+
+  const sdk = await connectWithSigner({ config }, signer);
+
+  return sdk;
+};
+```
+
+### Guidelines
+- **Always make sure the sdk instance is synced before performing any actions**
+- **Add logging**: Add sufficient logging to diagnose any issues users have
+- **Display pending payments**: Payments always contain a status field to determine completion. Show the correct status to users.
+- **Enable swap refunds**: Swaps resulting from On-Chain Transactions may not complete and change to `Refundable` state. Handle this by allowing the user to retry the refund with different fees until confirmed.
+- **Expose swap fees**: When sending or receiving on-chain, clearly show the expected fees and amounts.
+
+### Basic Operations
+
+#### Setting Up Logging
+
+```typescript
+import { setLogger } from '@breeztech/breez-sdk-liquid/web';
+
+const setupLogging = () => {
+  class JsLogger {
+    log = (l) => {
+      console.log(`[${l.level}]: ${l.line}`);
+    }
+  }
+
+  const logger = new JsLogger();
+  setLogger(logger);
+};
+```
+
+#### Event Handling
+
+```typescript
+import { SdkEvent } from '@breeztech/breez-sdk-liquid/web';
+
+const setupEventListener = async (sdk) => {
+  class JsEventListener {
+    onEvent = (event: SdkEvent) => {
+      console.log(`Received event: ${JSON.stringify(event)}`);
+    }
+  }
+
+  const eventListener = new JsEventListener();
+  const listenerId = await sdk.addEventListener(eventListener);
+  
+  // Save the listenerId to remove the listener later
+  return listenerId;
+};
+
+const removeEventListener = async (sdk, listenerId) => {
+  await sdk.removeEventListener(listenerId);
+};
+```
+
+#### Fetch Balance
+
+```typescript
+const fetchBalance = async (sdk) => {
+  try {
+    const info = await sdk.getInfo();
+    const balanceSat = info.walletInfo.balanceSat;
+    const pendingSendSat = info.walletInfo.pendingSendSat;
+    const pendingReceiveSat = info.walletInfo.pendingReceiveSat;
+    console.log(`Balance: ${balanceSat} sats`);
+  } catch (error) {
+    console.error(error);
+  }
+};
+```
+
+## Core Features
+
+### Buying Bitcoin
+
+```typescript
+const fetchOnchainLimits = async (sdk) => {
+  try {
+    const currentLimits = await sdk.fetchOnchainLimits();
+    console.log(`Minimum amount, in sats: ${currentLimits.receive.minSat}`);
+    console.log(`Maximum amount, in sats: ${currentLimits.receive.maxSat}`);
+    return currentLimits;
+  } catch (err) {
+    console.error(err);
+  }
+};
+
+const prepareBuyBtc = async (sdk, currentLimits) => {
+  try {
+    const prepareRes = await sdk.prepareBuyBitcoin({
+      provider: 'moonpay',
+      amountSat: currentLimits.receive.minSat
+    });
+
+    // Check the fees are acceptable before proceeding
+    const receiveFeesSat = prepareRes.feesSat;
+    console.log(`Fees: ${receiveFeesSat} sats`);
+    return prepareRes;
+  } catch (err) {
+    console.error(err);
+  }
+};
+
+const buyBtc = async (sdk, prepareResponse) => {
+  try {
+    const url = await sdk.buyBitcoin({
+      prepareResponse
+    });
+    // Redirect user to url to complete purchase
+  } catch (err) {
+    console.error(err);
+  }
+};
+```
+
+### Fiat Currencies
+
+```typescript
+const listFiatCurrencies = async (sdk) => {
+  const fiatCurrencies = await sdk.listFiatCurrencies();
+  return fiatCurrencies;
+};
+
+const fetchFiatRates = async (sdk) => {
+  const fiatRates = await sdk.fetchFiatRates();
+  return fiatRates;
+};
+```
+
+### Sending Payments
+
+#### Lightning Payments
+
+Sending Lightning payments involves a submarine swap and two Liquid on-chain transactions. The process is:
+
+1. User broadcasts an L-BTC transaction to a Liquid lockup address.
+2. Swapper pays the invoice, sending to the recipient, and gets a preimage.
+3. Swapper broadcasts an L-BTC transaction to claim funds from the Liquid lockup address.
+
+The fee components:
+- Lockup Transaction Fee: ~34 sats (0.1 sat/discount vbyte)
+- Claim Transaction Fee: ~19 sats (0.1 sat/discount vbyte)
+- Swap Service Fee: 0.1% of the amount sent (dynamic)
+
+```typescript
+const prepareSendPaymentLightningBolt11 = async (sdk) => {
+  // Set the bolt11 invoice you wish to pay
+  const prepareResponse = await sdk.prepareSendPayment({
+    destination: '<bolt11 invoice>'
+  });
+
+  // If the fees are acceptable, continue to create the Send Payment
+  const sendFeesSat = prepareResponse.feesSat;
+  console.log(`Fees: ${sendFeesSat} sats`);
+  return prepareResponse;
+};
+
+const prepareSendPaymentLightningBolt12 = async (sdk) => {
+  // Set the bolt12 offer you wish to pay
+  const optionalAmount = {
+    type: 'bitcoin',
+    receiverAmountSat: 5_000
+  };
+
+  const prepareResponse = await sdk.prepareSendPayment({
+    destination: '<bolt12 offer>',
+    amount: optionalAmount
+  });
+  
+  return prepareResponse;
+};
+```
+
+#### Liquid Payments
+
+```typescript
+const prepareSendPaymentLiquid = async (sdk) => {
+  // Set the Liquid BIP21 or Liquid address you wish to pay
+  const optionalAmount = {
+    type: 'bitcoin',
+    receiverAmountSat: 5_000
+  };
+
+  const prepareResponse = await sdk.prepareSendPayment({
+    destination: '<Liquid BIP21 or address>',
+    amount: optionalAmount
+  });
+
+  // If the fees are acceptable, continue to create the Send Payment
+  const sendFeesSat = prepareResponse.feesSat;
+  console.log(`Fees: ${sendFeesSat} sats`);
+  return prepareResponse;
+};
+
+const prepareSendPaymentLiquidDrain = async (sdk) => {
+  // Set the Liquid BIP21 or Liquid address you wish to pay
+  const optionalAmount = {
+    type: 'drain'
+  };
+
+  const prepareResponse = await sdk.prepareSendPayment({
+    destination: '<Liquid BIP21 or address>',
+    amount: optionalAmount
+  });
+
+  // If the fees are acceptable, continue to create the Send Payment
+  const sendFeesSat = prepareResponse.feesSat;
+  console.log(`Fees: ${sendFeesSat} sats`);
+  return prepareResponse;
+};
+```
+
+#### Execute Payment
+
+```typescript
+const sendPayment = async (sdk, prepareResponse) => {
+  const sendResponse = await sdk.sendPayment({
+    prepareResponse
+  });
+  const payment = sendResponse.payment;
+  console.log(payment);
+};
+```
+
+### Receiving Payments
+
+#### Lightning Payments
+
+Receiving Lightning payments involves a reverse submarine swap and requires two Liquid on-chain transactions:
+
+1. Sender pays the Swapper invoice.
+2. Swapper broadcasts an L-BTC transaction to a Liquid lockup address.
+3. SDK claims the funds from the Liquid lockup address and exposes the preimage.
+4. Swapper uses the preimage to claim funds from the Liquid lockup address.
+
+The fee components:
+- Lockup Transaction Fee: ~27 sats (0.1 sat/discount vbyte)
+- Claim Transaction Fee: ~20 sats (0.1 sat/discount vbyte)
+- Swap Service Fee: 0.25% of the amount received (dynamic)
+
+```typescript
+const prepareReceiveLightning = async (sdk) => {
+  try {
+    // Fetch the lightning Receive limits
+    const currentLimits = await sdk.fetchLightningLimits();
+    console.log(`Minimum amount allowed to deposit in sats: ${currentLimits.receive.minSat}`);
+    console.log(`Maximum amount allowed to deposit in sats: ${currentLimits.receive.maxSat}`);
+
+    // Set the invoice amount you wish the payer to send, which should be within the above limits
+    const optionalAmount = {
+      type: 'bitcoin',
+      payerAmountSat: 5_000
+    };
+
+    const prepareResponse = await sdk.prepareReceivePayment({
+      paymentMethod: 'lightning',
+      amount: optionalAmount
+    });
+
+    // If the fees are acceptable, continue to create the Receive Payment
+    const receiveFeesSat = prepareResponse.feesSat;
+    console.log(`Fees: ${receiveFeesSat} sats`);
+    return prepareResponse;
+  } catch (error) {
+    console.error(error);
+    throw error;
+  }
+};
+```
+
+#### Onchain Payments
+
+```typescript
+const prepareReceiveOnchain = async (sdk) => {
+  try {
+    // Fetch the Onchain Receive limits
+    const currentLimits = await sdk.fetchOnchainLimits();
+    console.log(`Minimum amount allowed to deposit in sats: ${currentLimits.receive.minSat}`);
+    console.log(`Maximum amount allowed to deposit in sats: ${currentLimits.receive.maxSat}`);
+
+    // Set the onchain amount you wish the payer to send, which should be within the above limits
+    const optionalAmount = {
+      type: 'bitcoin',
+      payerAmountSat: 5_000
+    };
+
+    const prepareResponse = await sdk.prepareReceivePayment({
+      paymentMethod: 'bitcoinAddress',
+      amount: optionalAmount
+    });
+
+    // If the fees are acceptable, continue to create the Receive Payment
+    const receiveFeesSat = prepareResponse.feesSat;
+    console.log(`Fees: ${receiveFeesSat} sats`);
+    return prepareResponse;
+  } catch (error) {
+    console.error(error);
+    throw error;
+  }
+};
+```
+
+#### Liquid Payments
+
+```typescript
+const prepareReceiveLiquid = async (sdk) => {
+  try {
+    // Create a Liquid BIP21 URI/address to receive a payment to
+    // There are no limits, but the payer amount should be greater than broadcast fees when specified
+    // Note: Not setting the amount will generate a plain Liquid address
+    const optionalAmount = {
+      type: 'bitcoin',
+      payerAmountSat: 5_000
+    };
+
+    const prepareResponse = await sdk.prepareReceivePayment({
+      paymentMethod: 'liquidAddress',
+      amount: optionalAmount
+    });
+
+    // If the fees are acceptable, continue to create the Receive Payment
+    const receiveFeesSat = prepareResponse.feesSat;
+    console.log(`Fees: ${receiveFeesSat} sats`);
+    return prepareResponse;
+  } catch (error) {
+    console.error(error);
+    throw error;
+  }
+};
+```
+
+#### Execute Receive
+
+```typescript
+const receivePayment = async (sdk, prepareResponse) => {
+  try {
+    const optionalDescription = '<description>';
+    const res = await sdk.receivePayment({
+      prepareResponse,
+      description: optionalDescription
+    });
+
+    const destination = res.destination;
+    console.log(destination); // This is the invoice or address to share with the payer
+  } catch (error) {
+    console.error(error);
+    throw error;
+  }
+};
+```
+
+### LNURL Operations
+
+#### LNURL Authentication
+
+```typescript
+const lnurlAuth = async (sdk) => {
+  // Endpoint can also be in the form:
+  // keyauth://domain.com/auth?key=val
+  const lnurlAuthUrl =
+    'lnurl1dp68gurn8ghj7mr0vdskc6r0wd6z7mrww4excttvdankjm3lw3skw0tvdankjm3xdvcn6vtp8q6n2dfsx5mrjwtrxdjnqvtzv56rzcnyv3jrxv3sxqmkyenrvv6kve3exv6nqdtyv43nqcmzvdsnvdrzx33rsenxx5unqc3cxgeqgntfgu';
+
+  const input = await sdk.parse(lnurlAuthUrl);
+  if (input.type === 'lnUrlAuth') {
+    const result = await sdk.lnurlAuth(input.data);
+    if (result.type === 'ok') {
+      console.log('Successfully authenticated');
+    } else {
+      console.log('Failed to authenticate');
+    }
+  }
+};
+```
+
+#### LNURL Pay
+
+```typescript
+const prepareLnurlPay = async (sdk) => {
+  // Endpoint can also be in the form:
+  // lnurlp://domain.com/lnurl-pay?key=val
+  const lnurlPayUrl = 'lightning@address.com';
+
+  const input = await sdk.parse(lnurlPayUrl);
+  if (input.type === 'lnUrlPay') {
+    const amount = {
+      type: 'bitcoin',
+      receiverAmountSat: 5_000
+    };
+    const optionalComment = '<comment>';
+    const optionalValidateSuccessActionUrl = true;
+
+    const prepareResponse = await sdk.prepareLnurlPay({
+      data: input.data,
+      amount,
+      bip353Address: input.bip353Address,
+      comment: optionalComment,
+      validateSuccessActionUrl: optionalValidateSuccessActionUrl
+    });
+
+    // If the fees are acceptable, continue with the LNURL Pay
+    const feesSat = prepareResponse.feesSat;
+    console.log(`Fees: ${feesSat} sats`);
+    return prepareResponse;
+  }
+};
+
+const lnurlPay = async (sdk, prepareResponse) => {
+  const result = await sdk.lnurlPay({
+    prepareResponse
+  });
+  console.log(result);
+};
+```
+
+#### LNURL Withdraw
+
+```typescript
+const lnurlWithdraw = async (sdk) => {
+  // Endpoint can also be in the form:
+  // lnurlw://domain.com/lnurl-withdraw?key=val
+  const lnurlWithdrawUrl =
+    'lnurl1dp68gurn8ghj7mr0vdskc6r0wd6z7mrww4exctthd96xserjv9mn7um9wdekjmmw843xxwpexdnxzen9vgunsvfexq6rvdecx93rgdmyxcuxverrvcursenpxvukzv3c8qunsdecx33nzwpnvg6ryc3hv93nzvecxgcxgwp3h33lxk';
+
+  const input = await sdk.parse(lnurlWithdrawUrl);
+  if (input.type === 'lnUrlWithdraw') {
+    const amountMsat = input.data.minWithdrawable;
+    const lnUrlWithdrawResult = await sdk.lnurlWithdraw({
+      data: input.data,
+      amountMsat,
+      description: 'comment'
+    });
+    return lnUrlWithdrawResult;
+  }
+};
+```
+
+### Onchain Operations
+
+#### Pay Onchain
+
+```typescript
+const getOnchainLimits = async (sdk) => {
+  try {
+    const currentLimits = await sdk.fetchOnchainLimits();
+    console.log(`Minimum amount, in sats: ${currentLimits.send.minSat}`);
+    console.log(`Maximum amount, in sats: ${currentLimits.send.maxSat}`);
+    return currentLimits;
+  } catch (err) {
+    console.error(err);
+  }
+};
+
+const preparePayOnchain = async (sdk) => {
+  try {
+    const prepareResponse = await sdk.preparePayOnchain({
+      amount: {
+        type: 'bitcoin',
+        receiverAmountSat: 5_000
+      }
+    });
+
+    // Check if the fees are acceptable before proceeding
+    const totalFeesSat = prepareResponse.totalFeesSat;
+    return prepareResponse;
+  } catch (err) {
+    console.error(err);
+  }
+};
+
+const preparePayOnchainFeeRate = async (sdk) => {
+  try {
+    const optionalSatPerVbyte = 21;
+
+    const prepareResponse = await sdk.preparePayOnchain({
+      amount: {
+        type: 'bitcoin',
+        receiverAmountSat: 5_000
+      },
+      feeRateSatPerVbyte: optionalSatPerVbyte
+    });
+
+    // Check if the fees are acceptable before proceeding
+    const claimFeesSat = prepareResponse.claimFeesSat;
+    const totalFeesSat = prepareResponse.totalFeesSat;
+    return prepareResponse;
+  } catch (err) {
+    console.error(err);
+  }
+};
+
+const payOnchain = async (sdk, prepareResponse) => {
+  try {
+    const destinationAddress = 'bc1..';
+    const payOnchainRes = await sdk.payOnchain({
+      address: destinationAddress,
+      prepareResponse
+    });
+    return payOnchainRes;
+  } catch (err) {
+    console.error(err);
+  }
+};
+```
+
+#### Drain Funds
+
+```typescript
+const preparePayOnchainDrain = async (sdk) => {
+  try {
+    const prepareResponse = await sdk.preparePayOnchain({
+      amount: {
+        type: 'drain'
+      }
+    });
+
+    // Check if the fees are acceptable before proceeding
+    const totalFeesSat = prepareResponse.totalFeesSat;
+    return prepareResponse;
+  } catch (err) {
+    console.error(err);
+  }
+};
+```
+
+#### Handle Refundable Swaps
+
+```typescript
+const listRefundables = async (sdk) => {
+  try {
+    const refundables = await sdk.listRefundables();
+    return refundables;
+  } catch (err) {
+    console.error(err);
+  }
+};
+
+const executeRefund = async (sdk, refundable, refundTxFeeRate) => {
+  const destinationAddress = '...';
+  const feeRateSatPerVbyte = refundTxFeeRate;
+
+  const refundResponse = await sdk.refund({
+    swapAddress: refundable.swapAddress,
+    refundAddress: destinationAddress,
+    feeRateSatPerVbyte
+  });
+  return refundResponse;
+};
+
+const rescanSwaps = async (sdk) => {
+  try {
+    await sdk.rescanOnchainSwaps();
+  } catch (err) {
+    console.error(err);
+  }
+};
+```
+
+#### Handle Fee Acceptance
+
+```typescript
+const handlePaymentsWaitingFeeAcceptance = async (sdk) => {
+  // Payments on hold waiting for fee acceptance have the state WAITING_FEE_ACCEPTANCE
+  const paymentsWaitingFeeAcceptance = await sdk.listPayments({
+    states: ['waitingFeeAcceptance']
+  });
+
+  for (const payment of paymentsWaitingFeeAcceptance) {
+    if (payment.details.type !== 'bitcoin') {
+      // Only Bitcoin payments can be `WAITING_FEE_ACCEPTANCE`
+      continue;
+    }
+
+    const fetchFeesResponse = await sdk.fetchPaymentProposedFees({
+      swapId: payment.details.swapId
+    });
+
+    console.info(
+      `Payer sent ${fetchFeesResponse.payerAmountSat} and currently proposed fees are ${fetchFeesResponse.feesSat}`
+    );
+
+    // If the user is ok with the fees, accept them, allowing the payment to proceed
+    await sdk.acceptPaymentProposedFees({
+      response: fetchFeesResponse
+    });
+  }
+};
+```
+
+### Non-Bitcoin Assets
+
+```typescript
+const prepareReceiveAsset = async (sdk) => {
+  try {
+    // Create a Liquid BIP21 URI/address to receive an asset payment to
+    // Note: Not setting the amount will generate an amountless BIP21 URI
+    const usdtAssetId = 'ce091c998b83c78bb71a632313ba3760f1763d9cfcffae02258ffa9865a37bd2';
+    const optionalAmount = {
+      type: 'asset',
+      assetId: usdtAssetId,
+      payerAmount: 1.5
+    };
+
+    const prepareResponse = await sdk.prepareReceivePayment({
+      paymentMethod: 'liquidAddress',
+      amount: optionalAmount
+    });
+
+    // If the fees are acceptable, continue to create the Receive Payment
+    const receiveFeesSat = prepareResponse.feesSat;
+    console.log(`Fees: ${receiveFeesSat} sats`);
+    return prepareResponse;
+  } catch (error) {
+    console.error(error);
+    throw error;
+  }
+};
+
+const prepareSendPaymentAsset = async (sdk) => {
+  // Set the Liquid BIP21 or Liquid address you wish to pay
+  const destination = '<Liquid BIP21 or address>';
+  // If the destination is an address or an amountless BIP21 URI,
+  // you must specify an asset amount
+  const usdtAssetId = 'ce091c998b83c78bb71a632313ba3760f1763d9cfcffae02258ffa9865a37bd2';
+  const optionalAmount = {
+    type: 'asset',
+    assetId: usdtAssetId,
+    receiverAmount: 1.5,
+    estimateAssetFees: false
+  };
+
+  const prepareResponse = await sdk.prepareSendPayment({
+    destination,
+    amount: optionalAmount
+  });
+
+  // If the fees are acceptable, continue to create the Send Payment
+  const sendFeesSat = prepareResponse.feesSat;
+  console.log(`Fees: ${sendFeesSat} sats`);
+  return prepareResponse;
+};
+
+const sendPaymentWithAssetFees = async (sdk, prepareResponse) => {
+  // Set the use asset fees param to true
+  const sendResponse = await sdk.sendPayment({
+    prepareResponse,
+    useAssetFees: true
+  });
+  const payment = sendResponse.payment;
+  console.log(payment);
+};
+
+const configureAssetMetadata = () => {
+  // Create the default config
+  const config = defaultConfig('mainnet', '<your-Breez-API-key>');
+
+  // Configure asset metadata
+  config.assetMetadata = [
+    {
+      assetId: '18729918ab4bca843656f08d4dd877bed6641fbd596a0a963abbf199cfeb3cec',
+      name: 'PEGx EUR',
+      ticker: 'EURx',
+      precision: 8
+    }
+  ];
+};
+
+const fetchAssetBalance = async (sdk) => {
+  try {
+    const info = await sdk.getInfo();
+    const assetBalances = info.walletInfo.assetBalances;
+    return assetBalances;
+  } catch (error) {
+    console.error(error);
+    throw error;
+  }
+};
+```
+
+### Messages and Signing
+
+```typescript
+const signMessage = async (sdk) => {
+  const signMessageResponse = sdk.signMessage({
+    message: '<message to sign>'
+  });
+
+  // Get the wallet info for your pubkey
+  const info = await sdk.getInfo();
+
+  const signature = signMessageResponse.signature;
+  const pubkey = info.walletInfo.pubkey;
+
+  console.log(`Pubkey: ${pubkey}`);
+  console.log(`Signature: ${signature}`);
+};
+
+const checkMessage = (sdk) => {
+  const checkMessageResponse = sdk.checkMessage({
+    message: '<message>',
+    pubkey: '<pubkey of signer>',
+    signature: '<message signature>'
+  });
+  const isValid = checkMessageResponse.isValid;
+
+  console.log(`Signature valid: ${isValid}`);
+};
+```
+
+### List Payments
+
+```typescript
+const getPayment = async (sdk) => {
+  const paymentHash = '<payment hash>';
+  const paymentByHash = await sdk.getPayment({
+    type: 'paymentHash',
+    paymentHash
+  });
+
+  const swapId = '<swap id>';
+  const paymentBySwapId = await sdk.getPayment({
+    type: 'swapId',
+    swapId
+  });
+};
+
+const listAllPayments = async (sdk) => {
+  const payments = await sdk.listPayments({});
+  return payments;
+};
+
+const listPaymentsFiltered = async (sdk) => {
+  try {
+    const payments = await sdk.listPayments({
+      filters: ['send'],
+      fromTimestamp: 1696880000,
+      toTimestamp: 1696959200,
+      offset: 0,
+      limit: 50
+    });
+    return payments;
+  } catch (err) {
+    console.error(err);
+  }
+};
+
+const listPaymentsDetailsAddress = async (sdk) => {
+  try {
+    const payments = await sdk.listPayments({
+      details: {
+        type: 'bitcoin',
+        address: '<Bitcoin address>'
+      }
+    });
+    return payments;
+  } catch (err) {
+    console.error(err);
+  }
+};
+
+const listPaymentsDetailsDestination = async (sdk) => {
+  try {
+    const payments = await sdk.listPayments({
+      details: {
+        type: 'liquid',
+        destination: '<Liquid BIP21 or address>'
+      }
+    });
+    return payments;
+  } catch (err) {
+    console.error(err);
+  }
+};
+```
+
+### Webhook Integration
+
+```typescript
+const registerWebhook = async (sdk) => {
+  try {
+    await sdk.registerWebhook('https://your-nds-service.com/notify?platform=web&token=<PUSH_TOKEN>');
+  } catch (err) {
+    console.error(err);
+  }
+};
+
+const unregisterWebhook = async (sdk) => {
+  try {
+    await sdk.unregisterWebhook();
+  } catch (err) {
+    console.error(err);
+  }
+};
+```
+
+### Input Parsing
+
+```typescript
+const parseInput = async (sdk) => {
+  const input = 'an input to be parsed...';
+
+  const parsed = await sdk.parse(input);
+
+  switch (parsed.type) {
+    case 'bitcoinAddress':
+      console.log(`Input is Bitcoin address ${parsed.address.address}`);
+      break;
+
+    case 'bolt11':
+      console.log(
+        `Input is BOLT11 invoice for ${
+          parsed.invoice.amountMsat != null ? parsed.invoice.amountMsat.toString() : 'unknown'
+        } msats`
+      );
+      break;
+
+    case 'lnUrlPay':
+      console.log(
+        `Input is LNURL-Pay/Lightning address accepting min/max ${parsed.data.minSendable}/${
+          parsed.data.maxSendable
+        } msats - BIP353 was used: ${parsed.bip353Address != null}`
+      );
+      break;
+
+    case 'lnUrlWithdraw':
+      console.log(
+        `Input is LNURL-Withdraw for min/max ${parsed.data.minWithdrawable}/${parsed.data.maxWithdrawable} msats`
+      );
+      break;
+
+    default:
+      // Other input types are available
+      break;
+  }
+};
+
+const configureExternalParsers = async () => {
+  const mnemonic = '<mnemonics words>';
+
+  // Create the default config, providing your Breez API key
+  const config = defaultConfig('mainnet', '<your-Breez-API-key>');
+
+  // Configure external parsers
+  config.externalInputParsers = [
+    {
+      providerId: 'provider_a',
+      inputRegex: '^provider_a',
+      parserUrl: 'https://parser-domain.com/parser?input=<input>'
+    },
+    {
+      providerId: 'provider_b',
+      inputRegex: '^provider_b',
+      parserUrl: 'https://parser-domain.com/parser?input=<input>'
+    }
+  ];
+
+  await connect({ mnemonic, config });
+};
+```
+
+## Complete Web App Example
+
+Here's a simplified React component that demonstrates how to use the SDK in a web app:
+
+```jsx
+import React, { useEffect, useState, useCallback } from 'react';
+import init, { connect, defaultConfig } from '@breeztech/breez-sdk-liquid/web';
+
+function WalletComponent() {
+  const [sdk, setSdk] = useState(null);
+  const [walletInfo, setWalletInfo] = useState(null);
+  const [transactions, setTransactions] = useState([]);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState(null);
+
+  // Initialize SDK on component mount
+  useEffect(() => {
+    const initWallet = async () => {
+      try {
+        setIsLoading(true);
+        
+        // Initialize WASM module
+        await init();
+        
+        // Get saved mnemonic or create new one
+        const savedMnemonic = localStorage.getItem('walletMnemonic');
+        const mnemonic = savedMnemonic || generateNewMnemonic();
+        
+        // Create config with API key
+        const config = defaultConfig('mainnet');
+        config.breezApiKey = process.env.REACT_APP_BREEZ_API_KEY;
+        
+        // Connect to Breez SDK
+        const sdkInstance = await connect({
+          config,
+          mnemonic,
+        });
+        
+        // Save mnemonic if new
+        if (!savedMnemonic) {
+          localStorage.setItem('walletMnemonic', mnemonic);
+        }
+        
+        // Set up event listener
+        const eventListener = {
+          onEvent: (event) => {
+            console.log('SDK event:', event);
+            if (event.type === 'synced') {
+              refreshWalletData();
+            }
+          }
+        };
+        
+        const listenerId = await sdkInstance.addEventListener(eventListener);
+        
+        // Store SDK instance
+        setSdk(sdkInstance);
+        
+        // Get initial wallet data
+        const info = await sdkInstance.getInfo();
+        const txs = await sdkInstance.listPayments({});
+        
+        setWalletInfo(info);
+        setTransactions(txs);
+      } catch (err) {
+        console.error('Wallet initialization error:', err);
+        setError(err.message);
+      } finally {
+        setIsLoading(false);
+      }
+    };
+    
+    initWallet();
+    
+    // Clean up on unmount
+    return () => {
+      if (sdk) {
+        sdk.disconnect().catch(console.error);
+      }
+    };
+  }, []);
+  
+  // Function to refresh wallet data
+  const refreshWalletData = useCallback(async () => {
+    if (!sdk) return;
+    
+    try {
+      const info = await sdk.getInfo();
+      const txs = await sdk.listPayments({});
+      
+      setWalletInfo(info);
+      setTransactions(txs);
+    } catch (err) {
+      console.error('Error refreshing wallet data:', err);
+    }
+  }, [sdk]);
+  
+  // Handle receiving payment
+  const handleReceive = async () => {
+    if (!sdk) return;
+    
+    try {
+      // Fetch lightning limits
+      const limits = await sdk.fetchLightningLimits();
+      
+      // Prepare receive with amount of 5000 sats
+      const prepareResponse = await sdk.prepareReceivePayment({
+        paymentMethod: 'lightning',
+        amount: {
+          type: 'bitcoin',
+          payerAmountSat: 5000
+        }
+      });
+      
+      // Create the invoice
+      const response = await sdk.receivePayment({
+        prepareResponse,
+        description: 'Payment received via web app'
+      });
+      
+      // Show the invoice to user
+      alert(`Generated invoice: ${response.destination}`);
+    } catch (err) {
+      console.error('Error generating invoice:', err);
+      setError(err.message);
+    }
+  };
+  
+  // Handle sending payment
+  const handleSend = async (invoice) => {
+    if (!sdk || !invoice) return;
+    
+    try {
+      // Prepare send payment
+      const prepareResponse = await sdk.prepareSendPayment({
+        destination: invoice
+      });
+      
+      // Check if fees are acceptable
+      if (prepareResponse.feesSat > 100) {
+        const confirmed = window.confirm(`Fee is ${prepareResponse.feesSat} sats. Continue?`);
+        if (!confirmed) return;
+      }
+      
+      // Send payment
+      const sendResponse = await sdk.sendPayment({
+        prepareResponse
+      });
+      
+      alert('Payment sent successfully!');
+      refreshWalletData();
+    } catch (err) {
+      console.error('Error sending payment:', err);
+      setError(err.message);
+    }
+  };
+  
+  if (isLoading) {
+    return <div>Loading wallet...</div>;
+  }
+  
+  if (error) {
+    return <div>Error: {error}</div>;
+  }
+  
+  return (
+    <div>
+      <h1>Breez SDK Wallet</h1>
+      
+      {walletInfo && (
+        <div>
+          <h2>Balance: {walletInfo.walletInfo.balanceSat.toLocaleString()} sats</h2>
+          <button onClick={handleReceive}>Receive</button>
+          <button onClick={() => {
+            const invoice = prompt('Enter invoice to pay:');
+            if (invoice) handleSend(invoice);
+          }}>Send</button>
+          
+          <h3>Transaction History</h3>
+          <ul>
+            {transactions.map((tx, index) => (
+              <li key={index}>
+                {tx.paymentType === 'receive' ? 'Received: ' : 'Sent: '}
+                {tx.amountSat.toLocaleString()} sats
+                {tx.status !== 'complete' && ` (${tx.status})`}
+              </li>
+            ))}
+          </ul>
+        </div>
+      )}
+    </div>
+  );
+}
+
+export default WalletComponent;
+```
+
+## End-User Fees
+
+### Sending Lightning Payments
+
+Sending Lightning payments involves a submarine swap and two Liquid on-chain transactions:
+
+1. User broadcasts an L-BTC transaction to a Liquid lockup address
+2. Swapper pays the invoice and gets a preimage
+3. Swapper broadcasts an L-BTC transaction to claim funds
+
+Fee components:
+- Lockup Transaction Fee: ~34 sats (0.1 sat/discount vbyte)
+- Claim Transaction Fee: ~19 sats (0.1 sat/discount vbyte)
+- Swap Service Fee: 0.1% of the amount sent
+
+Example: If sending 10k sats, total fee = 34 + 19 + 10 = 63 sats
+
+### Receiving Lightning Payments
+
+Receiving Lightning payments involves a reverse submarine swap and two Liquid on-chain transactions:
+
+1. Sender pays the Swapper invoice
+2. Swapper broadcasts an L-BTC transaction to a Liquid lockup address
+3. SDK claims the funds and exposes the preimage
+4. Swapper uses the preimage to claim funds
+
+Fee components:
+- Lockup Transaction Fee: ~27 sats (0.1 sat/discount vbyte)
+- Claim Transaction Fee: ~20 sats (0.1 sat/discount vbyte)
+- Swap Service Fee: 0.25% of the amount received
+
+Example: If receiving 10k sats, total fee = 27 + 20 + 25 = 72 sats
+
+### Sending to a Bitcoin Address
+
+Sending to a BTC address involves a trustless chain swap with 2 Liquid transactions and 2 BTC transactions:
+
+1. SDK broadcasts an L-BTC transaction to a Liquid lockup address
+2. Swapper broadcasts a BTC transaction to a Bitcoin lockup address
+3. Recipient claims the funds from the Bitcoin lockup address
+4. Swapper claims the funds from the Liquid lockup address
+
+Fee components:
+- L-BTC Lockup Transaction Fee: ~34 sats
+- BTC Lockup Transaction Fee: based on current BTC mempool usage
+- Swap Service Fee: 0.1% of the amount sent
+- BTC Claim Transaction Fee: fees to claim BTC to destination address
+
+Example: For 100k sats with 2000 sats BTC mining fees and 1000 sats claim fees, total = 34 + 2000 + 100 + 1000 = 3134 sats
+
+### Receiving from a BTC Address
+
+Receiving from a BTC address also involves a trustless chain swap:
+
+1. Sender broadcasts a BTC transaction to the Bitcoin lockup address
+2. Swapper broadcasts an L-BTC transaction to a Liquid lockup address
+3. SDK claims the funds from the Liquid lockup address
+4. Swapper claims the funds from the Bitcoin lockup address
+
+Fee components:
+- L-BTC Claim Transaction Fee: ~20 sats
+- BTC Claim Transaction Fee: based on Bitcoin mempool usage
+- Swapper Service Fee: 0.1% of the amount received
+
+Example: For 100k sats with 2000 sats BTC mining fees, total = 20 + 100 + 2000 = 2120 sats
+
+## Best Practices
+
+### Syncing
+
+Always ensure the SDK instance is synced before performing actions:
+
+```typescript
+const waitForSynced = async (sdk) => {
+  const eventPromise = new Promise((resolve) => {
+    const listener = {
+      onEvent: (event) => {
+        if (event.type === 'synced') {
+          resolve();
+        }
+      }
+    };
+    sdk.addEventListener(listener);
+  });
+  
+  // Wait for sync event or timeout after 30 seconds
+  return Promise.race([
+    eventPromise,
+    new Promise((_, reject) => setTimeout(() => reject(new Error('Sync timeout')), 30000))
+  ]);
+};
+
+const performAction = async (sdk) => {
+  await waitForSynced(sdk);
+  
+  // Now it's safe to perform actions
+  const info = await sdk.getInfo();
+  console.log(info);
+};
+```
+
+### Error Handling
+
+Implement robust error handling:
+
+```typescript
+const safeOperation = async (operation) => {
+  try {
+    return await operation();
+  } catch (error) {
+    console.error(`Operation failed: ${error.message}`);
+    // Handle specific error types appropriately
+    if (error.message.includes('insufficient funds')) {
+      // Handle insufficient funds error
+    } else if (error.message.includes('connection')) {
+      // Handle connection error
+    }
+    throw error; // Re-throw or handle at a higher level
+  }
+};
+
+// Usage
+const result = await safeOperation(() => sdk.sendPayment({
+  prepareResponse
+}));
+```
+
+### Connection Lifecycle
+
+Manage the connection lifecycle properly:
+
+```typescript
+// Initialize only once per session
+const sdk = await connect(connectRequest);
+
+// Use SDK
+// ...
+
+// Disconnect when done
+try {
+  await sdk.disconnect();
+} catch (error) {
+  console.error(`Error disconnecting: ${error.message}`);
+}
+```
+
+### Fee Handling
+
+Always check fees before executing payments:
+
+```typescript
+const executeSafePayment = async (sdk, destination, maxAcceptableFee = 1000) => {
+  // Get fee information
+  const prepareResponse = await sdk.prepareSendPayment({
+    destination
+  });
+  
+  const feesSat = prepareResponse.feesSat || 0;
+  
+  // Check if fees are acceptable before proceeding
+  if (feesSat <= maxAcceptableFee) {
+    // Execute payment
+    return await sdk.sendPayment({
+      prepareResponse
+    });
+  } else {
+    // Fees are too high
+    throw new Error(`Fees too high: ${feesSat} sats (maximum: ${maxAcceptableFee} sats)`);
+  }
+};
+```
+
+### Browser Storage Considerations
+
+When working with browser storage, consider:
+
+```typescript
+const secureMnemonicStorage = {
+  // Save mnemonic - in production, consider more secure options than localStorage
+  save: (mnemonic) => {
+    // For demonstration only - not secure for production
+    localStorage.setItem('encrypted_mnemonic', btoa(mnemonic));
+  },
+  
+  // Retrieve mnemonic
+  retrieve: () => {
+    const storedMnemonic = localStorage.getItem('encrypted_mnemonic');
+    return storedMnemonic ? atob(storedMnemonic) : null;
+  },
+  
+  // Clear mnemonic
+  clear: () => {
+    localStorage.removeItem('encrypted_mnemonic');
+  }
+};
+```
+
+## Security Considerations
+
+1. **Protecting Mnemonics**
+   - Never hardcode mnemonics in your code
+   - Store encrypted or in secure storage
+   - Consider using a custom signer for production apps
+   - For web apps, consider using hardware wallet integration
+
+2. **API Key Security**
+   - Store API keys in environment variables
+   - Consider proxy server for production to avoid exposing keys in frontend code
+   - Don't commit API keys to source control
+
+3. **Validating Inputs**
+   - Always validate payment destinations
+   - Check amounts are within reasonable limits
+   - Sanitize and validate all external inputs
+
+4. **WASM-Specific Considerations**
+   - Load WASM files from a trusted source
+   - Be aware of cross-origin restrictions and CORS settings
+   - Consider using CSP (Content Security Policy) to restrict where WASM can be loaded from
+
+5. **Browser Environment**
+   - Use HTTPS for all connections
+   - Be aware of limited storage options in browsers
+   - Consider the implications of users clearing browser storage and provide recovery options
\ No newline at end of file

From e114af2b231944b886f046cc4d06044b77bf1ec5 Mon Sep 17 00:00:00 2001
From: Aljaz Ceru <aljaz@ceru.si>
Date: Thu, 1 May 2025 10:44:24 +0200
Subject: [PATCH 2/2] adding python

---
 .../breez-nodeless-python-llms.md             | 1502 +++++++++++++++++
 1 file changed, 1502 insertions(+)
 create mode 100644 examples/breez-nodeless-llms/breez-nodeless-python-llms.md

diff --git a/examples/breez-nodeless-llms/breez-nodeless-python-llms.md b/examples/breez-nodeless-llms/breez-nodeless-python-llms.md
new file mode 100644
index 00000000..33f4b83f
--- /dev/null
+++ b/examples/breez-nodeless-llms/breez-nodeless-python-llms.md
@@ -0,0 +1,1502 @@
+# Breez SDK Nodeless (Liquid implementation) Documentation
+
+This comprehensive document provides all the context needed to build applications with the Python bindings of Breez SDK Nodeless, a toolkit for integrating Bitcoin, Lightning Network, and Liquid Network functionality into your applications.
+
+## Overview
+
+Breez SDK Nodeless (Liquid implementation) is a powerful library that allows developers to integrate Bitcoin, Lightning Network, and Liquid Network functionality into their applications. The SDK abstracts many of the complexities of working with these technologies, providing a simple interface for common operations such as sending and receiving payments, managing wallets, and interacting with both Lightning and Liquid networks.
+
+Key capabilities include:
+- Wallet management and balance tracking
+- Lightning Network payments
+- Liquid Network transactions
+- Onchain Bitcoin operations
+- LNURL support (auth, pay, withdraw)
+- Non-Bitcoin asset management
+- Webhook integration
+- Event handling with listeners
+
+## Getting Started
+
+### Installation
+
+```bash
+pip install breez-sdk-liquid
+```
+
+### Guidelines
+- **always make sure the sdk instance is synced before performing any actions**
+-  **Add logging**: Add sufficient logging into your application to diagnose any issues users are having. 
+- **Display pending payments**: Payments always contain a status field that can be used to determine if the payment was completed or not. Make sure you handle the case where the payment is still pending by showing the correct status to the user.
+    
+- **Enable swap refunds**: Swaps that are the result of receiving an On-Chain Transaction may not be completed and change to `Refundable` state. Make sure you handle this case correctly by allowing the user to retry the refund with different fees as long as the refund is not confirmed.
+- **Expose swap fees**: When sending or receiving on-chain, make sure to clearly show the expected fees involved, as well as the send / receive amounts.
+### Initializing the SDK
+
+To get started with Breez SDK Nodeless (Liquid implementation), you need to initialize the SDK with your configuration:
+
+```python
+import breez_sdk_liquid
+from breez_sdk_liquid import connect, default_config, ConnectRequest, LiquidNetwork
+
+def start():
+    # Your mnemonic seed phrase for wallet recovery
+    mnemonic = "<mnemonic words>"
+
+    # Create the default config, providing your Breez API key
+    config = default_config(
+        network=LiquidNetwork.MAINNET,
+        breez_api_key="<your-Breez-API-key>"
+    )
+
+    # Customize the config object according to your needs
+    config.working_dir = "path to an existing directory"
+
+    try:
+        connect_request = ConnectRequest(
+            config=config,
+            mnemonic=mnemonic
+        )
+        sdk = connect(connect_request)
+        return sdk
+    except Exception as error:
+        logging.error(error)
+        raise
+```
+
+### Custom Signer Support
+
+If you prefer to manage your own keys, you can use a custom signer:
+
+```python
+import logging
+import breez_sdk_liquid
+from breez_sdk_liquid import connect_with_signer, default_config, LiquidNetwork, Signer, ConnectWithSignerRequest
+
+def connect_with_self_signer(signer: Signer):
+   
+    # Create the default config, providing your Breez API key
+    config = default_config(
+        network=LiquidNetwork.MAINNET,
+        breez_api_key="<your-Breez-API-key>"
+    )
+
+    # Customize the config object according to your needs
+    config.working_dir = "path to an existing directory"
+
+    try:
+        connect_request = ConnectWithSignerRequest(config=config)
+        sdk = connect_with_signer(connect_request, signer)
+        return sdk
+    except Exception as error:
+        logging.error(error)
+        raise
+```
+
+### Basic Operations
+
+#### Fetch Balance
+- **always make sure the sdk instance is synced before performing any actions**
+
+```python
+def fetch_balance(sdk):
+    try:
+        info = sdk.get_info()
+        balance_sat = info.wallet_info.balance_sat
+        pending_send_sat = info.wallet_info.pending_send_sat
+        pending_receive_sat = info.wallet_info.pending_receive_sat
+    except Exception as error:
+        logging.error(error)
+        raise
+```
+
+#### Logging and Event Handling
+
+```python
+# Define a logger class
+class SdkLogger(Logger):
+    def log(self, log_entry: LogEntry):
+        logging.debug(f"Received log [{log_entry.level}]: {log_entry.line}")
+
+# Set up logging
+def set_logger(logger: SdkLogger):
+    try:
+        breez_sdk_liquid.set_logger(logger)
+    except Exception as error:
+        logging.error(error)
+        raise
+
+# Define an event listener
+class SdkListener(EventListener):
+    def on_event(self, sdk_event: SdkEvent):
+        logging.debug(f"Received event {sdk_event}")
+
+# Add an event listener
+def add_event_listener(sdk, listener: SdkListener):
+    try:
+        listener_id = sdk.add_event_listener(listener)
+        return listener_id
+    except Exception as error:
+        logging.error(error)
+        raise
+
+# Remove an event listener
+def remove_event_listener(sdk, listener_id):
+    try:
+        sdk.remove_event_listener(listener_id)
+    except Exception as error:
+        logging.error(error)
+        raise
+```
+
+## Core Features
+
+### Buying Bitcoin
+
+```python
+from breez_sdk_liquid import BindingLiquidSdk, OnchainPaymentLimitsResponse, BuyBitcoinProvider, PrepareBuyBitcoinRequest, PrepareBuyBitcoinResponse, BuyBitcoinRequest
+
+def fetch_onchain_limits(sdk: BindingLiquidSdk):
+    try:
+        current_limits = sdk.fetch_onchain_limits()
+        logging.debug(
+            "Minimum amount, in sats ",
+            current_limits.receive.min_sat
+        )
+        logging.debug(
+            "Maximum amount, in sats ",
+            current_limits.receive.max_sat
+        )
+        return current_limits
+    except Exception as error:
+        logging.error(error)
+        raise
+
+def prepare_buy_btc(sdk: BindingLiquidSdk, current_limits: OnchainPaymentLimitsResponse):
+    try:
+        req = PrepareBuyBitcoinRequest(
+            provider=BuyBitcoinProvider.MOONPAY,
+            amount_sat=current_limits.receive.min_sat
+        )
+        prepare_response = sdk.prepare_buy_bitcoin(req)
+
+        # Check the fees are acceptable before proceeding
+        receive_fees_sat = prepare_response.fees_sat
+        logging.debug("Fees: ", receive_fees_sat, " sats")
+        return prepare_response
+    except Exception as error:
+        logging.error(error)
+        raise
+
+def buy_btc(sdk: BindingLiquidSdk, prepare_response: PrepareBuyBitcoinResponse):
+    try:
+        req = BuyBitcoinRequest(prepare_response=prepare_response)
+        url = sdk.buy_bitcoin(req)
+    except Exception as error:
+        logging.error(error)
+        raise
+```
+
+### Fiat Currencies
+
+```python
+def list_fiat_currencies(sdk):
+   try:
+      supported_fiat_currencies = sdk.list_fiat_currencies()
+   except Exception as error:
+      print(error)
+      raise
+
+def fetch_fiat_rates(sdk):
+   try:
+      fiat_rates = sdk.fetch_fiat_rates()
+   except Exception as error:
+      print(error)
+      raise
+```
+
+### Sending Payments
+
+#### Lightning Payments
+
+Sending Lightning payments involves a submarine swap and two Liquid on-chain transactions. The process is as follows:
+
+1. User broadcasts an L-BTC transaction to a Liquid lockup address.
+2. Swapper pays the invoice, sending to the recipient, and then gets a preimage.
+3. Swapper broadcasts an L-BTC transaction to claim the funds from the Liquid lockup address.
+
+The fee a user pays to send a Lightning payment is composed of three parts:
+
+1. **Lockup Transaction Fee:** ~34 sats (0.1 sat/discount vbyte).
+2. **Claim Transaction Fee:** ~19 sats (0.1 sat/discount vbyte).
+3. **Swap Service Fee:** 0.1% fee on the amount sent.
+
+Note: swap service fee is dynamic and can change. Currently, it is 0.1%.
+
+> **Example**: If the user sends 10k sats, the fee would be:
+> 
+> - 34 sats [Lockup Transaction Fee] + 19 sats [Claim Transaction Fee] + 10 sats [Swapper Service Fee] = 63 sats
+```python
+def prepare_send_payment_lightning_bolt11(sdk: BindingLiquidSdk):
+    # Set the bolt11 invoice you wish to pay
+    destination = "<bolt11 invoice>"
+    try:
+        prepare_response = sdk.prepare_send_payment(
+            PrepareSendRequest(
+                destination=destination
+            )
+        )
+
+        # If the fees are acceptable, continue to create the Send Payment
+        send_fees_sat = prepare_response.fees_sat
+        logging.debug(f"Fees: {send_fees_sat} sats")
+        return prepare_response
+    except Exception as error:
+        logging.error(error)
+        raise
+
+def prepare_send_payment_lightning_bolt12(sdk: BindingLiquidSdk):
+    # Set the bolt12 offer you wish to pay
+    destination = "<bolt12 offer>"
+    try:
+        optional_amount = PayAmount.BITCOIN(5_000)
+
+        prepare_response = sdk.prepare_send_payment(
+            PrepareSendRequest(
+                destination=destination,
+                amount=optional_amount
+            )
+        )
+
+        return prepare_response
+    except Exception as error:
+        logging.error(error)
+        raise
+```
+
+#### Liquid Payments
+
+```python
+def prepare_send_payment_liquid(sdk: BindingLiquidSdk):
+    # Set the Liquid BIP21 or Liquid address you wish to pay
+    destination = "<Liquid BIP21 or address>"
+    try:
+        optional_amount = PayAmount.BITCOIN(5_000)
+        prepare_response = sdk.prepare_send_payment(
+            PrepareSendRequest(
+                destination=destination,
+                amount=optional_amount
+            )
+        )
+
+        # If the fees are acceptable, continue to create the Send Payment
+        send_fees_sat = prepare_response.fees_sat
+        logging.debug(f"Fees: {send_fees_sat} sats")
+        return prepare_response
+    except Exception as error:
+        logging.error(error)
+        raise
+
+def prepare_send_payment_liquid_drain(sdk: BindingLiquidSdk):
+    # Set the Liquid BIP21 or Liquid address you wish to pay
+    destination = "<Liquid BIP21 or address>"
+    try:
+        optional_amount = PayAmount.DRAIN
+        prepare_response = sdk.prepare_send_payment(
+            PrepareSendRequest(
+                destination=destination,
+                amount=optional_amount
+            )
+        )
+
+        # If the fees are acceptable, continue to create the Send Payment
+        send_fees_sat = prepare_response.fees_sat
+        logging.debug(f"Fees: {send_fees_sat} sats")
+        return prepare_response
+    except Exception as error:
+        logging.error(error)
+        raise
+```
+
+#### Execute Payment
+- **always make sure the sdk instance is synced before performing any actions**
+
+```python
+def send_payment(sdk: BindingLiquidSdk, prepare_response: PrepareSendResponse):
+    try:
+        send_response = sdk.send_payment(
+            SendPaymentRequest(
+                prepare_response=prepare_response
+            )
+        )
+        payment = send_response.payment
+    except Exception as error:
+        logging.error(error)
+        raise
+```
+
+### Receiving Payments
+**always make sure the sdk instance is synced before performing any actions**
+#### Lightning Payments
+Receiving Lightning payments involves a reverse submarine swap and requires two Liquid on-chain transactions. The process is as follows:
+
+1. Sender pays the Swapper invoice.
+2. Swapper broadcasts an L-BTC transaction to a Liquid lockup address.
+3. SDK claims the funds from the Liquid lockup address and then exposes the preimage.
+4. Swapper uses the preimage to claim the funds from the Liquid lockup address.
+
+The fee a user pays to receive a Lightning payment is composed of three parts:
+
+1. **Lockup Transaction Fee:** ~27 sats (0.1 sat/discount vbyte).
+2. **Claim Transaction Fee:** ~20 sats (0.1 sat/discount vbyte).
+3. **Swap Service Fee:** 0.25% fee on the amount received.
+
+Note: swap service fee is dynamic and can change. Currently, it is 0.25%.
+
+> **Example**: If the sender sends 10k sats, the fee for the end-user would be:
+> 
+> - 27 sats [Lockup Transaction Fee] + 20 sats [Claim Transaction Fee] + 25 sats [Swapper Service Fee] = 72 sats
+```python
+def prepare_receive_lightning(sdk: BindingLiquidSdk):
+    try:
+        # Fetch the lightning Receive limits
+        current_limits = sdk.fetch_lightning_limits()
+        logging.debug(f"Minimum amount allowed to deposit in sats {current_limits.receive.min_sat}")
+        logging.debug(f"Maximum amount allowed to deposit in sats {current_limits.receive.max_sat}")
+
+        # Set the invoice amount you wish the payer to send, which should be within the above limits
+        optional_amount = ReceiveAmount.BITCOIN(5_000)
+        prepare_request = PrepareReceiveRequest(
+            payment_method=PaymentMethod.LIGHTNING,
+            amount=optional_amount
+        )
+        prepare_response = sdk.prepare_receive_payment(prepare_request)
+
+        # If the fees are acceptable, continue to create the Receive Payment
+        receive_fees_sat = prepare_response.fees_sat
+        logging.debug(f"Fees: {receive_fees_sat} sats")
+        return prepare_response
+    except Exception as error:
+        logging.error(error)
+        raise
+```
+
+#### Onchain Payments
+
+```python
+def prepare_receive_onchain(sdk: BindingLiquidSdk):
+    try:
+        # Fetch the onchain Receive limits
+        current_limits = sdk.fetch_onchain_limits()
+        logging.debug(f"Minimum amount allowed to deposit in sats {current_limits.receive.min_sat}")
+        logging.debug(f"Maximum amount allowed to deposit in sats {current_limits.receive.max_sat}")
+
+        # Set the onchain amount you wish the payer to send, which should be within the above limits
+        optional_amount = ReceiveAmount.BITCOIN(5_000)
+        prepare_request = PrepareReceiveRequest(
+            payment_method=PaymentMethod.BITCOIN_ADDRESS,
+            amount=optional_amount
+        )
+        prepare_response = sdk.prepare_receive_payment(prepare_request)
+
+        # If the fees are acceptable, continue to create the Receive Payment
+        receive_fees_sat = prepare_response.fees_sat
+        logging.debug(f"Fees: {receive_fees_sat} sats")
+        return prepare_response
+    except Exception as error:
+        logging.error(error)
+        raise
+```
+
+#### Liquid Payments
+
+```python
+def prepare_receive_liquid(sdk: BindingLiquidSdk):
+    try:
+        # Create a Liquid BIP21 URI/address to receive a payment to.
+        # There are no limits, but the payer amount should be greater than broadcast fees when specified
+        # Note: Not setting the amount will generate a plain Liquid address
+        optional_amount = ReceiveAmount.BITCOIN(5_000)
+        prepare_request = PrepareReceiveRequest(
+            payment_method=PaymentMethod.LIQUID_ADDRESS,
+            amount=optional_amount
+        )
+        prepare_response = sdk.prepare_receive_payment(prepare_request)
+
+        # If the fees are acceptable, continue to create the Receive Payment
+        receive_fees_sat = prepare_response.fees_sat
+        logging.debug(f"Fees: {receive_fees_sat} sats")
+        return prepare_response
+    except Exception as error:
+        logging.error(error)
+        raise
+```
+
+#### Execute Receive
+
+```python
+def receive_payment(sdk: BindingLiquidSdk, prepare_response: PrepareReceiveResponse):
+    try:
+        optional_description = "<description>"
+        req = ReceivePaymentRequest(
+            prepare_response=prepare_response,
+            description=optional_description
+        )
+        res = sdk.receive_payment(req)
+        destination = res.destination
+    except Exception as error:
+        logging.error(error)
+        raise
+```
+
+### LNURL Operations
+
+#### LNURL Authentication
+
+```python
+def auth(sdk: BindingLiquidSdk):
+    # Endpoint can also be of the form:
+    # keyauth://domain.com/auth?key=val
+    lnurl_auth_url = "lnurl1dp68gurn8ghj7mr0vdskc6r0wd6z7mrww4excttvdankjm3lw3skw0tvdankjm3xdvcn6vtp8q6n2dfsx5mrjwtrxdjnqvtzv56rzcnyv3jrxv3sxqmkyenrvv6kve3exv6nqdtyv43nqcmzvdsnvdrzx33rsenxx5unqc3cxgeqgntfgu"
+
+    try:
+        parsed_input = sdk.parse(lnurl_auth_url)
+        if isinstance(parsed_input, InputType.LN_URL_AUTH):
+            result = sdk.lnurl_auth(parsed_input.data)
+            if result.is_ok():
+                logging.debug("Successfully authenticated")
+            else:
+                logging.debug("Failed to authenticate")
+    except Exception as error:
+        logging.error(error)
+        raise
+```
+
+#### LNURL Pay
+
+```python
+def prepare_pay(sdk: BindingLiquidSdk):
+    # Endpoint can also be of the form:
+    # lnurlp://domain.com/lnurl-pay?key=val
+    # lnurl1dp68gurn8ghj7mr0vdskc6r0wd6z7mrww4excttsv9un7um9wdekjmmw84jxywf5x43rvv35xgmr2enrxanr2cfcvsmnwe3jxcukvde48qukgdec89snwde3vfjxvepjxpjnjvtpxd3kvdnxx5crxwpjvyunsephsz36jf
+    lnurl_pay_url = "lightning@address.com"
+    try: 
+        parsed_input = sdk.parse(lnurl_pay_url)
+        if isinstance(parsed_input, InputType.LN_URL_PAY):
+            amount = PayAmount.BITCOIN(5_000)
+            optional_comment = "<comment>"
+            optional_validate_success_action_url = True
+
+            req = PrepareLnUrlPayRequest(
+                data=parsed_input.data,
+                amount=amount,
+                bip353_address=parsed_input.bip353_address,
+                comment=optional_comment,
+                validate_success_action_url=optional_validate_success_action_url
+            )
+            prepare_response = sdk.prepare_lnurl_pay(req)
+
+            # If the fees are acceptable, continue to create the LNURL Pay
+            fees_sat = prepare_response.fees_sat
+            logging.debug("Fees: ", fees_sat, " sats")
+            return prepare_response
+    except Exception as error:
+        logging.error(error)
+        raise
+
+def pay(sdk: BindingLiquidSdk, prepare_response: PrepareLnUrlPayResponse):
+    try:
+        result = sdk.lnurl_pay(LnUrlPayRequest(prepare_response))
+    except Exception as error:
+        logging.error(error)
+        raise
+```
+
+#### LNURL Withdraw
+
+```python
+def withdraw(sdk: BindingLiquidSdk):
+    # Endpoint can also be of the form:
+    # lnurlw://domain.com/lnurl-withdraw?key=val
+    lnurl_withdraw_url = "lnurl1dp68gurn8ghj7mr0vdskc6r0wd6z7mrww4exctthd96xserjv9mn7um9wdekjmmw843xxwpexdnxzen9vgunsvfexq6rvdecx93rgdmyxcuxverrvcursenpxvukzv3c8qunsdecx33nzwpnvg6ryc3hv93nzvecxgcxgwp3h33lxk"
+
+    try:
+        parsed_input = sdk.parse(lnurl_withdraw_url)
+        if isinstance(parsed_input, InputType.LN_URL_WITHDRAW):
+            amount_msat = parsed_input.data.min_withdrawable
+            result = sdk.lnurl_withdraw(parsed_input.data, amount_msat, "comment")
+            return result
+    except Exception as error:
+        logging.error(error)
+        raise
+```
+
+### Onchain Operations
+
+#### Pay Onchain
+
+```python
+def fetch_pay_onchain_limits(sdk: BindingLiquidSdk):
+    try:
+        current_limits = sdk.fetch_onchain_limits()
+        logging.debug(
+            "Minimum amount, in sats ",
+            current_limits.send.min_sat
+        )
+        logging.debug(
+            "Maximum amount, in sats ",
+            current_limits.send.max_sat
+        )
+        return current_limits
+    except Exception as error:
+        logging.error(error)
+        raise
+
+def prepare_pay_onchain(sdk: BindingLiquidSdk):
+    try:
+        amount = PayAmount.BITCOIN(5_000)
+        prepare_request = PreparePayOnchainRequest(amount=amount)
+        prepare_response = sdk.prepare_pay_onchain(prepare_request)
+
+        # Check if the fees are acceptable before proceeding
+        total_fees_sat = prepare_response.total_fees_sat
+    except Exception as error:
+        logging.error(error)
+        raise
+
+def prepare_pay_onchain_fee_rate(sdk: BindingLiquidSdk):
+    try:
+        amount = PayAmount.BITCOIN(5_000)
+        optional_sat_per_vbyte = 21
+
+        prepare_request = PreparePayOnchainRequest(
+            amount=amount,
+            fee_rate_sat_per_vbyte=optional_sat_per_vbyte
+        )
+        prepare_response = sdk.prepare_pay_onchain(prepare_request)
+
+        # Check if the fees are acceptable before proceeding
+        claim_fees_sat = prepare_response.claim_fees_sat
+        total_fees_sat = prepare_response.total_fees_sat
+    except Exception as error:
+        logging.error(error)
+        raise
+
+def start_pay_onchain(sdk: BindingLiquidSdk, prepare_response: PreparePayOnchainResponse):
+    address = "bc1.."
+    try:
+        sdk.pay_onchain(PayOnchainRequest(
+            address=address,
+            prepare_response=prepare_response
+        ))
+    except Exception as error:
+        logging.error(error)
+        raise
+```
+
+#### Drain Funds
+
+```python
+def prepare_pay_onchain_drain(sdk: BindingLiquidSdk):
+    try:
+        amount = PayAmount.DRAIN
+        prepare_request = PreparePayOnchainRequest(amount=amount)
+        prepare_response = sdk.prepare_pay_onchain(prepare_request)
+
+        # Check if the fees are acceptable before proceeding
+        total_fees_sat = prepare_response.total_fees_sat
+    except Exception as error:
+        logging.error(error)
+        raise
+```
+
+#### Receive Onchain
+
+```python
+def list_refundables(sdk: BindingLiquidSdk):
+    try:
+        refundables = sdk.list_refundables()
+        return refundables
+    except Exception as error:
+        logging.error(error)
+        raise
+
+def execute_refund(sdk: BindingLiquidSdk, refund_tx_fee_rate: int, refundable: RefundableSwap):
+    destination_address = "..."
+    fee_rate_sat_per_vbyte = refund_tx_fee_rate
+    try:
+        sdk.refund(RefundRequest(
+            swap_address=refundable.swap_address,
+            refund_address=destination_address,
+            fee_rate_sat_per_vbyte=fee_rate_sat_per_vbyte
+        ))
+    except Exception as error:
+        logging.error(error)
+        raise
+
+def rescan_swaps(sdk: BindingLiquidSdk):
+    try:
+        sdk.rescan_onchain_swaps()
+    except Exception as error:
+        logging.error(error)
+        raise
+
+def recommended_fees(sdk: BindingLiquidSdk):
+    try:
+        fees = sdk.recommended_fees()
+    except Exception as error:
+        logging.error(error)
+        raise
+```
+
+#### Handle Fee Acceptance
+
+```python
+def handle_payments_waiting_fee_acceptance(sdk: BindingLiquidSdk):
+    try:
+        # Payments on hold waiting for fee acceptance have the state WAITING_FEE_ACCEPTANCE
+        payments_waiting_fee_acceptance = sdk.list_payments(
+            ListPaymentsRequest(
+                states=[PaymentState.WAITING_FEE_ACCEPTANCE]
+            )
+        )
+
+        for payment in payments_waiting_fee_acceptance:
+            if not isinstance(payment.details, PaymentDetails.BITCOIN):
+                # Only Bitcoin payments can be `WAITING_FEE_ACCEPTANCE`
+                continue
+
+            fetch_fees_response = sdk.fetch_payment_proposed_fees(
+                FetchPaymentProposedFeesRequest(
+                    swap_id=payment.details.swap_id
+                )
+            )
+
+            logging.info(
+                f"Payer sent {fetch_fees_response.payer_amount_sat} "
+                f"and currently proposed fees are {fetch_fees_response.fees_sat}"
+            )
+
+            # If the user is ok with the fees, accept them, allowing the payment to proceed
+            sdk.accept_payment_proposed_fees(
+                AcceptPaymentProposedFeesRequest(
+                    response=fetch_fees_response
+                )
+            )
+
+    except Exception as error:
+        logging.error(error)
+        raise
+```
+
+### Non-Bitcoin Assets
+
+```python
+def prepare_receive_asset(sdk: BindingLiquidSdk):
+    try:
+        # Create a Liquid BIP21 URI/address to receive an asset payment to.
+        # Note: Not setting the amount will generate an amountless BIP21 URI.
+        usdt_asset_id = "ce091c998b83c78bb71a632313ba3760f1763d9cfcffae02258ffa9865a37bd2"
+        optional_amount = ReceiveAmount.ASSET(usdt_asset_id, 1.50)
+        prepare_request = PrepareReceiveRequest(
+            payment_method=PaymentMethod.LIQUID_ADDRESS,
+            amount=optional_amount
+        )
+        prepare_response = sdk.prepare_receive_payment(prepare_request)
+
+        # If the fees are acceptable, continue to create the Receive Payment
+        receive_fees_sat = prepare_response.fees_sat
+        logging.debug("Fees: ", receive_fees_sat, " sats")
+        return prepare_response
+    except Exception as error:
+        logging.error(error)
+        raise
+
+def prepare_send_payment_asset(sdk: BindingLiquidSdk):
+    # Set the Liquid BIP21 or Liquid address you wish to pay
+    destination = "<Liquid BIP21 or address>"
+    try:
+        # If the destination is an address or an amountless BIP21 URI,
+        # you must specifiy an asset amount
+        usdt_asset_id = "ce091c998b83c78bb71a632313ba3760f1763d9cfcffae02258ffa9865a37bd2"
+        optional_amount = PayAmount.ASSET(usdt_asset_id, 1.50)
+        prepare_response = sdk.prepare_send_payment(PrepareSendRequest(destination, optional_amount))
+
+        # If the fees are acceptable, continue to create the Send Payment
+        send_fees_sat = prepare_response.fees_sat
+        logging.debug("Fees: ", send_fees_sat, " sats")
+        return prepare_response
+    except Exception as error:
+        logging.error(error)
+        raise
+
+def configure_asset_metadata():
+    # Create the default config
+    config = default_config(
+        network=LiquidNetwork.MAINNET,
+        breez_api_key="<your-Breez-API-key>"
+    )
+
+    # Configure asset metadata
+    config.asset_metadata = [
+        AssetMetadata(
+            asset_id="18729918ab4bca843656f08d4dd877bed6641fbd596a0a963abbf199cfeb3cec",
+            name="PEGx EUR",
+            ticker="EURx",
+            precision=8
+        )
+    ]
+
+def fetch_asset_balance(sdk: BindingLiquidSdk):
+    try:
+        info = sdk.get_info()
+        asset_balances = info.wallet_info.asset_balances
+    except Exception as error:
+        logging.error(error)
+        raise
+```
+
+### Messages and Signing
+
+```python
+def sign_message(sdk: BindingLiquidSdk):
+    message = "<message to sign>"
+    try:
+        sign_message_request = SignMessageRequest(message=message)
+        sign_message_response = sdk.sign_message(sign_message_request)
+
+        # Get the wallet info for your pubkey
+        info = sdk.get_info()
+
+        signature = sign_message_response.signature
+        pubkey = info.wallet_info.pubkey
+
+        logging.debug(f"Pubkey: {pubkey}")
+        logging.debug(f"Signature: {signature}")
+    except Exception as error:
+        logging.error(error)
+        raise
+
+def check_message(sdk: BindingLiquidSdk):
+    message = "<message>"
+    pubkey = "<pubkey of signer>"
+    signature = "<message signature>"
+    try:
+        check_message_request = CheckMessageRequest(
+            message=message,
+            pubkey=pubkey,
+            signature=signature
+        )
+        check_message_response = sdk.check_message(check_message_request)
+
+        is_valid = check_message_response.is_valid
+
+        logging.debug(f"Signature valid: {is_valid}")
+    except Exception as error:
+        logging.error(error)
+        raise
+```
+
+### List Payments
+
+```python
+def get_payment(sdk: BindingLiquidSdk):
+    try:
+        payment_hash = "<payment hash>"
+        sdk.get_payment(GetPaymentRequest.PAYMENT_HASH(payment_hash))
+
+        swap_id = "<swap id>"
+        sdk.get_payment(GetPaymentRequest.SWAP_ID(swap_id))
+    except Exception as error:
+        logging.error(error)
+        raise
+
+def list_payments(sdk: BindingLiquidSdk):
+    try:
+        sdk.list_payments(ListPaymentsRequest())
+    except Exception as error:
+        logging.error(error)
+        raise
+
+def list_payments_filtered(sdk: BindingLiquidSdk):
+    try:
+        req = ListPaymentsRequest(
+            filters = [PaymentType.SEND],
+            from_timestamp = 1696880000, 
+            to_timestamp = 1696959200, 
+            offset = 0,
+            limit = 50)
+        sdk.list_payments(req)
+    except Exception as error:
+        logging.error(error)
+        raise
+
+def list_payments_details_address(sdk: BindingLiquidSdk):
+    try:
+        address = "<Bitcoin address>"
+        req = ListPaymentsRequest(
+            details = ListPaymentDetails.BITCOIN(address))
+        sdk.list_payments(req)
+    except Exception as error:
+        logging.error(error)
+        raise
+
+def list_payments_details_destination(sdk: BindingLiquidSdk):
+    try:
+        destination = "<Liquid BIP21 or address>"
+        req = ListPaymentsRequest(
+            details = ListPaymentDetails.LIQUID(destination=destination))
+        sdk.list_payments(req)
+    except Exception as error:
+        logging.error(error)
+        raise
+```
+
+### Webhook Integration
+
+```python
+def register_webhook(sdk: BindingLiquidSdk):
+    try:
+        sdk.register_webhook("https://your-nds-service.com/notify?platform=ios&token=<PUSH_TOKEN>")
+    except Exception as error:
+        logging.error(error)
+        raise
+
+def unregister_webhook(sdk: BindingLiquidSdk):
+    try:
+        sdk.unregister_webhook()
+    except Exception as error:
+        logging.error(error)
+        raise
+```
+
+### Input Parsing
+
+```python
+def parse_input(sdk: BindingLiquidSdk):
+    input = "an input to be parsed..."
+
+    try:
+        parsed_input = sdk.parse(input)
+        if isinstance(parsed_input, InputType.BITCOIN_ADDRESS):
+            logging.debug(f"Input is Bitcoin address {parsed_input.address.address}")
+        elif isinstance(parsed_input, InputType.BOLT11):
+            amount = "unknown"
+            if parsed_input.invoice.amount_msat:
+                amount = str(parsed_input.invoice.amount_msat)
+            logging.debug(f"Input is BOLT11 invoice for {amount} msats")
+        elif isinstance(parsed_input, InputType.LN_URL_PAY):
+            logging.debug(f"Input is LNURL-Pay/Lightning address accepting min/max {parsed_input.data.min_sendable}/{parsed_input.data.max_sendable} msats - BIP353 was used: {parsed_input.bip353_address is not None}")
+        elif isinstance(parsed_input, InputType.LN_URL_WITHDRAW):
+            logging.debug(f"Input is LNURL-Withdraw for min/max {parsed_input.data.min_withdrawable}/{parsed_input.data.max_withdrawable} msats")
+        # Other input types are available
+    except Exception as error:
+        logging.error(error)
+        raise
+
+def configure_parsers():
+    mnemonic = "<mnemonic words>"
+
+    # Create the default config, providing your Breez API key
+    config = default_config(
+        network=LiquidNetwork.MAINNET,
+        breez_api_key="<your-Breez-API-key>"
+    )
+
+    # Configure external parsers
+    config.external_input_parsers = [
+        ExternalInputParser(
+            provider_id="provider_a",
+            input_regex="^provider_a",
+            parser_url="https://parser-domain.com/parser?input=<input>"
+        ),
+        ExternalInputParser(
+            provider_id="provider_b",
+            input_regex="^provider_b",
+            parser_url="https://parser-domain.com/parser?input=<input>"
+        )
+    ]
+
+    try:
+        connect_request = ConnectRequest(
+            config=config,
+            mnemonic=mnemonic
+        )
+        sdk = connect(connect_request)
+        return sdk
+    except Exception as error:
+        logging.error(error)
+        raise
+```
+
+## Complete CLI Example
+
+The SDK includes a complete CLI example that shows how to build a functional application:
+
+```python
+from typing import Optional
+from colorama import init as colorama_init, Style
+from mnemonic import Mnemonic
+from os.path import exists
+from qrcode.main import QRCode
+from qrcode.constants import ERROR_CORRECT_L
+from breez_sdk_liquid import LiquidNetwork, PayAmount, ReceiveAmount
+import argparse
+import breez_sdk_liquid
+import sys
+import time
+import os
+import json
+
+colorama_init()
+
+class Sdk:
+    """
+    A wrapper class for the Breez SDK.
+
+    This class initializes the Breez SDK, manages the mnemonic phrase,
+    and provides methods to interact with the SDK.
+
+    Attributes:
+        instance: The Breez SDK instance.
+        listener: An instance of SdkListener to handle SDK events.
+    """
+
+    def __init__(self, network: Optional[LiquidNetwork] = None, debug: Optional[bool] = False):
+        if debug:
+            breez_sdk_liquid.set_logger(SdkLogListener())
+
+        api_key = os.getenv('BREEZ_API_KEY')
+        mnemonic = self.read_mnemonic()
+        config = breez_sdk_liquid.default_config(network or LiquidNetwork.TESTNET, api_key)
+        connect_request = breez_sdk_liquid.ConnectRequest(config=config, mnemonic=mnemonic)
+        self.instance = breez_sdk_liquid.connect(connect_request)
+        self.listener = SdkListener()
+        self.instance.add_event_listener(self.listener)
+
+    def is_paid(self, destination: str):
+        return self.listener.is_paid(destination)
+
+    def is_synced(self):
+        return self.listener.is_synced()
+    
+    def read_mnemonic(self):
+        if exists('phrase'):
+            with open('phrase') as f:
+                mnemonic = f.readline()
+                f.close()
+                return mnemonic
+        else:
+            with open('phrase', 'w') as f:
+                mnemo = Mnemonic("english")
+                words = mnemo.generate(strength=128)
+                f.write(words)
+                f.close()
+                return words
+
+
+class SdkLogListener(breez_sdk_liquid.Logger):
+    def log(self, log_entry):
+        if log_entry.level != "TRACE":
+            print_dim("{}: {}".format(log_entry.level, log_entry.line))
+
+
+class SdkListener(breez_sdk_liquid.EventListener):
+    """
+    A listener class for handling Breez SDK events.
+
+    This class extends the EventListener from breez_sdk_liquid and implements
+    custom event handling logic, particularly for tracking successful payments.
+
+    Attributes:
+        paid (list): A list to store destinations of successful payments.
+    """
+
+    def __init__(self):
+        """
+        Initialize the SdkListener.
+
+        Sets up an empty list to track paid destinations.
+        """
+        self.synced = False
+        self.paid = []
+
+    def on_event(self, event):
+        if isinstance(event, breez_sdk_liquid.SdkEvent.SYNCED):
+            self.synced = True
+        else:
+            print_dim(event)
+        if isinstance(event, breez_sdk_liquid.SdkEvent.PAYMENT_SUCCEEDED):
+            if event.details.destination:
+                self.paid.append(event.details.destination)
+    
+    def is_paid(self, destination: str):
+        return destination in self.paid
+    
+    def is_synced(self):
+        return self.synced
+
+def parse_network(network_str: str) -> LiquidNetwork:
+    if network_str == 'TESTNET':
+        return LiquidNetwork.TESTNET
+    elif network_str == 'MAINNET':
+        return LiquidNetwork.MAINNET
+
+    raise Exception("Invalid network specified")
+
+def parse_pay_amount(params) -> Optional[PayAmount]:
+    amount_sat = getattr(params, 'amount_sat', None)
+    amount = getattr(params, 'amount', None)
+    asset_id = getattr(params, 'asset_id', None)
+    drain = getattr(params, 'drain', None)
+    asset_params = (asset_id, amount)
+    if drain is True:
+        return PayAmount.DRAIN
+    elif amount_sat is not None:
+        return PayAmount.BITCOIN(amount_sat)
+    elif any(asset_params):
+        if not all(asset_params):
+            raise ValueError('Sending an asset requires both `asset_id` and `amount`')
+        return PayAmount.ASSET(asset_id, amount)
+    return None
+
+def parse_receive_amount(params) -> Optional[ReceiveAmount]:
+    amount_sat = getattr(params, 'amount_sat', None)
+    amount = getattr(params, 'amount', None)
+    asset_id = getattr(params, 'asset_id', None)
+    if amount_sat is not None:
+        return ReceiveAmount.BITCOIN(amount_sat)
+    elif asset_id is not None:
+        return ReceiveAmount.ASSET(asset_id, amount)
+    return None
+
+def list_payments(params):
+    """
+    List payments using the Breez SDK.
+
+    This function initializes the Breez SDK and retrieves a list of payments
+    based on the provided parameters. It then prints the results.
+
+    Args:
+        params (argparse.Namespace): Command-line arguments containing:
+            - from_timestamp (int, optional): The start timestamp for filtering payments.
+            - to_timestamp (int, optional): The end timestamp for filtering payments.
+            - offset (int, optional): The number of payments to skip before starting to return results.
+            - limit (int, optional): The maximum number of payments to return.
+
+    Raises:
+        Exception: If any error occurs during the process of listing payments.
+    """
+    sdk = Sdk(params.network, params.debug)
+    try:
+        req = breez_sdk_liquid.ListPaymentsRequest(from_timestamp=params.from_timestamp, 
+                                                   to_timestamp=params.to_timestamp, 
+                                                   offset=params.offset, 
+                                                   limit=params.limit)
+        res = sdk.instance.list_payments(req)
+        print(*res, sep='\n\n')
+    except Exception as error:
+        print(error)
+
+def receive_payment(params):
+    """
+    Handles the process of receiving a payment using the Breez SDK.
+
+    This function performs the following steps:
+    1. Initializes the SDK
+    2. Prepares a receive request to get fee information
+    3. Prompts the user to accept the fees
+    4. If accepted, initiates the receive payment process
+    5. Displays a QR code for the payment destination
+    6. Waits for the payment to be received
+
+    Args:
+        params (argparse.Namespace): Command-line arguments containing:
+            - method (str): The payment method (e.g., 'LIGHTNING', 'BITCOIN_ADDRESS', 'LIQUID_ADDRESS')
+            - amount_sat (int): The amount to receive in satoshis
+            - asset_id (str): The optional id of the asset to receive
+            - amount (float): The optional amount to receive of the asset
+
+    Raises:
+        Exception: If any error occurs during the payment receiving process
+    """
+    sdk = Sdk(params.network, params.debug)
+    try:
+        # Prepare the receive request to get fees
+        receive_amount = parse_receive_amount(params)
+        prepare_req = breez_sdk_liquid.PrepareReceiveRequest(payment_method=getattr(breez_sdk_liquid.PaymentMethod, params.method), amount=receive_amount)
+        prepare_res = sdk.instance.prepare_receive_payment(prepare_req)
+        # Prompt to accept fees
+        accepted = input(f"Fees: {prepare_res.fees_sat} sat. Are the fees acceptable? (y/N)? : ")
+        if accepted in ["Y", "y"]:
+            # Receive payment
+            req = breez_sdk_liquid.ReceivePaymentRequest(prepare_response=prepare_res)
+            res = sdk.instance.receive_payment(req)
+            if res.destination:
+                print_qr(res.destination)
+                print('Waiting for payment:', res.destination)
+                wait_for_payment(sdk, res.destination)
+    except Exception as error:
+        print(error)
+
+def send_payment(params):
+    """
+    Handles the process of sending a payment using the Breez SDK.
+
+    This function performs the following steps:
+    1. Initializes the SDK
+    2. Prepares a send request to get fee information
+    3. Prompts the user to accept the fees
+    4. If accepted, initiates the send payment process
+    5. Waits for the payment to be completed
+
+    Args:
+        params (argparse.Namespace): Command-line arguments containing:
+            - destination (str): The bolt11 or Liquid BIP21 URI/address
+            - amount_sats (int): The amount to send in satoshis
+            - asset_id (str): The optional id of the asset to send
+            - amount (float): The optional amount to send of the asset
+            - drain: Drain all funds when sending
+
+    Raises:
+        Exception: If any error occurs during the payment sending process
+    """
+    sdk = Sdk(params.network, params.debug)
+    try:
+        # Prepare the send request to get fees
+        pay_amount = parse_pay_amount(params)
+        prepare_req = breez_sdk_liquid.PrepareSendRequest(destination=params.destination, amount=pay_amount)
+        prepare_res = sdk.instance.prepare_send_payment(prepare_req)
+        # Prompt to accept fees
+        accepted = input(f"Fees: {prepare_res.fees_sat} sat. Are the fees acceptable? (Y/n)? : ")
+        if accepted == "Y":
+            # Send payment
+            req = breez_sdk_liquid.SendPaymentRequest(prepare_response=prepare_res)
+            res = sdk.instance.send_payment(req)
+            if res.payment.destination:
+                print('Sending payment:', res.payment.destination)
+                wait_for_payment(sdk, res.payment.destination)
+    except Exception as error:
+        print(error)
+
+def print_dim(data):
+    print(Style.DIM)
+    print(data)
+    print(Style.RESET_ALL)
+
+def print_qr(text: str):
+    qr = QRCode(
+        version=1,
+        error_correction=ERROR_CORRECT_L,
+        box_size=10,
+        border=4,
+    )
+    qr.add_data(text)
+    qr.make(fit=True)
+    qr.print_ascii()
+
+def wait_for_payment(sdk: Sdk, destination: str):
+    while True:
+        if sdk.is_paid(destination):
+            break
+        time.sleep(1)
+
+def wait_for_synced(sdk: Sdk):
+    while True:
+        if sdk.is_synced():
+            break
+        time.sleep(1)
+
+def get_info(params):
+    sdk = Sdk(params.network, params.debug)
+    wait_for_synced(sdk)
+    res = sdk.instance.get_info()
+    print(json.dumps(res, default=lambda x: x.__dict__, indent=2))
+
+def main():
+    if len(sys.argv) <= 1:
+        sys.argv.append('--help')
+
+    parser = argparse.ArgumentParser('Pythod SDK Example', description='Simple CLI to receive/send payments')
+    parser.add_argument('-d', '--debug',
+                        default=False,
+                        action='store_true',
+                        help='Output SDK logs')
+    parser.add_argument('-n', '--network',
+                        help='The network the SDK runs on, either "MAINNET" or "TESTNET"',
+                        type=parse_network)
+    subparser = parser.add_subparsers(title='subcommands')
+    # info
+    info_parser = subparser.add_parser('info', help='Get wallet info')
+    info_parser.set_defaults(run=get_info)
+    # list
+    list_parser = subparser.add_parser('list', help='List payments')
+    list_parser.add_argument('-f', '--from_timestamp', 
+                                type=int, 
+                                help='The optional from unix timestamp')
+    list_parser.add_argument('-t', '--to_timestamp', 
+                                type=int, 
+                                help='The optional to unix timestamp')
+    list_parser.add_argument('-o', '--offset', 
+                                type=int, 
+                                help='The optional offset of payments')
+    list_parser.add_argument('-l', '--limit', 
+                                type=int, 
+                                help='The optional limit of listed payments')
+    list_parser.set_defaults(run=list_payments)
+    # receive
+    receive_parser = subparser.add_parser('receive', help='Receive a payment')
+    receive_parser.add_argument('-m', '--method', 
+                                choices=['LIGHTNING', 'BITCOIN_ADDRESS', 'LIQUID_ADDRESS'], 
+                                help='The payment method', 
+                                required=True)
+    receive_parser.add_argument('-a', '--amount_sat', 
+                                type=int, 
+                                help='The optional amount to receive in sats')
+    receive_parser.add_argument('--asset_id', help='The optional id of the asset to receive')
+    receive_parser.add_argument('--amount', type=float, help='The optional amount to receive of the asset')
+    receive_parser.set_defaults(run=receive_payment)
+    # send
+    send_parser = subparser.add_parser('send', help='Send a payment')
+    send_parser.add_argument('-d', '--destination', help='The bolt11 or Liquid BIP21 URI/address', required=True)
+    send_parser.add_argument('-a', '--amount_sat', type=int, help='The optional amount to send in sats')
+    send_parser.add_argument('--asset_id', help='The optional id of the asset to send')
+    send_parser.add_argument('--amount', type=float, help='The optional amount to send of the asset')
+    send_parser.add_argument('--drain', default=False, action='store_true', help='Drain all funds when sending')
+    send_parser.set_defaults(run=send_payment)
+
+    args = parser.parse_args()
+    args.run(args)
+```
+
+
+### End-User fees
+#### Sending Lightning Payments
+
+Sending Lightning payments involves a submarine swap and two Liquid on-chain transactions. The process is as follows:
+
+1.  User broadcasts an L-BTC transaction to a Liquid lockup address.
+2.  Swapper pays the invoice, sending to the recipient, and then gets a preimage.
+3.  Swapper broadcasts an L-BTC transaction to claim the funds from the Liquid lockup address.
+
+The fee a user pays to send a Lightning payment is composed of three parts:
+
+1.  **Lockup Transaction Fee:** ~34 sats (0.1 sat/discount vbyte).
+2.  **Claim Transaction Fee:** ~19 sats (0.1 sat/discount vbyte).
+3.  **Swap Service Fee:** 0.1% fee on the amount sent.
+
+Note: swap service fee is dynamic and can change. Currently, it is 0.1%.
+
+> **Example**: If the user sends 10k sats, the fee would be:
+> 
+> -   34 sats \[Lockup Transaction Fee\] + 19 sats \[Claim Transaction Fee\] + 10 sats \[Swapper Service Fee\] = 63 sats
+
+#### Receiving Lightning Payments
+
+Receiving Lightning payments involves a reverse submarine swap and requires two Liquid on-chain transactions. The process is as follows:
+
+1.  Sender pays the Swapper invoice.
+2.  Swapper broadcasts an L-BTC transaction to a Liquid lockup address.
+3.  SDK claims the funds from the Liquid lockup address and then exposes the preimage.
+4.  Swapper uses the preimage to claim the funds from the Liquid lockup address.
+
+The fee a user pays to receive a Lightning payment is composed of three parts:
+
+1.  **Lockup Transaction Fee:** ~27 sats (0.1 sat/discount vbyte).
+2.  **Claim Transaction Fee:** ~20 sats (0.1 sat/discount vbyte).
+3.  **Swap Service Fee:** 0.25% fee on the amount received.
+
+Note: swap service fee is dynamic and can change. Currently, it is 0.25%.
+
+> **Example**: If the sender sends 10k sats, the fee for the end-user would be:
+> 
+> -   27 sats \[Lockup Transaction Fee\] + 20 sats \[Claim Transaction Fee\] + 25 sats \[Swapper Service Fee\] = 72 sats
+
+#### Sending to a bitcoin address
+
+Sending to a BTC address involves a trustless chain swap, 2 Liquid on-chain transactions, and 2 BTC on-chain transactions. The process is as follows:
+
+1.  SDK broadcasts an L-BTC transaction to a Liquid lockup address.
+2.  Swapper broadcasts a BTC transaction to a Bitcoin lockup address.
+3.  Recipient claims the funds from the Bitcoin lockup address.
+4.  Swapper claims the funds from the Liquid lockup address.
+
+The fee to send to a BTC address is composed of four parts:
+
+1.  **L-BTC Lockup Transaction Fee**: ~34 sats (0.1 sat/discount vbyte).
+2.  **BTC Lockup Transaction Fee**: the swapper charges a mining fee based on the current bitcoin mempool usage.
+3.  **Swap Service Fee:** 0.1% fee on the amount sent.
+4.  **BTC Claim Transaction Fee:** the SDK fees to claim BTC funds to the destination address, based on the current Bitcoin mempool usage.
+
+Note: swap service fee is dynamic and can change. Currently, it is 0.1%.
+
+> **Example**: If the user sends 100k sats, the mining fees returned by the Swapper are 2000 sats, and the claim fees for the user are 1000 sats—the fee would be:
+> 
+> -   34 sats \[Lockup Transaction Fee\] + 2000 sats \[BTC Claim Transaction Fee\] + 100 sats \[Swapper Service Fee\] + 1000 sats \[BTC Lockup Transaction Fee\] = 3132 sats
+
+### Receiving from a BTC Address
+
+Receiving from a BTC address involves a trustless chain swap, 2 Liquid on-chain transactions, and 2 BTC on-chain transactions.
+
+The process is as follows:
+
+1.  Sender broadcasts a BTC transaction to the Bitcoin lockup address.
+2.  Swapper broadcasts an L-BTC transaction to a Liquid lockup address.
+3.  SDK claims the funds from the Liquid lockup address.
+4.  Swapper claims the funds from the Bitcoin lockup address.
+
+The fee to receive from a BTC address is composed of three parts:
+
+1.  **L-BTC Claim Transaction Fee:** ~20 sats (0.1 sat/discount vbyte).
+2.  **BTC Claim Transaction Fee:** the swapper charges a mining fee based on the Bitcoin mempool usage at the time of the swap.
+3.  **Swapper Service Fee:** the swapper charges a 0.1% fee on the amount received.
+
+Note: swapper service see is dynamic and can change. Currently, it is 0.1%.
+
+> **Example**: If the sender sends 100k sats and the mining fees returned by the Swapper are 2000 sats—the fee for the end-user would be:
+> 
+> -   20 sats \[Claim Transaction Fee\] + 100 sats \[Swapper Service Fee\] + 2000 sats \[BTC Claim Transaction Fee\] = 2120 sats
+## Best Practices
+
+### Syncing
+- **Always make sure the sdk instance is synced before performing any actions**
+
+```python 
+def wait_for_synced(sdk: Sdk):
+    while True:
+        if sdk.is_synced():
+            break
+        time.sleep(1)
+
+
+def main():
+    sdk = Sdk(params.network, params.debug)
+    wait_for_synced(sdk)
+    res = sdk.instance.get_info()
+    print(json.dumps({
+        "walletInfo": res.wallet_info.__dict__,
+        "blockchainInfo": res.blockchain_info.__dict__,
+    }, indent=2))
+
+```
+
+### Error Handling
+
+Always wrap your SDK method calls in try-except blocks to properly handle errors:
+
+```python
+try:
+    # Call SDK method
+    result = sdk.some_method()
+    # Process result
+except Exception as error:
+    logging.error(f"An error occurred: {error}")
+    # Handle the error appropriately
+```
+
+### Connection Lifecycle
+
+Manage the connection lifecycle properly:
+
+1. Initialize only once per session
+2. Properly handle events
+3. Disconnect when done
+
+```python
+# Initialize
+sdk = connect(connect_request)
+
+# Use SDK
+# ...
+
+# Disconnect
+try:
+    sdk.disconnect()
+except Exception as error:
+    logging.error(f"Error disconnecting: {error}")
+```
+
+### Fee Handling
+
+Always check fees before executing payments:
+
+```python
+# Get fee information
+prepare_response = sdk.prepare_send_payment(prepare_request)
+fees_sat = prepare_response.fees_sat
+
+# Check if fees are acceptable before proceeding
+if fees_sat <= max_acceptable_fee:
+    # Execute payment
+    sdk.send_payment(SendPaymentRequest(prepare_response=prepare_response))
+else:
+    # Fees are too high
+    logging.warning(f"Fees too high: {fees_sat} sats")
+```
+
+### Event Handling
+
+Implement a robust event listener to handle asynchronous events:
+
+```python
+class MyEventListener(EventListener):
+    def on_event(self, event):
+        if isinstance(event, SdkEvent.SYNCED):
+            logging.info("SDK is synced")
+        elif isinstance(event, SdkEvent.PAYMENT_SUCCEEDED):
+            logging.info(f"Payment succeeded: {event.details.payment_hash}")
+        elif isinstance(event, SdkEvent.PAYMENT_FAILED):
+            logging.error(f"Payment failed: {event.details.error}")
+        # Handle other event types
+```
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Connection Problems**
+   - Check your API key
+   - Verify network selection (MAINNET vs TESTNET)
+   - Confirm working directory permissions
+
+2. **Payment Issues**
+   - Verify amount is within allowed limits
+   - Check fee settings
+   - Ensure destination is valid
+   - Verify sufficient balance
+
+3. **Event Listener Not Triggering**
+   - Confirm listener is registered with `add_event_listener`
+   - Check event type matching in your handler
+   - Add debug logging to trace events
+
+### Debugging
+
+Use the SDK's built-in logging system:
+
+```python
+class DetailedLogListener(Logger):
+    def log(self, log_entry):
+        print(f"[{log_entry.level}] {log_entry.line}")
+
+# Set as logger
+breez_sdk_liquid.set_logger(DetailedLogListener())
+```
+
+## Security Considerations
+
+1. **Protecting Mnemonics**
+   - Never hardcode mnemonics in your code
+   - Store encrypted or in secure storage
+   - Consider using a custom signer for production apps
+
+2. **API Key Security**
+   - Store API keys in environment variables
+   - Don't commit API keys to source control
+   - Use different keys for production and testing
+
+3. **Validating Inputs**
+   - Always validate payment destinations
+   - Check amounts are within reasonable limits
+   - Sanitize and validate all external inputs
+