react-native-nitro-ark 0.0.37 → 0.0.39

package/nitrogen/generated/shared/c++/HybridNitroArkSpec.cpp

@@ -16,36 +16,36 @@ namespace margelo::nitro::nitroark {
     registerHybrids(this, [](Prototype& prototype) {
       prototype.registerHybridMethod("createMnemonic", &HybridNitroArkSpec::createMnemonic);
       prototype.registerHybridMethod("loadWallet", &HybridNitroArkSpec::loadWallet);
-      prototype.registerHybridMethod("closeWallet", &HybridNitroArkSpec::closeWallet);
       prototype.registerHybridMethod("isWalletLoaded", &HybridNitroArkSpec::isWalletLoaded);
+      prototype.registerHybridMethod("closeWallet", &HybridNitroArkSpec::closeWallet);
       prototype.registerHybridMethod("persistConfig", &HybridNitroArkSpec::persistConfig);
       prototype.registerHybridMethod("maintenance", &HybridNitroArkSpec::maintenance);
       prototype.registerHybridMethod("sync", &HybridNitroArkSpec::sync);
-      prototype.registerHybridMethod("syncArk", &HybridNitroArkSpec::syncArk);
+      prototype.registerHybridMethod("syncExits", &HybridNitroArkSpec::syncExits);
       prototype.registerHybridMethod("syncRounds", &HybridNitroArkSpec::syncRounds);
       prototype.registerHybridMethod("getArkInfo", &HybridNitroArkSpec::getArkInfo);
-      prototype.registerHybridMethod("onchainBalance", &HybridNitroArkSpec::onchainBalance);
       prototype.registerHybridMethod("offchainBalance", &HybridNitroArkSpec::offchainBalance);
-      prototype.registerHybridMethod("getOnchainAddress", &HybridNitroArkSpec::getOnchainAddress);
-      prototype.registerHybridMethod("getOnchainUtxos", &HybridNitroArkSpec::getOnchainUtxos);
-      prototype.registerHybridMethod("getVtxoPubkey", &HybridNitroArkSpec::getVtxoPubkey);
+      prototype.registerHybridMethod("deriveStoreNextKeypair", &HybridNitroArkSpec::deriveStoreNextKeypair);
+      prototype.registerHybridMethod("peakKeyPair", &HybridNitroArkSpec::peakKeyPair);
       prototype.registerHybridMethod("getVtxos", &HybridNitroArkSpec::getVtxos);
-      prototype.registerHybridMethod("sendOnchain", &HybridNitroArkSpec::sendOnchain);
-      prototype.registerHybridMethod("drainOnchain", &HybridNitroArkSpec::drainOnchain);
-      prototype.registerHybridMethod("sendManyOnchain", &HybridNitroArkSpec::sendManyOnchain);
+      prototype.registerHybridMethod("onchainBalance", &HybridNitroArkSpec::onchainBalance);
+      prototype.registerHybridMethod("onchainSync", &HybridNitroArkSpec::onchainSync);
+      prototype.registerHybridMethod("onchainListUnspent", &HybridNitroArkSpec::onchainListUnspent);
+      prototype.registerHybridMethod("onchainUtxos", &HybridNitroArkSpec::onchainUtxos);
+      prototype.registerHybridMethod("onchainAddress", &HybridNitroArkSpec::onchainAddress);
+      prototype.registerHybridMethod("onchainSend", &HybridNitroArkSpec::onchainSend);
+      prototype.registerHybridMethod("onchainDrain", &HybridNitroArkSpec::onchainDrain);
+      prototype.registerHybridMethod("onchainSendMany", &HybridNitroArkSpec::onchainSendMany);
       prototype.registerHybridMethod("boardAmount", &HybridNitroArkSpec::boardAmount);
       prototype.registerHybridMethod("boardAll", &HybridNitroArkSpec::boardAll);
       prototype.registerHybridMethod("sendArkoorPayment", &HybridNitroArkSpec::sendArkoorPayment);
-      prototype.registerHybridMethod("sendBolt11Payment", &HybridNitroArkSpec::sendBolt11Payment);
+      prototype.registerHybridMethod("sendLightningPayment", &HybridNitroArkSpec::sendLightningPayment);
       prototype.registerHybridMethod("sendLnaddr", &HybridNitroArkSpec::sendLnaddr);
-      prototype.registerHybridMethod("sendRoundOnchain", &HybridNitroArkSpec::sendRoundOnchain);
+      prototype.registerHybridMethod("sendRoundOnchainPayment", &HybridNitroArkSpec::sendRoundOnchainPayment);
       prototype.registerHybridMethod("bolt11Invoice", &HybridNitroArkSpec::bolt11Invoice);
-      prototype.registerHybridMethod("claimBolt11Payment", &HybridNitroArkSpec::claimBolt11Payment);
+      prototype.registerHybridMethod("finishLightningReceive", &HybridNitroArkSpec::finishLightningReceive);
       prototype.registerHybridMethod("offboardSpecific", &HybridNitroArkSpec::offboardSpecific);
       prototype.registerHybridMethod("offboardAll", &HybridNitroArkSpec::offboardAll);
-      prototype.registerHybridMethod("exitStartSpecific", &HybridNitroArkSpec::exitStartSpecific);
-      prototype.registerHybridMethod("exitStartAll", &HybridNitroArkSpec::exitStartAll);
-      prototype.registerHybridMethod("exitProgressOnce", &HybridNitroArkSpec::exitProgressOnce);
     });
   }
 

