react-native-nitro-ark 0.0.29 → 0.0.30

package/cpp/NitroArk.hpp

@@ -58,7 +58,8 @@ namespace margelo::nitro::nitroark
                 create_opts.signet = opts.signet.value_or(false);
                 create_opts.bitcoin = opts.bitcoin.value_or(true);
                 create_opts.mnemonic = opts.mnemonic;
-                create_opts.birthday_height = static_cast<uint32_t>(opts.birthday_height.value_or(0));
+                uint32_t birthday_height_val = opts.birthday_height.value_or(0);
+                create_opts.birthday_height = opts.birthday_height.has_value() ? &birthday_height_val : nullptr;
                 create_opts.config = config_opts;
 
                 bark_cxx::load_wallet(datadir, create_opts);
@@ -84,18 +85,110 @@ namespace margelo::nitro::nitroark
                                         { return bark_cxx::is_wallet_loaded(); });
         }
 
+        std::shared_ptr<Promise<void>>
+        persistConfig(const BarkConfigOpts &opts) override
+        {
+            return Promise<void>::async([opts]()
+                                        {
+            try {
+                bark_cxx::ConfigOpts config_opts;
+                config_opts.asp = opts.asp.value_or("");
+                config_opts.esplora = opts.esplora.value_or("");
+                config_opts.bitcoind = opts.bitcoind.value_or("");
+                config_opts.bitcoind_cookie = opts.bitcoind_cookie.value_or("");
+                config_opts.bitcoind_user = opts.bitcoind_user.value_or("");
+                config_opts.bitcoind_pass = opts.bitcoind_pass.value_or("");
+                config_opts.vtxo_refresh_expiry_threshold = static_cast<uint32_t>(opts.vtxo_refresh_expiry_threshold.value_or(0));
+                config_opts.fallback_fee_rate = static_cast<uint64_t>(opts.fallback_fee_rate.value_or(0));
+                bark_cxx::persist_config(config_opts);
+            } catch (const rust::Error &e) {
+                throw std::runtime_error(e.what());
+            } });
+        }
+
+        std::shared_ptr<Promise<void>> maintenance() override
+        {
+            return Promise<void>::async([]()
+                                        {
+            try {
+                bark_cxx::maintenance();
+            } catch (const rust::Error &e) {
+                throw std::runtime_error(e.what());
+            } });
+        }
+
+        std::shared_ptr<Promise<void>> sync() override
+        {
+            return Promise<void>::async([]()
+                                        {
+            try {
+                bark_cxx::sync();
+            } catch (const rust::Error &e) {
+                throw std::runtime_error(e.what());
+            } });
+        }
+
+        std::shared_ptr<Promise<void>> syncArk() override
+        {
+            return Promise<void>::async([]()
+                                        {
+            try {
+                bark_cxx::sync_ark();
+            } catch (const rust::Error &e) {
+                throw std::runtime_error(e.what());
+            } });
+        }
+
+        std::shared_ptr<Promise<void>> syncRounds() override
+        {
+            return Promise<void>::async([]()
+                                        {
+            try {
+                bark_cxx::sync_rounds();
+            } catch (const rust::Error &e) {
+                throw std::runtime_error(e.what());
+            } });
+        }
+
         // --- Wallet Info ---
 
