react-native-nitro-ark 0.0.132 → 0.0.133

package/android/src/main/cpp/NitroArkJni.cpp

@@ -2,6 +2,7 @@
 #include <cstdint>
 #include <exception>
 #include <jni.h>
+#include <memory>
 #include <optional>
 #include <stdexcept>
 #include <string>
@@ -226,8 +227,8 @@ JNIEXPORT void JNICALL Java_com_margelo_nitro_nitroark_NitroArkNative_closeWalle
 
 JNIEXPORT void JNICALL Java_com_margelo_nitro_nitroark_NitroArkNative_loadWalletNative(
     JNIEnv* env, jobject /*thiz*/, jstring jDatadir, jstring jMnemonic, jboolean jRegtest, jboolean jSignet,
-    jboolean jBitcoin, jobject jBirthdayHeight, jstring jArk, jstring jServerAccessToken, jstring jEsplora,
-    jstring jBitcoind, jstring jBitcoindCookie, jstring jBitcoindUser, jstring jBitcoindPass,
+    jboolean jBitcoin, jobject jBirthdayHeight, jstring jArk, jstring jUserAgent, jstring jEsplora, jstring jBitcoind,
+    jstring jBitcoindCookie, jstring jBitcoindUser, jstring jBitcoindPass,
     jint jVtxoRefreshExpiryThreshold, jlong jFallbackFeeRate, jobject jHtlcRecvClaimDelta, jobject jVtxoExitMargin,
     jobject jRoundTxRequiredConfirmations) {
   try {
@@ -251,7 +252,7 @@ JNIEXPORT void JNICALL Java_com_margelo_nitro_nitroark_NitroArkNative_loadWallet
 
     bark_cxx::ConfigOpts config{};
     config.ark = JStringToString(env, jArk);
-    config.server_access_token = JStringToString(env, jServerAccessToken);
+    config.user_agent = JStringToString(env, jUserAgent);
     config.esplora = JStringToString(env, jEsplora);
     config.bitcoind = JStringToString(env, jBitcoind);
     config.bitcoind_cookie = JStringToString(env, jBitcoindCookie);
@@ -284,10 +285,10 @@ JNIEXPORT void JNICALL Java_com_margelo_nitro_nitroark_NitroArkNative_loadWallet
   }
 }
 