package/nitrogen/generated/shared/c++/HybridNitroArkSpec.hpp

@@ -19,14 +19,20 @@ namespace margelo::nitro::nitroark { struct BarkCreateOpts; }
 namespace margelo::nitro::nitroark { struct BarkConfigOpts; }
 // Forward declaration of `BarkArkInfo` to properly resolve imports.
 namespace margelo::nitro::nitroark { struct BarkArkInfo; }
+// Forward declaration of `OffchainBalanceResult` to properly resolve imports.
+namespace margelo::nitro::nitroark { struct OffchainBalanceResult; }
+// Forward declaration of `BarkVtxo` to properly resolve imports.
+namespace margelo::nitro::nitroark { struct BarkVtxo; }
+// Forward declaration of `OnchainBalanceResult` to properly resolve imports.
+namespace margelo::nitro::nitroark { struct OnchainBalanceResult; }
 // Forward declaration of `OnchainPaymentResult` to properly resolve imports.
 namespace margelo::nitro::nitroark { struct OnchainPaymentResult; }
 // Forward declaration of `BarkSendManyOutput` to properly resolve imports.
 namespace margelo::nitro::nitroark { struct BarkSendManyOutput; }
 // Forward declaration of `ArkoorPaymentResult` to properly resolve imports.
 namespace margelo::nitro::nitroark { struct ArkoorPaymentResult; }
-// Forward declaration of `Bolt11PaymentResult` to properly resolve imports.
-namespace margelo::nitro::nitroark { struct Bolt11PaymentResult; }
+// Forward declaration of `LightningPaymentResult` to properly resolve imports.
+namespace margelo::nitro::nitroark { struct LightningPaymentResult; }
 // Forward declaration of `LnurlPaymentResult` to properly resolve imports.
 namespace margelo::nitro::nitroark { struct LnurlPaymentResult; }
 
@@ -35,12 +41,15 @@ namespace margelo::nitro::nitroark { struct LnurlPaymentResult; }
 #include "BarkCreateOpts.hpp"
 #include "BarkConfigOpts.hpp"
 #include "BarkArkInfo.hpp"
-#include <optional>
-#include "OnchainPaymentResult.hpp"
+#include "OffchainBalanceResult.hpp"
 #include <vector>
+#include "BarkVtxo.hpp"
+#include "OnchainBalanceResult.hpp"
+#include "OnchainPaymentResult.hpp"
+#include <optional>
 #include "BarkSendManyOutput.hpp"
 #include "ArkoorPaymentResult.hpp"
