react-native-nitro-ark 0.0.93 → 0.0.95

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

@@ -324,10 +324,10 @@ JNIEXPORT void JNICALL Java_com_margelo_nitro_nitroark_NitroArkNative_tryClaimLi
   }
 }
 
-JNIEXPORT jobject JNICALL Java_com_margelo_nitro_nitroark_NitroArkNative_peakKeyPair(JNIEnv* env, jobject /*thiz*/,
+JNIEXPORT jobject JNICALL Java_com_margelo_nitro_nitroark_NitroArkNative_peekKeyPair(JNIEnv* env, jobject /*thiz*/,
                                                                                      jint jIndex) {
   try {
-    bark_cxx::KeyPairResult keypair = bark_cxx::peak_keypair(static_cast<uint32_t>(jIndex));
+    bark_cxx::KeyPairResult keypair = bark_cxx::peek_keypair(static_cast<uint32_t>(jIndex));
     return MakeKeyPairResult(env, keypair);
   } catch (const std::exception& e) {
     HandleException(env, e);

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

@@ -92,7 +92,7 @@ object NitroArkNative {
       token: String?
   )
   external fun offboardAll(destinationAddress: String): RoundStatusResult
-  external fun peakKeyPair(index: Int): KeyPairResultAndroid
+  external fun peekKeyPair(index: Int): KeyPairResultAndroid
   external fun verifyMessage(message: String, signature: String, publicKey: String): Boolean
   external fun bolt11Invoice(amountMsat: Long): Bolt11InvoiceResult
   external fun signMessage(message: String, index: Int): String

package/cpp/BarkNotificationSubscription.hpp

@@ -0,0 +1,179 @@
+#pragma once
+
+#include "BarkNotificationEvent.hpp"
+#include "HybridBarkNotificationSubscriptionSpec.hpp"
+#include "generated/ark_cxx.h"
+#include <atomic>
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <stdexcept>
+#include <thread>
+#include <utility>
+
+namespace margelo::nitro::nitroark {
+
+class BarkNotificationSubscription final : public HybridBarkNotificationSubscriptionSpec {
+public:
+  BarkNotificationSubscription(rust::Box<bark_cxx::NotificationSubscription> subscription,
+                               std::function<void(const BarkNotificationEvent&)>&& onEvent)
+      : HybridObject(TAG), subscription_(std::move(subscription)), onEvent_(std::move(onEvent)),
+        worker_([this]() { pumpEvents(); }) {}
+
+  ~BarkNotificationSubscription() override {
+    stopInternal(false);
+  }
+
+  void stop() override {
+    stopInternal(true);
+  }
+
+  bool isActive() override {
+    if (!isActive_.load()) {
+      return false;
+    }
+
+    std::lock_guard<std::mutex> lock(subscriptionMutex_);
+    return subscription_->is_active();
+  }
+
+private:
+  void stopInternal(bool rethrowErrors) {
+    const bool wasActive = isActive_.exchange(false);
+
+    if (wasActive) {
+      try {
+        std::lock_guard<std::mutex> lock(subscriptionMutex_);
+        subscription_->stop();
+      } catch (const std::exception& error) {
+        if (rethrowErrors) {
+          throw std::runtime_error(error.what());
+        }
+      }
+    }
+
+    joinWorker();
+  }
+
+  void joinWorker() {
+    if (!worker_.joinable()) {
+      return;
+    }
+
+    if (worker_.get_id() == std::this_thread::get_id()) {
+      worker_.detach();
+      return;
+    }
+
+    worker_.join();
+  }
+
+  void pumpEvents() {
+    try {
+      while (isActive_.load()) {
+        bark_cxx::NotificationPollResult result;
+        {
+          std::lock_guard<std::mutex> lock(subscriptionMutex_);
+          result = subscription_->wait_next(250);
+        }
+
+        if (!isActive_.load()) {
+          break;
+        }
+
+        if (result.has_event) {
+          onEvent_(convertEvent(result.event));
+        }
+
+        if (!result.is_active) {
+          isActive_.store(false);
+          break;
+        }
+      }
+    } catch (...) {
+      isActive_.store(false);
+    }
+  }
+
+  static BarkMovementDestination convertDestination(const bark_cxx::BarkMovementDestination& destinationRs) {
+    BarkMovementDestination destination;
+    destination.destination =
+        std::string(destinationRs.destination.data(), destinationRs.destination.length());
+    destination.payment_method =
+        std::string(destinationRs.payment_method.data(), destinationRs.payment_method.length());
+    destination.amount_sat = static_cast<double>(destinationRs.amount_sat);
+    return destination;
+  }
+
+  static BarkMovement convertMovement(const bark_cxx::BarkMovement& movementRs) {
+    BarkMovement movement;
+    movement.id = static_cast<double>(movementRs.id);
+    movement.status = std::string(movementRs.status.data(), movementRs.status.length());
+    movement.metadata_json = std::string(movementRs.metadata_json.data(), movementRs.metadata_json.length());
+    movement.intended_balance_sat = static_cast<double>(movementRs.intended_balance_sat);
+    movement.effective_balance_sat = static_cast<double>(movementRs.effective_balance_sat);
+    movement.offchain_fee_sat = static_cast<double>(movementRs.offchain_fee_sat);
+    movement.created_at = std::string(movementRs.created_at.data(), movementRs.created_at.length());
+    movement.updated_at = std::string(movementRs.updated_at.data(), movementRs.updated_at.length());
+
+    if (movementRs.completed_at.length() == 0) {
+      movement.completed_at = std::nullopt;
+    } else {
+      movement.completed_at = std::string(movementRs.completed_at.data(), movementRs.completed_at.length());
+    }
+
+    movement.subsystem.name =
+        std::string(movementRs.subsystem_name.data(), movementRs.subsystem_name.length());
+    movement.subsystem.kind =
+        std::string(movementRs.subsystem_kind.data(), movementRs.subsystem_kind.length());
+
+    movement.sent_to.reserve(movementRs.sent_to.size());
+    for (const auto& destinationRs : movementRs.sent_to) {
+      movement.sent_to.push_back(convertDestination(destinationRs));
+    }
+
+    movement.received_on.reserve(movementRs.received_on.size());
+    for (const auto& destinationRs : movementRs.received_on) {
+      movement.received_on.push_back(convertDestination(destinationRs));
+    }
+
+    movement.input_vtxos.reserve(movementRs.input_vtxos.size());
+    for (const auto& vtxoId : movementRs.input_vtxos) {
+      movement.input_vtxos.emplace_back(std::string(vtxoId.data(), vtxoId.length()));
+    }
+
+    movement.output_vtxos.reserve(movementRs.output_vtxos.size());
+    for (const auto& vtxoId : movementRs.output_vtxos) {
+      movement.output_vtxos.emplace_back(std::string(vtxoId.data(), vtxoId.length()));
+    }
+
+    movement.exited_vtxos.reserve(movementRs.exited_vtxos.size());
+    for (const auto& vtxoId : movementRs.exited_vtxos) {
+      movement.exited_vtxos.emplace_back(std::string(vtxoId.data(), vtxoId.length()));
+    }
+
+    return movement;
+  }
+
+  static BarkNotificationEvent convertEvent(const bark_cxx::NotificationEvent& eventRs) {
+    BarkNotificationEvent event;
+    event.kind = std::string(eventRs.kind.data(), eventRs.kind.length());
+
+    if (eventRs.has_movement) {
+      event.movement = convertMovement(eventRs.movement);
+    } else {
+      event.movement = std::nullopt;
+    }
+
+    return event;
+  }
+
+private:
+  rust::Box<bark_cxx::NotificationSubscription> subscription_;
+  std::function<void(const BarkNotificationEvent&)> onEvent_;
+  std::thread worker_;
+  std::atomic<bool> isActive_{true};
+  std::mutex subscriptionMutex_;
+};
+
+} // namespace margelo::nitro::nitroark

package/cpp/NitroArk.hpp

@@ -1,9 +1,11 @@
 #pragma once
 
+#include "BarkNotificationSubscription.hpp"
 #include "HybridNitroArkSpec.hpp"
 #include "generated/ark_cxx.h"
 #include "generated/cxx.h"
 #include <memory>
+#include <mutex>
 #include <stdexcept>
 #include <string>
 #include <sys/wait.h>
@@ -32,9 +34,92 @@ inline std::vector<BarkVtxo> convertRustVtxosToVector(const rust::Vec<bark_cxx::
   return vtxos;
 }
 
+inline BarkMovementDestination convertRustMovementDestination(const bark_cxx::BarkMovementDestination& destination_rs) {
+  BarkMovementDestination destination;
+  destination.destination = std::string(destination_rs.destination.data(), destination_rs.destination.length());
+  destination.payment_method = std::string(destination_rs.payment_method.data(), destination_rs.payment_method.length());
+  destination.amount_sat = static_cast<double>(destination_rs.amount_sat);
+  return destination;
+}
+
+inline BarkMovement convertRustMovement(const bark_cxx::BarkMovement& movement_rs) {
+  BarkMovement movement;
+  movement.id = static_cast<double>(movement_rs.id);
+  movement.status = std::string(movement_rs.status.data(), movement_rs.status.length());
+  movement.metadata_json = std::string(movement_rs.metadata_json.data(), movement_rs.metadata_json.length());
+  movement.intended_balance_sat = static_cast<double>(movement_rs.intended_balance_sat);
+  movement.effective_balance_sat = static_cast<double>(movement_rs.effective_balance_sat);
+  movement.offchain_fee_sat = static_cast<double>(movement_rs.offchain_fee_sat);
+  movement.created_at = std::string(movement_rs.created_at.data(), movement_rs.created_at.length());
+  movement.updated_at = std::string(movement_rs.updated_at.data(), movement_rs.updated_at.length());
+  if (movement_rs.completed_at.length() == 0) {
+    movement.completed_at = std::nullopt;
+  } else {
+    movement.completed_at = std::string(movement_rs.completed_at.data(), movement_rs.completed_at.length());
+  }
+
+  movement.subsystem.name = std::string(movement_rs.subsystem_name.data(), movement_rs.subsystem_name.length());
+  movement.subsystem.kind = std::string(movement_rs.subsystem_kind.data(), movement_rs.subsystem_kind.length());
+
+  movement.sent_to.reserve(movement_rs.sent_to.size());
+  for (const auto& destination_rs : movement_rs.sent_to) {
+    movement.sent_to.push_back(convertRustMovementDestination(destination_rs));
+  }
+
+  movement.received_on.reserve(movement_rs.received_on.size());
+  for (const auto& destination_rs : movement_rs.received_on) {
+    movement.received_on.push_back(convertRustMovementDestination(destination_rs));
+  }
+
+  movement.input_vtxos.reserve(movement_rs.input_vtxos.size());
+  for (const auto& vtxo_id : movement_rs.input_vtxos) {
+    movement.input_vtxos.emplace_back(std::string(vtxo_id.data(), vtxo_id.length()));
+  }
+
+  movement.output_vtxos.reserve(movement_rs.output_vtxos.size());
+  for (const auto& vtxo_id : movement_rs.output_vtxos) {
+    movement.output_vtxos.emplace_back(std::string(vtxo_id.data(), vtxo_id.length()));
+  }
+
+  movement.exited_vtxos.reserve(movement_rs.exited_vtxos.size());
+  for (const auto& vtxo_id : movement_rs.exited_vtxos) {
+    movement.exited_vtxos.emplace_back(std::string(vtxo_id.data(), vtxo_id.length()));
+  }
+
+  return movement;
+}
+
 class NitroArk : public HybridNitroArkSpec {
 
 private:
+  void trackSubscription(const std::shared_ptr<HybridBarkNotificationSubscriptionSpec>& subscription) {
+    std::lock_guard<std::mutex> lock(subscriptions_mutex_);
+    subscriptions_.push_back(subscription);
+  }
+
+  void stopAllSubscriptions() {
+    std::vector<std::shared_ptr<HybridBarkNotificationSubscriptionSpec>> active_subscriptions;
+    {
+      std::lock_guard<std::mutex> lock(subscriptions_mutex_);
+      auto it = subscriptions_.begin();
+      while (it != subscriptions_.end()) {
+        if (auto subscription = it->lock()) {
+          active_subscriptions.push_back(std::move(subscription));
+          ++it;
+        } else {
+          it = subscriptions_.erase(it);
+        }
+      }
+    }
+
+    for (const auto& subscription : active_subscriptions) {
+      try {
+        subscription->stop();
+      } catch (...) {
+      }
+    }
+  }
+
   // Helper function to create ConfigOpts from BarkConfigOpts
   static bark_cxx::ConfigOpts createConfigOpts(const std::optional<BarkConfigOpts>& config) {
     bark_cxx::ConfigOpts config_opts;
@@ -61,6 +146,10 @@ public:
     bark_cxx::init_logger();
   }
 
+  ~NitroArk() override {
+    stopAllSubscriptions();
+  }
+
   // --- Management ---
 
   std::shared_ptr<Promise<std::string>> createMnemonic() override {
@@ -127,6 +216,8 @@ public:
   }
 
   std::shared_ptr<Promise<void>> closeWallet() override {
+    stopAllSubscriptions();
+
     return Promise<void>::async([]() {
       try {
         bark_cxx::close_wallet();
@@ -249,6 +340,7 @@ public:
         BarkArkInfo info;
         info.network = std::string(rust_info.network.data(), rust_info.network.length());
         info.server_pubkey = std::string(rust_info.server_pubkey.data(), rust_info.server_pubkey.length());
+        info.mailbox_pubkey = std::string(rust_info.mailbox_pubkey.data(), rust_info.mailbox_pubkey.length());
         info.round_interval = static_cast<double>(rust_info.round_interval);
         info.nb_round_nonces = static_cast<double>(rust_info.nb_round_nonces);
         info.vtxo_exit_delta = static_cast<double>(rust_info.vtxo_exit_delta);
@@ -256,6 +348,8 @@ public:
         info.htlc_send_expiry_delta = static_cast<double>(rust_info.htlc_send_expiry_delta);
         info.max_vtxo_amount = static_cast<double>(rust_info.max_vtxo_amount);
         info.required_board_confirmations = static_cast<double>(rust_info.required_board_confirmations);
+        info.min_board_amount = static_cast<double>(rust_info.min_board_amount);
+        info.ln_receive_anti_dos_required = rust_info.ln_receive_anti_dos_required;
         return info;
       } catch (const rust::Error& e) {
         throw std::runtime_error(e.what());
@@ -270,6 +364,7 @@ public:
         OffchainBalanceResult balance;
         balance.spendable = static_cast<double>(rust_balance.spendable);
         balance.pending_lightning_send = static_cast<double>(rust_balance.pending_lightning_send);
+        balance.claimable_lightning_receive = static_cast<double>(rust_balance.claimable_lightning_receive);
         balance.pending_in_round = static_cast<double>(rust_balance.pending_in_round);
         balance.pending_exit = static_cast<double>(rust_balance.pending_exit);
         balance.pending_board = static_cast<double>(rust_balance.pending_board);
@@ -296,11 +391,11 @@ public:
     });
   }
 
-  std::shared_ptr<Promise<KeyPairResult>> peakKeyPair(double index) override {
+  std::shared_ptr<Promise<KeyPairResult>> peekKeyPair(double index) override {
     return Promise<KeyPairResult>::async([index]() {
       try {
         uint32_t index_val = static_cast<uint32_t>(index);
-        bark_cxx::KeyPairResult keypair_rs = bark_cxx::peak_keypair(index_val);
+        bark_cxx::KeyPairResult keypair_rs = bark_cxx::peek_keypair(index_val);
         KeyPairResult keypair;
         keypair.public_key = std::string(keypair_rs.public_key.data(), keypair_rs.public_key.length());
         keypair.secret_key = std::string(keypair_rs.secret_key.data(), keypair_rs.secret_key.length());
@@ -327,10 +422,10 @@ public:
     });
   }
 
-  std::shared_ptr<Promise<NewAddressResult>> peakAddress(double index) override {
+  std::shared_ptr<Promise<NewAddressResult>> peekAddress(double index) override {
     return Promise<NewAddressResult>::async([index]() {
       try {
-        bark_cxx::NewAddressResult address_rs = bark_cxx::peak_address(static_cast<uint32_t>(index));
+        bark_cxx::NewAddressResult address_rs = bark_cxx::peek_address(static_cast<uint32_t>(index));
         NewAddressResult address;
         address.user_pubkey = std::string(address_rs.user_pubkey.data(), address_rs.user_pubkey.length());
         address.ark_id = std::string(address_rs.ark_id.data(), address_rs.ark_id.length());
@@ -395,6 +490,76 @@ public:
     });
   }
 
+  std::shared_ptr<Promise<KeyPairResult>> mailboxKeypair() override {
+    return Promise<KeyPairResult>::async([]() {
+      try {
+        bark_cxx::KeyPairResult keypair_rs = bark_cxx::mailbox_keypair();
+        KeyPairResult keypair;
+        keypair.public_key = std::string(keypair_rs.public_key.data(), keypair_rs.public_key.length());
+        keypair.secret_key = std::string(keypair_rs.secret_key.data(), keypair_rs.secret_key.length());
+        return keypair;
+      } catch (const rust::Error& e) {
+        throw std::runtime_error(e.what());
+      }
+    });
+  }
+
+  std::shared_ptr<Promise<MailboxAuthorizationResult>> mailboxAuthorization(double authorizationExpiry) override {
+    return Promise<MailboxAuthorizationResult>::async([authorizationExpiry]() {
+      try {
+        int64_t expiry_val = static_cast<int64_t>(authorizationExpiry);
+        bark_cxx::MailboxAuthorizationResult auth_rs = bark_cxx::mailbox_authorization(expiry_val);
+        MailboxAuthorizationResult result;
+        result.mailbox_id = std::string(auth_rs.mailbox_id.data(), auth_rs.mailbox_id.length());
+        result.expiry = static_cast<double>(auth_rs.expiry);
+        result.encoded = std::string(auth_rs.encoded.data(), auth_rs.encoded.length());
+        return result;
+      } catch (const rust::Error& e) {
+        throw std::runtime_error(e.what());
+      }
+    });
+  }
+
+  std::shared_ptr<HybridBarkNotificationSubscriptionSpec>
+  subscribeNotifications(const std::function<void(const BarkNotificationEvent&)>& onEvent) override {
+    try {
+      auto subscription = std::make_shared<BarkNotificationSubscription>(
+          bark_cxx::subscribe_notifications(), std::function<void(const BarkNotificationEvent&)>(onEvent));
+      trackSubscription(subscription);
+      return subscription;
+    } catch (const rust::Error& e) {
+      throw std::runtime_error(e.what());
+    }
+  }
+
+  std::shared_ptr<HybridBarkNotificationSubscriptionSpec>
+  subscribeArkoorAddressMovements(const std::string& address,
+                                  const std::function<void(const BarkNotificationEvent&)>& onEvent) override {
+    try {
+      auto subscription = std::make_shared<BarkNotificationSubscription>(
+          bark_cxx::subscribe_arkoor_address_movements(address),
+          std::function<void(const BarkNotificationEvent&)>(onEvent));
+      trackSubscription(subscription);
+      return subscription;
+    } catch (const rust::Error& e) {
+      throw std::runtime_error(e.what());
+    }
+  }
+
+  std::shared_ptr<HybridBarkNotificationSubscriptionSpec>
+  subscribeLightningPaymentMovements(const std::string& paymentHash,
+                                     const std::function<void(const BarkNotificationEvent&)>& onEvent) override {
+    try {
+      auto subscription = std::make_shared<BarkNotificationSubscription>(
+          bark_cxx::subscribe_lightning_payment_movements(paymentHash),
+          std::function<void(const BarkNotificationEvent&)>(onEvent));
+      trackSubscription(subscription);
+      return subscription;
+    } catch (const rust::Error& e) {
+      throw std::runtime_error(e.what());
+    }
+  }
+
   std::shared_ptr<Promise<std::vector<BarkMovement>>> history() override {
     return Promise<std::vector<BarkMovement>>::async([]() {
       try {
@@ -404,58 +569,7 @@ public:
         movements.reserve(movements_rs.size());
 
         for (const auto& movement_rs : movements_rs) {
-          BarkMovement movement;
-          movement.id = static_cast<double>(movement_rs.id);
-          movement.status = std::string(movement_rs.status.data(), movement_rs.status.length());
-          movement.metadata_json = std::string(movement_rs.metadata_json.data(), movement_rs.metadata_json.length());
-          movement.intended_balance_sat = static_cast<double>(movement_rs.intended_balance_sat);
-          movement.effective_balance_sat = static_cast<double>(movement_rs.effective_balance_sat);
-          movement.offchain_fee_sat = static_cast<double>(movement_rs.offchain_fee_sat);
-          movement.created_at = std::string(movement_rs.created_at.data(), movement_rs.created_at.length());
-          movement.updated_at = std::string(movement_rs.updated_at.data(), movement_rs.updated_at.length());
-          if (movement_rs.completed_at.length() == 0) {
-            movement.completed_at = std::nullopt;
-          } else {
-            movement.completed_at = std::string(movement_rs.completed_at.data(), movement_rs.completed_at.length());
-          }
-
-          movement.subsystem.name = std::string(movement_rs.subsystem_name.data(), movement_rs.subsystem_name.length());
-          movement.subsystem.kind = std::string(movement_rs.subsystem_kind.data(), movement_rs.subsystem_kind.length());
-
-          movement.sent_to.reserve(movement_rs.sent_to.size());
-          for (const auto& dest_rs : movement_rs.sent_to) {
-            BarkMovementDestination destination;
-            destination.destination = std::string(dest_rs.destination.data(), dest_rs.destination.length());
-            destination.payment_method = std::string(dest_rs.payment_method.data(), dest_rs.payment_method.length());
-            destination.amount_sat = static_cast<double>(dest_rs.amount_sat);
-            movement.sent_to.push_back(std::move(destination));
-          }
-
-          movement.received_on.reserve(movement_rs.received_on.size());
-          for (const auto& dest_rs : movement_rs.received_on) {
-            BarkMovementDestination destination;
-            destination.destination = std::string(dest_rs.destination.data(), dest_rs.destination.length());
-            destination.payment_method = std::string(dest_rs.payment_method.data(), dest_rs.payment_method.length());
-            destination.amount_sat = static_cast<double>(dest_rs.amount_sat);
-            movement.received_on.push_back(std::move(destination));
-          }
-
-          movement.input_vtxos.reserve(movement_rs.input_vtxos.size());
-          for (const auto& vtxo_id : movement_rs.input_vtxos) {
-            movement.input_vtxos.emplace_back(std::string(vtxo_id.data(), vtxo_id.length()));
-          }
-
-          movement.output_vtxos.reserve(movement_rs.output_vtxos.size());
-          for (const auto& vtxo_id : movement_rs.output_vtxos) {
-            movement.output_vtxos.emplace_back(std::string(vtxo_id.data(), vtxo_id.length()));
-          }
-
-          movement.exited_vtxos.reserve(movement_rs.exited_vtxos.size());
-          for (const auto& vtxo_id : movement_rs.exited_vtxos) {
-            movement.exited_vtxos.emplace_back(std::string(vtxo_id.data(), vtxo_id.length()));
-          }
-
-          movements.push_back(std::move(movement));
+          movements.push_back(convertRustMovement(movement_rs));
         }
 
         return movements;
@@ -957,6 +1071,8 @@ public:
 
 private:
   // Tag for logging/debugging within Nitro
+  std::mutex subscriptions_mutex_;
+  std::vector<std::weak_ptr<HybridBarkNotificationSubscriptionSpec>> subscriptions_;
   static constexpr auto TAG = "NitroArk";
 };