react-native-nitro-ark 0.0.132 → 0.0.134

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

@@ -5,6 +5,9 @@
 #include "HybridNitroArkSpec.hpp"
 #include "generated/ark_cxx.h"
 #include "generated/cxx.h"
+#include <cmath>
+#include <cstdint>
+#include <limits>
 #include <memory>
 #include <mutex>
 #include <optional>
@@ -16,6 +19,19 @@
 namespace margelo::nitro::nitroark {
 
 using namespace margelo::nitro;
+
+inline std::string lightningPaymentOriginMethodToString(LightningPaymentOriginMethod method) {
+  switch (method) {
+    case LightningPaymentOriginMethod::LIGHTNING_ADDRESS:
+      return "lightning-address";
+    case LightningPaymentOriginMethod::LNURL:
+      return "lnurl";
+    case LightningPaymentOriginMethod::CUSTOM:
+      return "custom";
+  }
+  throw std::invalid_argument("Unsupported Lightning payment origin method");
+}
+
 // Helper functions to convert rust vtxos to C++ values
 inline BarkVtxo convertRustVtxo(const bark_cxx::BarkVtxo& vtxo_rs) {
   BarkVtxo vtxo;
@@ -87,6 +103,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 +384,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 +571,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 +581,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 {
@@ -1066,6 +1087,21 @@ public:
     });
   }
 
+  std::shared_ptr<Promise<void>> updateHistoryMetadata(double movementId, const std::string& patchJson) override {
+    return Promise<void>::async([movementId, patchJson]() {
+      if (!std::isfinite(movementId) || std::trunc(movementId) != movementId || movementId < 0 ||
+          movementId > static_cast<double>(std::numeric_limits<uint32_t>::max())) {
+        throw std::invalid_argument("movementId must be a finite unsigned 32-bit integer");
+      }
+
+      try {
+        bark_cxx::update_history_metadata(static_cast<uint32_t>(movementId), patchJson);
+      } catch (const rust::Error& e) {
+        throw std::runtime_error(e.what());
+      }
+    });
+  }
+
   std::shared_ptr<Promise<std::vector<BarkVtxo>>> vtxos() override {
     return Promise<std::vector<BarkVtxo>>::async([]() {
       try {
@@ -1109,6 +1145,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 {
@@ -1375,6 +1426,22 @@ public:
     });
   }
 
+  // Pay an invoice resolved by the caller while preserving the durable,
+  // user-facing origin in Bark instead of storing only the one-time invoice.
+  std::shared_ptr<Promise<LightningPaymentResult>>
+  payLightningInvoiceWithOrigin(const std::string& invoice, const LightningPaymentOrigin& origin, bool wait) override {
+    return Promise<LightningPaymentResult>::async([invoice, origin, wait]() {
+      try {
+        bark_cxx::LightningPaymentResult rust_result = bark_cxx::pay_lightning_invoice_with_origin(
+            invoice, lightningPaymentOriginMethodToString(origin.method), origin.value, wait);
+
+        return convertRustLightningPaymentResult(rust_result);
+      } catch (const rust::Error& e) {
+        throw std::runtime_error(e.what());
+      }
+    });
+  }
+
   std::shared_ptr<Promise<LightningPaymentResult>> payLightningOffer(const std::string& offer, bool wait,
                                                                      std::optional<double> amountSat) override {
     return Promise<LightningPaymentResult>::async([offer, wait, amountSat]() {
@@ -1433,16 +1500,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 +1524,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 +1545,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;
 };
@@ -1612,12 +1618,16 @@ bool verify_message(::rust::Str message, ::rust::Str signature, ::rust::Str publ
 
 ::rust::Vec<::bark_cxx::BarkVtxo> vtxos();
 
+void update_history_metadata(::std::uint32_t movement_id, ::rust::Str patch_json);
+
 ::bark_cxx::BarkVtxo decode_vtxo_hex(::rust::Str vtxo_hex);
 
 ::bark_cxx::BarkVtxo import_vtxo(::rust::Str vtxo_hex);
 
 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 +1636,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 +1648,6 @@ void maintenance();
 
 void maintenance_delegated();
 
-void maintenance_with_onchain();
-
-void maintenance_with_onchain_delegated();
-
 void maintenance_refresh();
 
 void refresh_server();
@@ -1670,6 +1676,8 @@ void validate_arkoor_address(::rust::Str address);
 
 ::bark_cxx::LightningPaymentResult pay_lightning_invoice(::rust::Str destination, ::std::uint64_t const *amount_sat, bool wait);
 
+::bark_cxx::LightningPaymentResult pay_lightning_invoice_with_origin(::rust::Str invoice, ::rust::Str origin_method, ::rust::Str origin_value, bool wait);
+
 ::bark_cxx::LightningPaymentResult pay_lightning_offer(::rust::Str offer, ::std::uint64_t const *amount_sat, bool wait);
 
 ::bark_cxx::LightningPaymentResult pay_lightning_address(::rust::Str addr, ::std::uint64_t amount_sat, ::rust::Str comment, bool wait);
@@ -1704,7 +1712,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);