-#include "Bolt11PaymentResult.hpp"
+#include "LightningPaymentResult.hpp"
 #include "LnurlPaymentResult.hpp"
 
 namespace margelo::nitro::nitroark {
@@ -76,36 +85,36 @@ namespace margelo::nitro::nitroark {
       // Methods
       virtual std::shared_ptr<Promise<std::string>> createMnemonic() = 0;
       virtual std::shared_ptr<Promise<void>> loadWallet(const std::string& datadir, const BarkCreateOpts& opts) = 0;
-      virtual std::shared_ptr<Promise<void>> closeWallet() = 0;
       virtual std::shared_ptr<Promise<bool>> isWalletLoaded() = 0;
+      virtual std::shared_ptr<Promise<void>> closeWallet() = 0;
       virtual std::shared_ptr<Promise<void>> persistConfig(const BarkConfigOpts& opts) = 0;
       virtual std::shared_ptr<Promise<void>> maintenance() = 0;
       virtual std::shared_ptr<Promise<void>> sync() = 0;
-      virtual std::shared_ptr<Promise<void>> syncArk() = 0;
+      virtual std::shared_ptr<Promise<void>> syncExits() = 0;
       virtual std::shared_ptr<Promise<void>> syncRounds() = 0;
       virtual std::shared_ptr<Promise<BarkArkInfo>> getArkInfo() = 0;
-      virtual std::shared_ptr<Promise<double>> onchainBalance() = 0;
-      virtual std::shared_ptr<Promise<double>> offchainBalance() = 0;
-      virtual std::shared_ptr<Promise<std::string>> getOnchainAddress() = 0;
-      virtual std::shared_ptr<Promise<std::string>> getOnchainUtxos(bool no_sync) = 0;
-      virtual std::shared_ptr<Promise<std::string>> getVtxoPubkey(std::optional<double> index) = 0;
-      virtual std::shared_ptr<Promise<std::string>> getVtxos(bool no_sync) = 0;
-      virtual std::shared_ptr<Promise<OnchainPaymentResult>> sendOnchain(const std::string& destination, double amountSat) = 0;
-      virtual std::shared_ptr<Promise<std::string>> drainOnchain(const std::string& destination, bool no_sync) = 0;
-      virtual std::shared_ptr<Promise<std::string>> sendManyOnchain(const std::vector<BarkSendManyOutput>& outputs, bool no_sync) = 0;
+      virtual std::shared_ptr<Promise<OffchainBalanceResult>> offchainBalance() = 0;
+      virtual std::shared_ptr<Promise<std::string>> deriveStoreNextKeypair() = 0;
+      virtual std::shared_ptr<Promise<std::string>> peakKeyPair(double index) = 0;
+      virtual std::shared_ptr<Promise<std::vector<BarkVtxo>>> getVtxos() = 0;
+      virtual std::shared_ptr<Promise<OnchainBalanceResult>> onchainBalance() = 0;
+      virtual std::shared_ptr<Promise<void>> onchainSync() = 0;
+      virtual std::shared_ptr<Promise<std::string>> onchainListUnspent() = 0;
+      virtual std::shared_ptr<Promise<std::string>> onchainUtxos() = 0;
+      virtual std::shared_ptr<Promise<std::string>> onchainAddress() = 0;
+      virtual std::shared_ptr<Promise<OnchainPaymentResult>> onchainSend(const std::string& destination, double amountSat, std::optional<double> feeRate) = 0;
+      virtual std::shared_ptr<Promise<std::string>> onchainDrain(const std::string& destination, std::optional<double> feeRate) = 0;
+      virtual std::shared_ptr<Promise<std::string>> onchainSendMany(const std::vector<BarkSendManyOutput>& outputs, std::optional<double> feeRate) = 0;
       virtual std::shared_ptr<Promise<std::string>> boardAmount(double amountSat) = 0;
       virtual std::shared_ptr<Promise<std::string>> boardAll() = 0;
       virtual std::shared_ptr<Promise<ArkoorPaymentResult>> sendArkoorPayment(const std::string& destination, double amountSat) = 0;
-      virtual std::shared_ptr<Promise<Bolt11PaymentResult>> sendBolt11Payment(const std::string& destination, std::optional<double> amountSat) = 0;
+      virtual std::shared_ptr<Promise<LightningPaymentResult>> sendLightningPayment(const std::string& destination, std::optional<double> amountSat) = 0;
       virtual std::shared_ptr<Promise<LnurlPaymentResult>> sendLnaddr(const std::string& addr, double amountSat, const std::string& comment) = 0;
-      virtual std::shared_ptr<Promise<std::string>> sendRoundOnchain(const std::string& destination, double amountSat, bool no_sync) = 0;
+      virtual std::shared_ptr<Promise<std::string>> sendRoundOnchainPayment(const std::string& destination, double amountSat) = 0;
       virtual std::shared_ptr<Promise<std::string>> bolt11Invoice(double amountMsat) = 0;
-      virtual std::shared_ptr<Promise<void>> claimBolt11Payment(const std::string& bolt11) = 0;
+      virtual std::shared_ptr<Promise<void>> finishLightningReceive(const std::string& bolt11) = 0;
       virtual std::shared_ptr<Promise<std::string>> offboardSpecific(const std::vector<std::string>& vtxoIds, const std::string& destinationAddress) = 0;
       virtual std::shared_ptr<Promise<std::string>> offboardAll(const std::string& destinationAddress) = 0;
-      virtual std::shared_ptr<Promise<std::string>> exitStartSpecific(const std::vector<std::string>& vtxoIds) = 0;
-      virtual std::shared_ptr<Promise<std::string>> exitStartAll() = 0;
-      virtual std::shared_ptr<Promise<std::string>> exitProgressOnce() = 0;
 
     protected:
       // Hybrid Setup

package/nitrogen/generated/shared/c++/{Bolt11PaymentResult.hpp → LightningPaymentResult.hpp}

@@ -1,5 +1,5 @@
 ///
-/// Bolt11PaymentResult.hpp
+/// LightningPaymentResult.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © 2025 Marc Rousavy @ Margelo
@@ -27,17 +27,17 @@ namespace margelo::nitro::nitroark { enum class PaymentTypes; }
 namespace margelo::nitro::nitroark {
 
   /**
-   * A struct which can be represented as a JavaScript object (Bolt11PaymentResult).
+   * A struct which can be represented as a JavaScript object (LightningPaymentResult).
    */
-  struct Bolt11PaymentResult {
+  struct LightningPaymentResult {
   public:
     std::string bolt11_invoice     SWIFT_PRIVATE;
     std::string preimage     SWIFT_PRIVATE;
     PaymentTypes payment_type     SWIFT_PRIVATE;
 
   public:
-    Bolt11PaymentResult() = default;
-    explicit Bolt11PaymentResult(std::string bolt11_invoice, std::string preimage, PaymentTypes payment_type): bolt11_invoice(bolt11_invoice), preimage(preimage), payment_type(payment_type) {}
+    LightningPaymentResult() = default;
+    explicit LightningPaymentResult(std::string bolt11_invoice, std::string preimage, PaymentTypes payment_type): bolt11_invoice(bolt11_invoice), preimage(preimage), payment_type(payment_type) {}
   };
 
 } // namespace margelo::nitro::nitroark
@@ -46,18 +46,18 @@ namespace margelo::nitro {
 
   using namespace margelo::nitro::nitroark;
 
-  // C++ Bolt11PaymentResult <> JS Bolt11PaymentResult (object)
+  // C++ LightningPaymentResult <> JS LightningPaymentResult (object)
   template <>
-  struct JSIConverter<Bolt11PaymentResult> final {
-    static inline Bolt11PaymentResult fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+  struct JSIConverter<LightningPaymentResult> final {
+    static inline LightningPaymentResult fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       jsi::Object obj = arg.asObject(runtime);
-      return Bolt11PaymentResult(
+      return LightningPaymentResult(
         JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "bolt11_invoice")),
         JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "preimage")),
         JSIConverter<PaymentTypes>::fromJSI(runtime, obj.getProperty(runtime, "payment_type"))
       );
     }
-    static inline jsi::Value toJSI(jsi::Runtime& runtime, const Bolt11PaymentResult& arg) {
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const LightningPaymentResult& arg) {
       jsi::Object obj(runtime);
       obj.setProperty(runtime, "bolt11_invoice", JSIConverter<std::string>::toJSI(runtime, arg.bolt11_invoice));
       obj.setProperty(runtime, "preimage", JSIConverter<std::string>::toJSI(runtime, arg.preimage));

package/nitrogen/generated/shared/c++/OffchainBalanceResult.hpp

@@ -0,0 +1,77 @@
+///
+/// OffchainBalanceResult.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+
+
+namespace margelo::nitro::nitroark {
+
+  /**
+   * A struct which can be represented as a JavaScript object (OffchainBalanceResult).
+   */
+  struct OffchainBalanceResult {
+  public:
+    double spendable     SWIFT_PRIVATE;
+    double pending_lightning_send     SWIFT_PRIVATE;
+    double pending_exit     SWIFT_PRIVATE;
+
+  public:
+    OffchainBalanceResult() = default;
+    explicit OffchainBalanceResult(double spendable, double pending_lightning_send, double pending_exit): spendable(spendable), pending_lightning_send(pending_lightning_send), pending_exit(pending_exit) {}
+  };
+
+} // namespace margelo::nitro::nitroark
+
+namespace margelo::nitro {
+
+  using namespace margelo::nitro::nitroark;
+
+  // C++ OffchainBalanceResult <> JS OffchainBalanceResult (object)
+  template <>
+  struct JSIConverter<OffchainBalanceResult> final {
+    static inline OffchainBalanceResult fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return OffchainBalanceResult(
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, "spendable")),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, "pending_lightning_send")),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, "pending_exit"))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const OffchainBalanceResult& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, "spendable", JSIConverter<double>::toJSI(runtime, arg.spendable));
+      obj.setProperty(runtime, "pending_lightning_send", JSIConverter<double>::toJSI(runtime, arg.pending_lightning_send));
+      obj.setProperty(runtime, "pending_exit", JSIConverter<double>::toJSI(runtime, arg.pending_exit));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, "spendable"))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, "pending_lightning_send"))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, "pending_exit"))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/nitrogen/generated/shared/c++/OnchainBalanceResult.hpp