-JNIEXPORT void JNICALL Java_com_margelo_nitro_nitroark_NitroArkNative_maintenanceDelegated(JNIEnv* env,
-                                                                                           jobject /*thiz*/) {
+JNIEXPORT void JNICALL Java_com_margelo_nitro_nitroark_NitroArkNative_maintenance(JNIEnv* env,
+                                                                                  jobject /*thiz*/) {
   try {
-    bark_cxx::maintenance_delegated();
+    bark_cxx::maintenance();
   } catch (const std::exception& e) {
     HandleException(env, e);
   } catch (...) {
@@ -295,10 +296,10 @@ JNIEXPORT void JNICALL Java_com_margelo_nitro_nitroark_NitroArkNative_maintenanc
   }
 }
 
-JNIEXPORT void JNICALL Java_com_margelo_nitro_nitroark_NitroArkNative_maintenanceWithOnchainDelegated(
-    JNIEnv* env, jobject /*thiz*/) {
+JNIEXPORT void JNICALL Java_com_margelo_nitro_nitroark_NitroArkNative_maintenanceDelegated(JNIEnv* env,
+                                                                                           jobject /*thiz*/) {
   try {
-    bark_cxx::maintenance_with_onchain_delegated();
+    bark_cxx::maintenance_delegated();
   } catch (const std::exception& e) {
     HandleException(env, e);
   } catch (...) {
@@ -307,16 +308,11 @@ JNIEXPORT void JNICALL Java_com_margelo_nitro_nitroark_NitroArkNative_maintenanc
 }
 
 JNIEXPORT void JNICALL Java_com_margelo_nitro_nitroark_NitroArkNative_tryClaimLightningReceive(
-    JNIEnv* env, jobject /*thiz*/, jstring jPaymentHash, jboolean jWait, jstring jToken) {
+    JNIEnv* env, jobject /*thiz*/, jstring jPaymentHash, jboolean jWait) {
   try {
     const std::string payment_hash = JStringToString(env, jPaymentHash);
-    const std::string token_str = JStringToString(env, jToken);
-
     rust::String payment_hash_rs(payment_hash);
-    rust::String token_rs(token_str);
-    const rust::String* token_ptr = token_str.empty() ? nullptr : &token_rs;
-
-    bark_cxx::try_claim_lightning_receive(payment_hash_rs, jWait == JNI_TRUE, token_ptr);
+    bark_cxx::try_claim_lightning_receive(payment_hash_rs, jWait == JNI_TRUE);
   } catch (const std::exception& e) {
     HandleException(env, e);
   } catch (...) {
@@ -359,15 +355,19 @@ JNIEXPORT jboolean JNICALL Java_com_margelo_nitro_nitroark_NitroArkNative_verify
 JNIEXPORT jobject JNICALL Java_com_margelo_nitro_nitroark_NitroArkNative_bolt11InvoiceNative(JNIEnv* env,
                                                                                              jobject /*thiz*/,
                                                                                              jlong jAmountMsat,
-                                                                                             jstring jDescription) {
+                                                                                             jstring jDescription,
+                                                                                             jstring jToken) {
   try {
-    bark_cxx::Bolt11Invoice invoice;
+    std::unique_ptr<rust::String> description;
+    std::unique_ptr<rust::String> token;
     if (jDescription != nullptr) {
-      rust::String description(JStringToString(env, jDescription));
-      invoice = bark_cxx::bolt11_invoice(static_cast<uint64_t>(jAmountMsat), &description);
-    } else {
-      invoice = bark_cxx::bolt11_invoice(static_cast<uint64_t>(jAmountMsat), nullptr);
+      description = std::make_unique<rust::String>(JStringToString(env, jDescription));
+    }
+    if (jToken != nullptr) {
+      token = std::make_unique<rust::String>(JStringToString(env, jToken));
     }
+    const auto invoice =
+        bark_cxx::bolt11_invoice(static_cast<uint64_t>(jAmountMsat), description.get(), token.get());
     return MakeBolt11Invoice(env, invoice);
   } catch (const std::exception& e) {
     HandleException(env, e);

package/android/src/main/java/com/margelo/nitro/nitroark/NitroArkNative.kt

@@ -11,7 +11,7 @@ object NitroArkNative {
       val ark: String,
       val vtxoRefreshExpiryThreshold: Int,
       val fallbackFeeRate: Long,
-      val serverAccessToken: String? = null,
+      val userAgent: String? = null,
       val esplora: String? = null,
       val bitcoind: String? = null,
       val bitcoindCookie: String? = null,
@@ -48,7 +48,7 @@ object NitroArkNative {
         bitcoin,
         birthdayHeight,
         config.ark,
-        config.serverAccessToken,
+        config.userAgent,
         config.esplora,
         config.bitcoind,
         config.bitcoindCookie,
@@ -73,7 +73,7 @@ object NitroArkNative {
       bitcoin: Boolean,
       birthdayHeight: Int?,
       ark: String,
-      serverAccessToken: String?,
+      userAgent: String?,
       esplora: String?,
       bitcoind: String?,
       bitcoindCookie: String?,
@@ -88,19 +88,23 @@ object NitroArkNative {
 
   // Additional helpers
   external fun maintenance()
+  external fun maintenanceDelegated()
   external fun maintenanceRefresh()
   external fun tryClaimLightningReceive(
       paymentHash: String,
-      wait: Boolean,
-      token: String?
+      wait: Boolean
   )
   external fun offboardAll(destinationAddress: String): RoundStatusResult
   external fun peekKeyPair(index: Int): KeyPairResultAndroid
   external fun verifyMessage(message: String, signature: String, publicKey: String): Boolean
-  fun bolt11Invoice(amountMsat: Long, description: String? = null): Bolt11InvoiceResult =
-      bolt11InvoiceNative(amountMsat, description)
+  fun bolt11Invoice(amountMsat: Long, description: String? = null, token: String? = null): Bolt11InvoiceResult =
+      bolt11InvoiceNative(amountMsat, description, token)
 
-  private external fun bolt11InvoiceNative(amountMsat: Long, description: String?): Bolt11InvoiceResult
+  private external fun bolt11InvoiceNative(
+      amountMsat: Long,
+      description: String?,
+      token: String?
+  ): Bolt11InvoiceResult
   external fun signMessage(message: String, index: Int): String
   external fun sync()
 }

package/cpp/NitroArk.hpp

@@ -87,6 +87,32 @@ inline LightningPaymentResult convertRustLightningPaymentResult(const bark_cxx::
   return result;
 }
 
+inline LightningReceive convertRustLightningReceive(const bark_cxx::LightningReceive& rust_result) {
+  LightningReceive result;
+  result.state = std::string(rust_result.state.data(), rust_result.state.length());
+  if (!rust_result.phase.empty()) {
+    result.phase = std::string(rust_result.phase.data(), rust_result.phase.length());
+  }
+  result.payment_hash = std::string(rust_result.payment_hash.data(), rust_result.payment_hash.length());
+  result.payment_preimage =
+      std::string(rust_result.payment_preimage.data(), rust_result.payment_preimage.length());
+  result.invoice = std::string(rust_result.invoice.data(), rust_result.invoice.length());
+  result.htlc_vtxo_ids.reserve(rust_result.htlc_vtxo_ids.size());
+  for (const auto& id : rust_result.htlc_vtxo_ids) {
+    result.htlc_vtxo_ids.emplace_back(std::string(id.data(), id.length()));
+  }
+  if (rust_result.has_movement_id) {
+    result.movement_id = static_cast<double>(rust_result.movement_id);
+  }
+  if (rust_result.has_amount_sat) {
+    result.amount_sat = static_cast<double>(rust_result.amount_sat);
+  }
+  if (rust_result.has_settled_at) {
+    result.settled_at = static_cast<double>(rust_result.settled_at);
+  }
+  return result;
+}
+
 inline ExitBlockRefResult convertRustExitBlockRef(const bark_cxx::ExitBlockRefResult& block_rs) {
   ExitBlockRefResult block;
   block.height = static_cast<double>(block_rs.height);
@@ -342,7 +368,6 @@ private:
     bark_cxx::ConfigOpts config_opts;
     if (config.has_value()) {
       config_opts.ark = config->ark;
-      config_opts.server_access_token = config->server_access_token.value_or("");
       config_opts.user_agent = config->user_agent.value_or("");
       config_opts.esplora = config->esplora.value_or("");
       config_opts.bitcoind = config->bitcoind.value_or("");
@@ -530,16 +555,6 @@ public:
     });
   }
 
-  std::shared_ptr<Promise<void>> maintenanceWithOnchain() override {
-    return Promise<void>::async([]() {
-      try {
-        bark_cxx::maintenance_with_onchain();
-      } catch (const rust::Error& e) {
-        throw std::runtime_error(e.what());
-      }
-    });
-  }
-
   std::shared_ptr<Promise<void>> maintenanceDelegated() override {
     return Promise<void>::async([]() {
       try {
@@ -550,16 +565,6 @@ public:
     });
   }
 
-  std::shared_ptr<Promise<void>> maintenanceWithOnchainDelegated() override {
-    return Promise<void>::async([]() {
-      try {
-        bark_cxx::maintenance_with_onchain_delegated();
-      } catch (const rust::Error& e) {
-        throw std::runtime_error(e.what());
-      }
-    });
-  }
-
   std::shared_ptr<Promise<void>> maintenanceRefresh() override {
     return Promise<void>::async([]() {
       try {
@@ -1109,6 +1114,21 @@ public:
     });
   }
 
+  std::shared_ptr<Promise<void>> unlockVtxos(const std::vector<std::string>& vtxoIds) override {
+    return Promise<void>::async([vtxoIds]() {
+      try {
+        rust::Vec<rust::String> rust_vtxo_ids;
+        rust_vtxo_ids.reserve(vtxoIds.size());
+        for (const auto& vtxoId : vtxoIds) {
+          rust_vtxo_ids.push_back(vtxoId);
+        }
+        bark_cxx::unlock_vtxos(std::move(rust_vtxo_ids));
+      } catch (const rust::Error& e) {
+        throw std::runtime_error(e.what());
+      }
+    });
+  }
+
   std::shared_ptr<Promise<std::vector<BarkVtxo>>> getExpiringVtxos(double threshold) override {
     return Promise<std::vector<BarkVtxo>>::async([threshold]() {
       try {
@@ -1433,16 +1453,20 @@ public:
   }
 
   std::shared_ptr<Promise<Bolt11Invoice>> bolt11Invoice(double amountMsat,
-                                                        const std::optional<std::string>& description) override {
-    return Promise<Bolt11Invoice>::async([amountMsat, description]() {
+                                                        const std::optional<std::string>& description,
+                                                        const std::optional<std::string>& token) override {
+    return Promise<Bolt11Invoice>::async([amountMsat, description, token]() {
       try {
-        bark_cxx::Bolt11Invoice invoice_rs;
+        std::unique_ptr<rust::String> description_rs;
+        std::unique_ptr<rust::String> token_rs;
         if (description.has_value()) {
-          rust::String description_rs(description.value());
-          invoice_rs = bark_cxx::bolt11_invoice(static_cast<uint64_t>(amountMsat), &description_rs);
-        } else {
-          invoice_rs = bark_cxx::bolt11_invoice(static_cast<uint64_t>(amountMsat), nullptr);
+          description_rs = std::make_unique<rust::String>(description.value());
+        }
+        if (token.has_value()) {
+          token_rs = std::make_unique<rust::String>(token.value());
         }
+        const auto invoice_rs = bark_cxx::bolt11_invoice(
+            static_cast<uint64_t>(amountMsat), description_rs.get(), token_rs.get());
         return Bolt11Invoice(std::string(invoice_rs.bolt11_invoice.data(), invoice_rs.bolt11_invoice.length()),
                              std::string(invoice_rs.payment_secret.data(), invoice_rs.payment_secret.length()),
                              std::string(invoice_rs.payment_hash.data(), invoice_rs.payment_hash.length()));
@@ -1453,36 +1477,11 @@ public:
   }
 
   std::shared_ptr<Promise<LightningReceive>>
-  tryClaimLightningReceive(const std::string& paymentHash, bool wait,
-                           const std::optional<std::string>& token) override {
-    return Promise<LightningReceive>::async([paymentHash, wait, token]() -> LightningReceive {
+  tryClaimLightningReceive(const std::string& paymentHash, bool wait) override {
+    return Promise<LightningReceive>::async([paymentHash, wait]() -> LightningReceive {
       try {
-        bark_cxx::LightningReceive result;
-        if (token.has_value()) {
-          rust::String token_rs(token.value());
-          result = bark_cxx::try_claim_lightning_receive(paymentHash, wait, &token_rs);
-        } else {
-          result = bark_cxx::try_claim_lightning_receive(paymentHash, wait, nullptr);
-        }
-
-        LightningReceive lr;
-        lr.payment_hash = std::string(result.payment_hash.data(), result.payment_hash.length());
-        lr.payment_preimage = std::string(result.payment_preimage.data(), result.payment_preimage.length());
-        lr.invoice = std::string(result.invoice.data(), result.invoice.length());
-
-        if (result.preimage_revealed_at != nullptr) {
-          lr.preimage_revealed_at = static_cast<double>(*result.preimage_revealed_at);
-        } else {
-          lr.preimage_revealed_at = std::nullopt;
-        }
-
-        if (result.finished_at != nullptr) {
-          lr.finished_at = static_cast<double>(*result.finished_at);
-        } else {
-          lr.finished_at = std::nullopt;
-        }
-
-        return lr;
+        const auto result = bark_cxx::try_claim_lightning_receive(paymentHash, wait);
+        return convertRustLightningReceive(result);
       } catch (const rust::Error& e) {
         throw std::runtime_error(e.what());
       }
@@ -1499,36 +1498,11 @@ public:
     });
   }
 
-  std::shared_ptr<Promise<std::optional<LightningReceive>>>
+  std::shared_ptr<Promise<LightningReceive>>
   lightningReceiveStatus(const std::string& paymentHash) override {
-    return Promise<std::optional<LightningReceive>>::async([paymentHash]() {
+    return Promise<LightningReceive>::async([paymentHash]() {
       try {
-        const bark_cxx::LightningReceive* status_ptr = bark_cxx::lightning_receive_status(paymentHash);
-
-        if (status_ptr == nullptr) {
-          return std::optional<LightningReceive>();
-        }
-
-        std::unique_ptr<const bark_cxx::LightningReceive> status(status_ptr);
-
-        LightningReceive result;
-        result.payment_hash = std::string(status->payment_hash.data(), status->payment_hash.length());
-        result.payment_preimage = std::string(status->payment_preimage.data(), status->payment_preimage.length());
-        result.invoice = std::string(status->invoice.data(), status->invoice.length());
-
-        if (status->preimage_revealed_at != nullptr) {
-          result.preimage_revealed_at = static_cast<double>(*status->preimage_revealed_at);
-        } else {
-          result.preimage_revealed_at = std::nullopt;
-        }
-
-        if (status->finished_at != nullptr) {
-          result.finished_at = static_cast<double>(*status->finished_at);
-        } else {
-          result.finished_at = std::nullopt;
-        }
-
-        return std::optional<LightningReceive>(result);
+        return convertRustLightningReceive(bark_cxx::lightning_receive_status(paymentHash));
       } catch (const rust::Error& e) {
         throw std::runtime_error(e.what());
       }

package/cpp/generated/ark_cxx.h

@@ -1284,7 +1284,6 @@ struct CxxArkInfo final {
 #define CXXBRIDGE1_STRUCT_bark_cxx$ConfigOpts
 struct ConfigOpts final {
   ::rust::String ark;
-  ::rust::String server_access_token;
   ::rust::String user_agent;
   ::rust::String esplora;
   ::rust::String bitcoind;
@@ -1340,11 +1339,18 @@ enum class RefreshModeType : ::std::uint8_t {
 #ifndef CXXBRIDGE1_STRUCT_bark_cxx$LightningReceive
 #define CXXBRIDGE1_STRUCT_bark_cxx$LightningReceive
 struct LightningReceive final {
+  ::rust::String state;
+  ::rust::String phase;
   ::rust::String payment_hash;
   ::rust::String payment_preimage;
   ::rust::String invoice;
-  ::std::uint64_t const *preimage_revealed_at CXX_DEFAULT_VALUE(nullptr);
-  ::std::uint64_t const *finished_at CXX_DEFAULT_VALUE(nullptr);
+  ::rust::Vec<::rust::String> htlc_vtxo_ids;
+  bool has_movement_id CXX_DEFAULT_VALUE(false);
+  ::std::uint32_t movement_id CXX_DEFAULT_VALUE(0);
+  bool has_amount_sat CXX_DEFAULT_VALUE(false);
+  ::std::uint64_t amount_sat CXX_DEFAULT_VALUE(0);
+  bool has_settled_at CXX_DEFAULT_VALUE(false);
+  ::std::uint64_t settled_at CXX_DEFAULT_VALUE(0);
 
   using IsRelocatable = ::std::true_type;
 };
@@ -1618,6 +1624,8 @@ bool verify_message(::rust::Str message, ::rust::Str signature, ::rust::Str publ
 
 void dangerous_drop_vtxo(::rust::Str vtxo_id);
 
+void unlock_vtxos(::rust::Vec<::rust::String> vtxo_ids);
+
 ::rust::Vec<::bark_cxx::BarkVtxo> get_expiring_vtxos(::std::uint32_t threshold);
 
 ::bark_cxx::DelegatedRoundState refresh_vtxos_delegated(::rust::Vec<::rust::String> vtxo_ids);
@@ -1626,9 +1634,9 @@ void dangerous_drop_vtxo(::rust::Str vtxo_id);
 
 ::std::uint32_t const *get_next_required_refresh_blockheight();
 
-::bark_cxx::Bolt11Invoice bolt11_invoice(::std::uint64_t amount_msat, ::rust::String const *description);
+::bark_cxx::Bolt11Invoice bolt11_invoice(::std::uint64_t amount_msat, ::rust::String const *description, ::rust::String const *token);
 
-::bark_cxx::LightningReceive const *lightning_receive_status(::rust::String payment_hash);
+::bark_cxx::LightningReceive lightning_receive_status(::rust::String payment_hash);
 
 ::bark_cxx::LightningPaymentResult check_lightning_payment(::rust::String payment_hash, bool wait);
 
@@ -1638,10 +1646,6 @@ void maintenance();
 
 void maintenance_delegated();
 
-void maintenance_with_onchain();
-
-void maintenance_with_onchain_delegated();
-
 void maintenance_refresh();
 
 void refresh_server();
@@ -1704,7 +1708,7 @@ bool has_pending_exits();
 
 ::bark_cxx::BarkFeeEstimate estimate_offboard_all(::rust::Str destination_address);
 
-::bark_cxx::LightningReceive try_claim_lightning_receive(::rust::String payment_hash, bool wait, ::rust::String const *token);
+::bark_cxx::LightningReceive try_claim_lightning_receive(::rust::String payment_hash, bool wait);
 
 void try_claim_all_lightning_receives(bool wait);
 

package/lib/module/index.js

@@ -5,37 +5,65 @@ export const NitroArkHybridObject = NitroModules.createHybridObject('NitroArk');
 function enrichExitProgressStatus(result) {
   const {
     state,
+    state_details,
     ...rest
   } = result;
   return {
     ...rest,
-    state: state
+    state: state,
+    state_details: {
+      ...state_details,
+      kind: state_details.kind
+    }
   };
 }
 function enrichExitVtxo(result) {
   const {
     state,
+    state_details,
     history: stateHistory,
+    history_details,
     ...rest
   } = result;
   return {
     ...rest,
     state: state,
-    history: stateHistory
+    state_details: {
+      ...state_details,
+      kind: state_details.kind
+    },
+    history: stateHistory,
+    history_details: history_details.map(details => ({
+      ...details,
+      kind: details.kind
+    }))
   };
 }
 function enrichExitStatus(result) {
   const {
     state,
+    state_details,
     history: stateHistory,
+    history_details,
     ...rest
   } = result;
   return {
     ...rest,
     state: state,
-    history: stateHistory
+    state_details: {
+      ...state_details,
+      kind: state_details.kind
+    },
+    history: stateHistory,
+    history_details: history_details.map(details => ({
+      ...details,
+      kind: details.kind
+    }))
   };
 }
+function enrichLightningReceive(result) {
+  return result;
+}
 
 // --- Management ---
 
@@ -129,42 +157,16 @@ export function syncPendingBoards() {
   return NitroArkHybridObject.syncPendingBoards();
 }
 
-/**
- * Runs wallet maintenance tasks for offchain.
- * This includes refreshing vtxos that need to be refreshed.
- * @returns A promise that resolves on success.
- */
+/** Runs wallet maintenance, including on-chain synchronization and exit progression. */
 export function maintenance() {
   return NitroArkHybridObject.maintenance();
 }
 
-/**
- * Runs wallet maintenance tasks for both offchain and onchain.
- * This includes refreshing vtxos that need to be refreshed.
- * @returns A promise that resolves on success.
- */
-export function maintenanceWithOnchain() {
-  return NitroArkHybridObject.maintenanceWithOnchain();
-}
-
-/**
- * Runs delegated wallet maintenance tasks for offchain.
- * This includes refreshing vtxos that need to be refreshed using delegated signing.
- * @returns A promise that resolves on success.
- */
+/** Runs delegated wallet maintenance, including on-chain synchronization. */
 export function maintenanceDelegated() {
   return NitroArkHybridObject.maintenanceDelegated();
 }
 
-/**
- * Runs delegated wallet maintenance tasks for both offchain and onchain.
- * This includes refreshing vtxos that need to be refreshed using delegated signing.
- * @returns A promise that resolves on success.
- */
-export function maintenanceWithOnchainDelegated() {
-  return NitroArkHybridObject.maintenanceWithOnchainDelegated();
-}
-
 /**
  * Refreshes vtxos that need to be refreshed.
  * @returns A promise that resolves on success.
@@ -501,6 +503,15 @@ export function dangerousDropVtxo(vtxoId) {
   return NitroArkHybridObject.dangerousDropVtxo(vtxoId);
 }
 
+/**
+ * Unlocks locked VTXOs and returns them to the spendable state.
+ * Already-spendable VTXOs are left unchanged. Spent, unknown, or malformed IDs reject the batch.
+ * @param vtxoIds VTXO IDs to unlock.
+ */
+export function unlockVtxos(vtxoIds) {
+  return NitroArkHybridObject.unlockVtxos(vtxoIds);
+}
+
 /**
  * Gets the first expiring VTXO blockheight for the loaded wallet.
  * @returns A promise resolving to the first expiring VTXO blockheight.
@@ -624,8 +635,8 @@ export function onchainSendMany(outputs) {
  * @param description Optional invoice description/memo.
  * @returns A promise resolving to Bolt11Invoice object.
  */
-export function bolt11Invoice(amountMsat, description) {
-  return NitroArkHybridObject.bolt11Invoice(amountMsat, description);
+export function bolt11Invoice(amountMsat, description, token) {
+  return NitroArkHybridObject.bolt11Invoice(amountMsat, description, token);
 }
 
 /**
@@ -634,7 +645,7 @@ export function bolt11Invoice(amountMsat, description) {
  * @returns A promise resolving to the Lightning receive status.
  */
 export function lightningReceiveStatus(paymentHash) {
-  return NitroArkHybridObject.lightningReceiveStatus(paymentHash);
+  return NitroArkHybridObject.lightningReceiveStatus(paymentHash).then(enrichLightningReceive);
 }
 
 /**
@@ -651,14 +662,13 @@ export function checkLightningPayment(paymentHash, wait) {
 }
 
 /**
- * Attempts to claim a Lightning payment, optionally using a claim token.
+ * Attempts to claim a Lightning payment.
  * @param paymentHash The payment hash of the Lightning payment.
  * @param wait Whether to wait for the claim to complete.
- * @param token Optional claim token used when no spendable VTXOs are owned.
- * @returns A promise resolving to the claimed LightningReceive if successful, or null if not.
+ * @returns A promise resolving to the current Lightning receive state.
  */
-export function tryClaimLightningReceive(paymentHash, wait, token) {
-  return NitroArkHybridObject.tryClaimLightningReceive(paymentHash, wait, token);
+export function tryClaimLightningReceive(paymentHash, wait) {
+  return NitroArkHybridObject.tryClaimLightningReceive(paymentHash, wait).then(enrichLightningReceive);
 }
 
 /**