-        std::shared_ptr<Promise<BarkBalance>>
-        getBalance(bool no_sync) override
+        std::shared_ptr<Promise<BarkArkInfo>> getArkInfo() override
         {
-            return Promise<BarkBalance>::async([no_sync]()
+            return Promise<BarkArkInfo>::async([]()
                                                {
             try {
-                bark_cxx::CxxBalance c_balance = bark_cxx::get_balance(no_sync);
-                return BarkBalance{static_cast<double>(c_balance.onchain),
-                                   static_cast<double>(c_balance.offchain),
-                                   static_cast<double>(c_balance.pending_exit)};
+                bark_cxx::CxxArkInfo rust_info = bark_cxx::get_ark_info();
+                BarkArkInfo info;
+                info.network = std::string(rust_info.network.data(), rust_info.network.length());
+                info.asp_pubkey = std::string(rust_info.asp_pubkey.data(), rust_info.asp_pubkey.length());
+                info.round_interval_secs = static_cast<double>(rust_info.round_interval_secs);
+                info.vtxo_exit_delta = static_cast<double>(rust_info.vtxo_exit_delta);
+                info.vtxo_expiry_delta = static_cast<double>(rust_info.vtxo_expiry_delta);
+                info.htlc_expiry_delta = static_cast<double>(rust_info.htlc_expiry_delta);
+                info.max_vtxo_amount_sat = static_cast<double>(rust_info.max_vtxo_amount_sat);
+                return info;
+            } catch (const rust::Error &e) {
+                throw std::runtime_error(e.what());
+            } });
+        }
+
+        std::shared_ptr<Promise<double>> onchainBalance() override
+        {
+            return Promise<double>::async([]()
+                                          {
+            try {
+                return static_cast<double>(bark_cxx::onchain_balance());
+            } catch (const rust::Error &e) {
+                throw std::runtime_error(e.what());
+            } });
+        }
+
+        std::shared_ptr<Promise<double>> offchainBalance() override
+        {
+            return Promise<double>::async([]()
+                                          {
+            try {
+                return static_cast<double>(bark_cxx::offchain_balance());
             } catch (const rust::Error &e) {
                 throw std::runtime_error(e.what());
             } });
@@ -133,8 +226,8 @@ namespace margelo::nitro::nitroark
             return Promise<std::string>::async([index]()
                                                {
             try {
-                uint32_t index_val = index.has_value() ? static_cast<uint32_t>(index.value()) : UINT32_MAX;
-                rust::String pubkey_rs = bark_cxx::get_vtxo_pubkey(index_val);
+                uint32_t index_val = index.has_value() ? static_cast<uint32_t>(index.value()) : 0;
+                rust::String pubkey_rs = bark_cxx::get_vtxo_pubkey(index.has_value() ? &index_val : nullptr);
                 return std::string(pubkey_rs.data(), pubkey_rs.length());
             } catch (const rust::Error &e) {
                 throw std::runtime_error(e.what());
@@ -205,69 +298,39 @@ namespace margelo::nitro::nitroark
             } });
         }
 
-        // --- Ark Operations ---
+        // --- Ark & Lightning Payments ---
 
-        std::shared_ptr<Promise<std::string>>
-        refreshVtxos(const BarkRefreshOpts &refreshOpts, bool no_sync) override
+        std::shared_ptr<Promise<std::string>> boardAmount(double amountSat) override
         {
-            return Promise<std::string>::async([refreshOpts,
-                                                no_sync]()
+            return Promise<std::string>::async([amountSat]()
                                                {
             try {
-                bark_cxx::RefreshOpts opts;
-                switch (refreshOpts.mode_type) {
-                    case BarkRefreshModeType::DEFAULTTHRESHOLD:
-                        opts.mode_type = bark_cxx::RefreshModeType::DefaultThreshold;
-                        break;
-                    case BarkRefreshModeType::THRESHOLDBLOCKS:
-                        opts.mode_type = bark_cxx::RefreshModeType::ThresholdBlocks;
-                        break;
-                    case BarkRefreshModeType::THRESHOLDHOURS:
-                        opts.mode_type = bark_cxx::RefreshModeType::ThresholdHours;
-                        break;
-                    case BarkRefreshModeType::COUNTERPARTY:
-                        opts.mode_type = bark_cxx::RefreshModeType::Counterparty;
-                        break;
-                    case BarkRefreshModeType::ALL:
-                        opts.mode_type = bark_cxx::RefreshModeType::All;
-                        break;
-                    case BarkRefreshModeType::SPECIFIC:
-                        opts.mode_type = bark_cxx::RefreshModeType::Specific;
-                        break;
-                }
-                opts.threshold_value = static_cast<uint32_t>(refreshOpts.threshold_value.value_or(0));
-                if (refreshOpts.specific_vtxo_ids.has_value()) {
-                    for (const auto &id : refreshOpts.specific_vtxo_ids.value()) {
-                        opts.specific_vtxo_ids.push_back(id);
-                    }
-                }
-                rust::String status_rs = bark_cxx::refresh_vtxos(opts, no_sync);
+                rust::String status_rs = bark_cxx::board_amount(static_cast<uint64_t>(amountSat));
                 return std::string(status_rs.data(), status_rs.length());
             } catch (const rust::Error &e) {
                 throw std::runtime_error(e.what());
             } });
         }
 
-        std::shared_ptr<Promise<std::string>> boardAmount(double amountSat,
-                                                          bool no_sync) override
+        std::shared_ptr<Promise<std::string>> boardAll() override
         {
-            return Promise<std::string>::async([amountSat,
-                                                no_sync]()
+            return Promise<std::string>::async([]()
                                                {
             try {
-                rust::String status_rs = bark_cxx::board_amount(static_cast<uint64_t>(amountSat), no_sync);
+                rust::String status_rs = bark_cxx::board_all();
                 return std::string(status_rs.data(), status_rs.length());
             } catch (const rust::Error &e) {
                 throw std::runtime_error(e.what());
             } });
         }
 
-        std::shared_ptr<Promise<std::string>> boardAll(bool no_sync) override
+        std::shared_ptr<Promise<std::string>>
+        sendArkoorPayment(const std::string &destination, double amountSat) override
         {
-            return Promise<std::string>::async([no_sync]()
+            return Promise<std::string>::async([destination, amountSat]()
                                                {
             try {
-                rust::String status_rs = bark_cxx::board_all(no_sync);
+                rust::String status_rs = bark_cxx::send_arkoor_payment(destination, static_cast<uint64_t>(amountSat));
                 return std::string(status_rs.data(), status_rs.length());
             } catch (const rust::Error &e) {
                 throw std::runtime_error(e.what());
@@ -275,21 +338,25 @@ namespace margelo::nitro::nitroark
         }
 
         std::shared_ptr<Promise<std::string>>
-        send(const std::string &destination, std::optional<double> amountSat,
-             const std::optional<std::string> &comment, bool no_sync) override
+        sendBolt11Payment(const std::string &destination, double amountSat) override
         {
-            return Promise<std::string>::async([destination, amountSat, comment, no_sync]()
+            return Promise<std::string>::async([destination, amountSat]()
                                                {
             try {
-                uint64_t amount_val = 0;
-                if (amountSat.has_value()) {
-                    amount_val = static_cast<uint64_t>(amountSat.value());
-                }
-                std::string comment_val = "";
-                if (comment.has_value()) {
-                    comment_val = comment.value();
-                }
-                rust::String status_rs = bark_cxx::send_payment(destination, amount_val, comment_val, no_sync);
+                rust::String status_rs = bark_cxx::send_bolt11_payment(destination, static_cast<uint64_t>(amountSat));
+                return std::string(status_rs.data(), status_rs.length());
+            } catch (const rust::Error &e) {
+                throw std::runtime_error(e.what());
+            } });
+        }
+
+        std::shared_ptr<Promise<std::string>>
+        sendLnaddr(const std::string &addr, double amountSat, const std::string &comment) override
+        {
+            return Promise<std::string>::async([addr, amountSat, comment]()
+                                               {
+            try {
+                rust::String status_rs = bark_cxx::send_lnaddr(addr, static_cast<uint64_t>(amountSat), comment);
                 return std::string(status_rs.data(), status_rs.length());
             } catch (const rust::Error &e) {
                 throw std::runtime_error(e.what());
@@ -315,7 +382,7 @@ namespace margelo::nitro::nitroark
                 });
         }
 
-        // --- Lightning Operations ---
+        // --- Lightning Invoicing ---
 
         std::shared_ptr<Promise<std::string>>
         bolt11Invoice(double amountMsat) override
@@ -346,11 +413,11 @@ namespace margelo::nitro::nitroark
 
         std::shared_ptr<Promise<std::string>>
         offboardSpecific(const std::vector<std::string> &vtxoIds,
-                         const std::optional<std::string> &optionalAddress,
+                         const std::string &destinationAddress,
                          bool no_sync) override
         {
             return Promise<std::string>::async(
-                [vtxoIds, optionalAddress, no_sync]()
+                [vtxoIds, destinationAddress, no_sync]()
                 {
                     try
                     {
@@ -359,8 +426,7 @@ namespace margelo::nitro::nitroark
                         {
                             rust_vtxo_ids.push_back(rust::String(id));
                         }
-                        std::string address = optionalAddress.has_value() ? optionalAddress.value() : "";
-                        rust::String status_rs = bark_cxx::offboard_specific(std::move(rust_vtxo_ids), address, no_sync);
+                        rust::String status_rs = bark_cxx::offboard_specific(std::move(rust_vtxo_ids), destinationAddress, no_sync);
                         return std::string(status_rs.data(), status_rs.length());
                     }
                     catch (const rust::Error &e)
@@ -371,15 +437,14 @@ namespace margelo::nitro::nitroark
         }
 
         std::shared_ptr<Promise<std::string>>
-        offboardAll(const std::optional<std::string> &optionalAddress,
+        offboardAll(const std::string &destinationAddress,
                     bool no_sync) override
         {
-            return Promise<std::string>::async([optionalAddress,
+            return Promise<std::string>::async([destinationAddress,
                                                 no_sync]()
                                                {
             try {
-                std::string address = optionalAddress.has_value() ? optionalAddress.value() : "";
-                rust::String status_rs = bark_cxx::offboard_all(address, no_sync);
+                rust::String status_rs = bark_cxx::offboard_all(destinationAddress, no_sync);
                 return std::string(status_rs.data(), status_rs.length());
             } catch (const rust::Error &e) {
                 throw std::runtime_error(e.what());

package/cpp/generated/ark_cxx.h

@@ -797,25 +797,28 @@ std::size_t align_of() {
 #endif
 
 namespace bark_cxx {
-  struct CxxBalance;
+  struct CxxArkInfo;
   struct ConfigOpts;
   struct CreateOpts;
   struct SendManyOutput;
   enum class RefreshModeType : ::std::uint8_t;
-  struct RefreshOpts;
 }
 
 namespace bark_cxx {
-#ifndef CXXBRIDGE1_STRUCT_bark_cxx$CxxBalance
-#define CXXBRIDGE1_STRUCT_bark_cxx$CxxBalance
-struct CxxBalance final {
-  ::std::uint64_t onchain CXX_DEFAULT_VALUE(0);
-  ::std::uint64_t offchain CXX_DEFAULT_VALUE(0);
-  ::std::uint64_t pending_exit CXX_DEFAULT_VALUE(0);
+#ifndef CXXBRIDGE1_STRUCT_bark_cxx$CxxArkInfo
+#define CXXBRIDGE1_STRUCT_bark_cxx$CxxArkInfo
+struct CxxArkInfo final {
+  ::rust::String network;
+  ::rust::String asp_pubkey;
+  ::std::uint64_t round_interval_secs CXX_DEFAULT_VALUE(0);
+  ::std::uint16_t vtxo_exit_delta CXX_DEFAULT_VALUE(0);
+  ::std::uint16_t vtxo_expiry_delta CXX_DEFAULT_VALUE(0);
+  ::std::uint16_t htlc_expiry_delta CXX_DEFAULT_VALUE(0);
+  ::std::uint64_t max_vtxo_amount_sat CXX_DEFAULT_VALUE(0);
 
   using IsRelocatable = ::std::true_type;
 };
-#endif // CXXBRIDGE1_STRUCT_bark_cxx$CxxBalance
+#endif // CXXBRIDGE1_STRUCT_bark_cxx$CxxArkInfo
 
 #ifndef CXXBRIDGE1_STRUCT_bark_cxx$ConfigOpts
 #define CXXBRIDGE1_STRUCT_bark_cxx$ConfigOpts
@@ -840,7 +843,7 @@ struct CreateOpts final {
   bool signet CXX_DEFAULT_VALUE(false);
   bool bitcoin CXX_DEFAULT_VALUE(false);
   ::rust::String mnemonic;
-  ::std::uint32_t birthday_height CXX_DEFAULT_VALUE(0);
+  ::std::uint32_t const *birthday_height CXX_DEFAULT_VALUE(nullptr);
   ::bark_cxx::ConfigOpts config;
 
   using IsRelocatable = ::std::true_type;
@@ -869,17 +872,6 @@ enum class RefreshModeType : ::std::uint8_t {
 };
 #endif // CXXBRIDGE1_ENUM_bark_cxx$RefreshModeType
 
-#ifndef CXXBRIDGE1_STRUCT_bark_cxx$RefreshOpts
-#define CXXBRIDGE1_STRUCT_bark_cxx$RefreshOpts
-struct RefreshOpts final {
-  ::bark_cxx::RefreshModeType mode_type;
-  ::std::uint32_t threshold_value CXX_DEFAULT_VALUE(0);
-  ::rust::Vec<::rust::String> specific_vtxo_ids;
-
-  using IsRelocatable = ::std::true_type;
-};
-#endif // CXXBRIDGE1_STRUCT_bark_cxx$RefreshOpts
-
 void init_logger() noexcept;
 
 ::rust::String create_mnemonic();
@@ -888,13 +880,19 @@ bool is_wallet_loaded() noexcept;
 
 void close_wallet();
 
+void persist_config(::bark_cxx::ConfigOpts opts);
+
+::bark_cxx::CxxArkInfo get_ark_info();
+
 ::rust::String get_onchain_address();
 
-::bark_cxx::CxxBalance get_balance(bool no_sync);
+::std::uint64_t offchain_balance();
+
+::std::uint64_t onchain_balance();
 
 ::rust::String get_onchain_utxos(bool no_sync);
 
-::rust::String get_vtxo_pubkey(::std::uint32_t index);
+::rust::String get_vtxo_pubkey(::std::uint32_t const *index);
 
 ::rust::String get_vtxos(bool no_sync);
 
@@ -902,6 +900,14 @@ void close_wallet();
 
 void claim_bolt11_payment(::rust::Str bolt11);
 
+void maintenance();
+
+void sync();
+
+void sync_ark();
+
+void sync_rounds();
+
 void load_wallet(::rust::Str datadir, ::bark_cxx::CreateOpts opts);
 
 ::rust::String send_onchain(::rust::Str destination, ::std::uint64_t amount_sat, bool no_sync);
@@ -910,13 +916,15 @@ void load_wallet(::rust::Str datadir, ::bark_cxx::CreateOpts opts);
 
 ::rust::String send_many_onchain(::rust::Vec<::bark_cxx::SendManyOutput> outputs, bool no_sync);
 
-::rust::String refresh_vtxos(::bark_cxx::RefreshOpts opts, bool no_sync);
+::rust::String board_amount(::std::uint64_t amount_sat);
+
+::rust::String board_all();
 
-::rust::String board_amount(::std::uint64_t amount_sat, bool no_sync);
+::rust::String send_arkoor_payment(::rust::Str destination, ::std::uint64_t amount_sat);
 
-::rust::String board_all(bool no_sync);
+::rust::String send_bolt11_payment(::rust::Str destination, ::std::uint64_t amount_sat);
 
-::rust::String send_payment(::rust::Str destination, ::std::uint64_t amount_sat, ::rust::Str comment, bool no_sync);
+::rust::String send_lnaddr(::rust::Str addr, ::std::uint64_t amount_sat, ::rust::Str comment);
 
 ::rust::String send_round_onchain(::rust::Str destination, ::std::uint64_t amount_sat, bool no_sync);
 

package/lib/module/index.js

@@ -41,15 +41,71 @@ export function isWalletLoaded() {
   return NitroArkHybridObject.isWalletLoaded();
 }
 
+/**
+ * Persists wallet configuration.
+ * @param opts The configuration options to persist.
+ * @returns A promise that resolves on success or rejects on error.
+ */
+export function persistConfig(opts) {
+  return NitroArkHybridObject.persistConfig(opts);
+}
+
+/**
+ * Runs wallet maintenance tasks.
+ * @returns A promise that resolves on success.
+ */
+export function maintenance() {
+  return NitroArkHybridObject.maintenance();
+}
+
+/**
+ * Synchronizes the wallet with the blockchain.
+ * @returns A promise that resolves on success.
+ */
+export function sync() {
+  return NitroArkHybridObject.sync();
+}
+
+/**
+ * Synchronizes the Ark-specific parts of the wallet.
+ * @returns A promise that resolves on success.
+ */
+export function syncArk() {
+  return NitroArkHybridObject.syncArk();
+}
+
+/**
+ * Synchronizes the rounds of the wallet.
+ * @returns A promise that resolves on success.
+ */
+export function syncRounds() {
+  return NitroArkHybridObject.syncRounds();
+}
+
 // --- Wallet Info ---
 
 /**
- * Gets the onchain and offchain balances for the loaded wallet.
- * @param no_sync If true, skips synchronization with the blockchain. Defaults to false.
- * @returns A promise resolving to the BarkBalance object.
+ * Gets the Ark-specific information.
+ * @returns A promise resolving to the BarkArkInfo object.
  */
-export function getBalance(no_sync = false) {
-  return NitroArkHybridObject.getBalance(no_sync);
+export function getArkInfo() {
+  return NitroArkHybridObject.getArkInfo();
+}
+
+/**
+ * Gets the onchain balance for the loaded wallet.
+ * @returns A promise resolving to the onchain balance in satoshis.
+ */
+export function onchainBalance() {
+  return NitroArkHybridObject.onchainBalance();
+}
+
+/**
+ * Gets the offchain balance for the loaded wallet.
+ * @returns A promise resolving to the offchain balance in satoshis.
+ */
+export function offchainBalance() {
+  return NitroArkHybridObject.offchainBalance();
 }
 
 /**
@@ -71,7 +127,7 @@ export function getOnchainUtxos(no_sync = false) {
 
 /**
  * Gets the wallet's VTXO public key (hex string).
- * @param index Optional index of the VTXO pubkey to retrieve.
+ * @param index Index of the VTXO pubkey to retrieve. Use u32::MAX for a new one.
  * @returns A promise resolving to the hex-encoded public key string.
  */
 export function getVtxoPubkey(index) {
@@ -143,53 +199,51 @@ export function claimBolt11Payment(bolt11) {
 // --- Ark Operations ---
 
 /**
- * Refreshes VTXOs based on specified criteria for the loaded wallet.
- * @param refreshOpts Options specifying which VTXOs to refresh.
- * @param no_sync If true, skips synchronization with the blockchain. Defaults to false.
+ * Boards a specific amount from the onchain wallet into Ark.
+ * @param amountSat The amount in satoshis to board.
  * @returns A promise resolving to a JSON status string.
  */
-export function refreshVtxos(refreshOpts, no_sync = false) {
-  if (!refreshOpts.mode_type) {
-    return Promise.reject(new Error('refreshVtxos requires refreshOpts.mode_type'));
-  }
-  if (refreshOpts.mode_type === 'Specific' && (!refreshOpts.specific_vtxo_ids || refreshOpts.specific_vtxo_ids.length === 0)) {
-    return Promise.reject(new Error("refreshVtxos with mode_type 'Specific' requires non-empty specific_vtxo_ids array"));
-  }
-  if ((refreshOpts.mode_type === 'ThresholdBlocks' || refreshOpts.mode_type === 'ThresholdHours') && (refreshOpts.threshold_value === undefined || refreshOpts.threshold_value <= 0)) {
-    return Promise.reject(new Error(`refreshVtxos with mode_type '${refreshOpts.mode_type}' requires a positive threshold_value`));
-  }
-  return NitroArkHybridObject.refreshVtxos(refreshOpts, no_sync);
+export function boardAmount(amountSat) {
+  return NitroArkHybridObject.boardAmount(amountSat);
 }
 
 /**
- * Boards a specific amount from the onchain wallet into Ark.
- * @param amountSat The amount in satoshis to board.
- * @param no_sync If true, skips synchronization with the onchain wallet. Defaults to false.
+ * Boards all available funds from the onchain wallet into Ark.
  * @returns A promise resolving to a JSON status string.
  */
-export function boardAmount(amountSat, no_sync = false) {
-  return NitroArkHybridObject.boardAmount(amountSat, no_sync);
+export function boardAll() {
+  return NitroArkHybridObject.boardAll();
 }
 
 /**
- * Boards all available funds from the onchain wallet into Ark.
- * @param no_sync If true, skips synchronization with the onchain wallet. Defaults to false.
- * @returns A promise resolving to a JSON status string.
+ * Sends an Arkoor payment.
+ * @param destination The destination Arkoor address.
+ * @param amountSat The amount in satoshis to send.
+ * @returns A promise resolving to a result string.
  */
-export function boardAll(no_sync = false) {
-  return NitroArkHybridObject.boardAll(no_sync);
+export function sendArkoorPayment(destination, amountSat) {
+  return NitroArkHybridObject.sendArkoorPayment(destination, amountSat);
 }
 
 /**
- * Sends funds offchain using Ark VTXOs.
- * @param destination Ark address (VTXO pubkey) or onchain Bitcoin address.
+ * Sends a Bolt11 payment.
+ * @param destination The Bolt11 invoice.
+ * @param amountSat The amount in satoshis to send. Use 0 for invoice amount.
+ * @returns A promise resolving to a result string.
+ */
+export function sendBolt11Payment(destination, amountSat) {
+  return NitroArkHybridObject.sendBolt11Payment(destination, amountSat);
+}
+
+/**
+ * Sends a payment to a Lightning Address.
+ * @param addr The Lightning Address.
  * @param amountSat The amount in satoshis to send.
- * @param comment Optional comment.
- * @param no_sync If true, skips synchronization with the wallet. Defaults to false.
- * @returns A promise resolving to a JSON status string.
+ * @param comment An optional comment.
+ * @returns A promise resolving to a result string.
  */
-export function send(destination, amountSat, comment = null, no_sync = false) {
-  return NitroArkHybridObject.send(destination, amountSat, comment, no_sync);
+export function sendLnaddr(addr, amountSat, comment) {
+  return NitroArkHybridObject.sendLnaddr(addr, amountSat, comment);
 }
 
 /**
@@ -206,24 +260,24 @@ export function sendRoundOnchain(destination, amountSat, no_sync = false) {
 // --- Offboarding / Exiting ---
 
 /**
- * Offboards specific VTXOs to an optional onchain address.
+ * Offboards specific VTXOs to a destination address.
  * @param vtxoIds Array of VtxoId strings to offboard.
- * @param optionalAddress Optional destination Bitcoin address (null if sending to internal wallet).
+ * @param destinationAddress Destination Bitcoin address (if empty, sends to internal wallet).
  * @param no_sync If true, skips synchronization with the wallet. Defaults to false.
  * @returns A promise resolving to a JSON result string.
  */
-export function offboardSpecific(vtxoIds, optionalAddress = null, no_sync = false) {
-  return NitroArkHybridObject.offboardSpecific(vtxoIds, optionalAddress, no_sync);
+export function offboardSpecific(vtxoIds, destinationAddress, no_sync = false) {
+  return NitroArkHybridObject.offboardSpecific(vtxoIds, destinationAddress, no_sync);
 }
 
 /**
- * Offboards all VTXOs to an optional onchain address.
- * @param optionalAddress Optional destination Bitcoin address (null if sending to internal wallet).
+ * Offboards all VTXOs to a destination address.
+ * @param destinationAddress Destination Bitcoin address (if empty, sends to internal wallet).
  * @param no_sync If true, skips synchronization with the wallet. Defaults to false.
  * @returns A promise resolving to a JSON result string.
  */
-export function offboardAll(optionalAddress = null, no_sync = false) {
-  return NitroArkHybridObject.offboardAll(optionalAddress, no_sync);
+export function offboardAll(destinationAddress, no_sync = false) {
+  return NitroArkHybridObject.offboardAll(destinationAddress, no_sync);
 }
 
 /**
@@ -231,7 +285,7 @@ export function offboardAll(optionalAddress = null, no_sync = false) {
  * @param vtxoIds Array of VtxoId strings to start exiting.
  * @returns A promise resolving to a JSON status string.
  */
-export function exitStartSpecific(vtxoIds) {
+export function startExitForVtxos(vtxoIds) {
   return NitroArkHybridObject.exitStartSpecific(vtxoIds);
 }
 
@@ -239,7 +293,7 @@ export function exitStartSpecific(vtxoIds) {
  * Starts the exit process for all VTXOs in the wallet.
  * @returns A promise resolving to a JSON status string.
  */
-export function exitStartAll() {
+export function startExitForEntireWallet() {
   return NitroArkHybridObject.exitStartAll();
 }