@@ -0,0 +1,81 @@
+///
+/// OnchainBalanceResult.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+
+
+namespace margelo::nitro::nitroark {
+
+  /**
+   * A struct which can be represented as a JavaScript object (OnchainBalanceResult).
+   */
+  struct OnchainBalanceResult {
+  public:
+    double immature     SWIFT_PRIVATE;
+    double trusted_pending     SWIFT_PRIVATE;
+    double untrusted_pending     SWIFT_PRIVATE;
+    double confirmed     SWIFT_PRIVATE;
+
+  public:
+    OnchainBalanceResult() = default;
+    explicit OnchainBalanceResult(double immature, double trusted_pending, double untrusted_pending, double confirmed): immature(immature), trusted_pending(trusted_pending), untrusted_pending(untrusted_pending), confirmed(confirmed) {}
+  };
+
+} // namespace margelo::nitro::nitroark
+
+namespace margelo::nitro {
+
+  using namespace margelo::nitro::nitroark;
+
+  // C++ OnchainBalanceResult <> JS OnchainBalanceResult (object)
+  template <>
+  struct JSIConverter<OnchainBalanceResult> final {
+    static inline OnchainBalanceResult fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return OnchainBalanceResult(
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, "immature")),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, "trusted_pending")),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, "untrusted_pending")),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, "confirmed"))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const OnchainBalanceResult& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, "immature", JSIConverter<double>::toJSI(runtime, arg.immature));
+      obj.setProperty(runtime, "trusted_pending", JSIConverter<double>::toJSI(runtime, arg.trusted_pending));
+      obj.setProperty(runtime, "untrusted_pending", JSIConverter<double>::toJSI(runtime, arg.untrusted_pending));
+      obj.setProperty(runtime, "confirmed", JSIConverter<double>::toJSI(runtime, arg.confirmed));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, "immature"))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, "trusted_pending"))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, "untrusted_pending"))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, "confirmed"))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "react-native-nitro-ark",
-  "version": "0.0.37",
+  "version": "0.0.39",
   "description": "Pure C++ Nitro Modules for Ark client",
   "source": "./src/index.tsx",
   "main": "./lib/module/index.js",
   "module": "./lib/module/index.js",
   "exports": {
     ".": {
+      "source": "./src/index.tsx",
       "types": "./lib/typescript/src/index.d.ts",
       "default": "./lib/module/index.js"
     },
@@ -45,18 +46,23 @@
   "keywords": [
     "react-native",
     "ios",
-    "android"
+    "android",
+    "nitro-modules",
+    "ark",
+    "bitcoin",
+    "arkoor",
+    "bitcoin-layer2"
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/niteshbalusu11/react-native-nitro-ark.git"
+    "url": "git+https://github.com/BlixtWallet/react-native-nitro-ark.git"
   },
   "author": "Nitesh Balusu <niteshbalusu@icloud.com> (https://github.com/niteshbalusu11)",
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/niteshbalusu11/react-native-nitro-ark/issues"
+    "url": "https://github.com/BlixtWallet/react-native-nitro-ark/issues"
   },
-  "homepage": "https://github.com/niteshbalusu11/react-native-nitro-ark#readme",
+  "homepage": "https://github.com/BlixtWallet/react-native-nitro-ark#readme",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
   },
@@ -76,12 +82,12 @@
     "eslint-config-prettier": "^10.1.1",
     "eslint-plugin-prettier": "^5.2.3",
     "jest": "^29.7.0",
-    "nitro-codegen": "^0.26.2",
+    "nitro-codegen": "^0.26.4",
     "prettier": "^3.0.3",
     "react": "19.0.0",
-    "react-native": "0.79.3",
-    "react-native-builder-bob": "^0.40.12",
-    "react-native-nitro-modules": "^0.26.2",
+    "react-native": "0.79.5",
+    "react-native-builder-bob": "^0.40.13",
+    "react-native-nitro-modules": "^0.26.4",
     "release-it": "^17.10.0",
     "turbo": "^1.10.7",
     "typescript": "^5.2.2"
@@ -89,7 +95,7 @@
   "peerDependencies": {
     "react": "*",
     "react-native": "*",
-    "react-native-nitro-modules": "^0.26.2"
+    "react-native-nitro-modules": "^0.26.4"
   },
   "workspaces": [
     "example"
@@ -168,6 +174,6 @@
   "create-react-native-library": {
     "languages": "kotlin-swift",
     "type": "nitro-module",
-    "version": "0.49.0"
+    "version": "0.52.0"
   }
 }

package/src/NitroArk.nitro.ts

@@ -56,10 +56,10 @@ export interface ArkoorPaymentResult {
   payment_type: PaymentTypes; // 'Arkoor'
 }
 
-export interface Bolt11PaymentResult {
+export interface LightningPaymentResult {
   bolt11_invoice: string;
   preimage: string;
-  payment_type: PaymentTypes; // 'Bolt11'
+  payment_type: PaymentTypes; // 'Lightning'
 }
 
 export interface LnurlPaymentResult {
@@ -76,39 +76,66 @@ export interface OnchainPaymentResult {
   payment_type: PaymentTypes; // 'Onchain'
 }
 
+export interface OffchainBalanceResult {
+  spendable: number; // u64
+  pending_lightning_send: number; // u64
+  pending_exit: number; // u64
+}
+
+export interface OnchainBalanceResult {
+        // All coinbase outputs not yet matured
+        immature: number,
+        // Unconfirmed UTXOs generated by a wallet tx
+        trusted_pending: number,
+        // Unconfirmed UTXOs received from an external wallet
+        untrusted_pending: number,
+        // Confirmed and immediately spendable balance
+        confirmed: number,
+}
+
 // --- Nitro Module Interface ---
 
 export interface NitroArk extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
   // --- Management ---
   createMnemonic(): Promise<string>;
   loadWallet(datadir: string, opts: BarkCreateOpts): Promise<void>;
-  closeWallet(): Promise<void>;
   isWalletLoaded(): Promise<boolean>;
+  closeWallet(): Promise<void>;
   persistConfig(opts: BarkConfigOpts): Promise<void>;
   maintenance(): Promise<void>;
   sync(): Promise<void>;
-  syncArk(): Promise<void>;
+  syncExits(): Promise<void>;
   syncRounds(): Promise<void>;
 
   // --- Wallet Info ---
   getArkInfo(): Promise<BarkArkInfo>;
-  onchainBalance(): Promise<number>;
-  offchainBalance(): Promise<number>;
-  getOnchainAddress(): Promise<string>;
-  getOnchainUtxos(no_sync: boolean): Promise<string>; // Returns JSON string
-  getVtxoPubkey(index?: number): Promise<string>;
-  getVtxos(no_sync: boolean): Promise<string>; // Returns JSON string
+  offchainBalance(): Promise<OffchainBalanceResult>;
+  deriveStoreNextKeypair(): Promise<string>;
+  peakKeyPair(index: number): Promise<string>;
+  getVtxos(): Promise<BarkVtxo[]>; // Returns JSON string
 
   // --- Onchain Operations ---
-  sendOnchain(
+  onchainBalance(): Promise<OnchainBalanceResult>;
+  onchainSync(): Promise<void>;
+  onchainListUnspent(): Promise<string>; // Returns JSON string
+  onchainUtxos(): Promise<string>; // Returns JSON string
+  onchainAddress(): Promise<string>; // Returns address string
+  onchainSend(
     destination: string,
-    amountSat: number
-  ): Promise<OnchainPaymentResult>; // Returns txid
-  drainOnchain(destination: string, no_sync: boolean): Promise<string>; // Returns txid
-  sendManyOnchain(
+    amountSat: number,
+    feeRate?: number // Optional fee rate in sat/vB
+  ): Promise<OnchainPaymentResult>; // Returns txid and details
+  // Note: feeRate is optional, if not provided, default fee rate will be used
+  onchainDrain(
+    destination: string,
+    feeRate?: number // Optional fee rate in sat/vB
+  ): Promise<string>; // Returns txid
+  // Note: feeRate is optional, if not provided, default fee rate will be used
+  onchainSendMany(
     outputs: BarkSendManyOutput[],
-    no_sync: boolean
+    feeRate?: number // Optional fee rate in sat/vB
   ): Promise<string>; // Returns txid
+  // Note: feeRate is optional, if not provided, default fee rate will be used
 
   // --- Ark & Lightning Payments ---
   boardAmount(amountSat: number): Promise<string>; // Returns JSON status
@@ -117,24 +144,23 @@ export interface NitroArk extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
     destination: string,
     amountSat: number
   ): Promise<ArkoorPaymentResult>;
-  sendBolt11Payment(
+  sendLightningPayment(
     destination: string,
     amountSat?: number
-  ): Promise<Bolt11PaymentResult>;
+  ): Promise<LightningPaymentResult>;
   sendLnaddr(
     addr: string,
     amountSat: number,
     comment: string
   ): Promise<LnurlPaymentResult>;
-  sendRoundOnchain(
+  sendRoundOnchainPayment(
     destination: string,
     amountSat: number,
-    no_sync: boolean
   ): Promise<string>; // Returns JSON status
 
   // --- Lightning Invoicing ---
   bolt11Invoice(amountMsat: number): Promise<string>; // Returns invoice string
-  claimBolt11Payment(bolt11: string): Promise<void>; // Throws on error
+  finishLightningReceive(bolt11: string): Promise<void>; // Throws on error
 
   // --- Offboarding / Exiting ---
   offboardSpecific(
@@ -142,7 +168,4 @@ export interface NitroArk extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
     destinationAddress: string
   ): Promise<string>; // Returns JSON result
   offboardAll(destinationAddress: string): Promise<string>; // Returns JSON result
-  exitStartSpecific(vtxoIds: string[]): Promise<string>;
-  exitStartAll(): Promise<string>;
-  exitProgressOnce(): Promise<string>;
 }