react-native-nitro-ark 0.0.71 → 0.0.73

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

@@ -19,17 +19,18 @@ namespace margelo::nitro::nitroark {
       prototype.registerHybridMethod("loadWallet", &HybridNitroArkSpec::loadWallet);
       prototype.registerHybridMethod("isWalletLoaded", &HybridNitroArkSpec::isWalletLoaded);
       prototype.registerHybridMethod("closeWallet", &HybridNitroArkSpec::closeWallet);
+      prototype.registerHybridMethod("checkConnection", &HybridNitroArkSpec::checkConnection);
       prototype.registerHybridMethod("syncPendingBoards", &HybridNitroArkSpec::syncPendingBoards);
       prototype.registerHybridMethod("maintenance", &HybridNitroArkSpec::maintenance);
       prototype.registerHybridMethod("maintenanceWithOnchain", &HybridNitroArkSpec::maintenanceWithOnchain);
       prototype.registerHybridMethod("maintenanceRefresh", &HybridNitroArkSpec::maintenanceRefresh);
       prototype.registerHybridMethod("sync", &HybridNitroArkSpec::sync);
       prototype.registerHybridMethod("syncExits", &HybridNitroArkSpec::syncExits);
-      prototype.registerHybridMethod("syncPastRounds", &HybridNitroArkSpec::syncPastRounds);
       prototype.registerHybridMethod("getArkInfo", &HybridNitroArkSpec::getArkInfo);
       prototype.registerHybridMethod("offchainBalance", &HybridNitroArkSpec::offchainBalance);
       prototype.registerHybridMethod("deriveStoreNextKeypair", &HybridNitroArkSpec::deriveStoreNextKeypair);
       prototype.registerHybridMethod("peakKeyPair", &HybridNitroArkSpec::peakKeyPair);
+      prototype.registerHybridMethod("peakAddress", &HybridNitroArkSpec::peakAddress);
       prototype.registerHybridMethod("newAddress", &HybridNitroArkSpec::newAddress);
       prototype.registerHybridMethod("signMessage", &HybridNitroArkSpec::signMessage);
       prototype.registerHybridMethod("signMesssageWithMnemonic", &HybridNitroArkSpec::signMesssageWithMnemonic);
@@ -52,14 +53,14 @@ namespace margelo::nitro::nitroark {
       prototype.registerHybridMethod("boardAll", &HybridNitroArkSpec::boardAll);
       prototype.registerHybridMethod("validateArkoorAddress", &HybridNitroArkSpec::validateArkoorAddress);
       prototype.registerHybridMethod("sendArkoorPayment", &HybridNitroArkSpec::sendArkoorPayment);
-      prototype.registerHybridMethod("sendLightningPayment", &HybridNitroArkSpec::sendLightningPayment);
-      prototype.registerHybridMethod("payOffer", &HybridNitroArkSpec::payOffer);
-      prototype.registerHybridMethod("sendLnaddr", &HybridNitroArkSpec::sendLnaddr);
+      prototype.registerHybridMethod("payLightningInvoice", &HybridNitroArkSpec::payLightningInvoice);
+      prototype.registerHybridMethod("payLightningOffer", &HybridNitroArkSpec::payLightningOffer);
+      prototype.registerHybridMethod("payLightningAddress", &HybridNitroArkSpec::payLightningAddress);
       prototype.registerHybridMethod("sendRoundOnchainPayment", &HybridNitroArkSpec::sendRoundOnchainPayment);
       prototype.registerHybridMethod("bolt11Invoice", &HybridNitroArkSpec::bolt11Invoice);
       prototype.registerHybridMethod("lightningReceiveStatus", &HybridNitroArkSpec::lightningReceiveStatus);
-      prototype.registerHybridMethod("checkAndClaimLnReceive", &HybridNitroArkSpec::checkAndClaimLnReceive);
-      prototype.registerHybridMethod("checkAndClaimAllOpenLnReceives", &HybridNitroArkSpec::checkAndClaimAllOpenLnReceives);
+      prototype.registerHybridMethod("tryClaimLightningReceive", &HybridNitroArkSpec::tryClaimLightningReceive);
+      prototype.registerHybridMethod("tryClaimAllLightningReceives", &HybridNitroArkSpec::tryClaimAllLightningReceives);
       prototype.registerHybridMethod("offboardSpecific", &HybridNitroArkSpec::offboardSpecific);
       prototype.registerHybridMethod("offboardAll", &HybridNitroArkSpec::offboardAll);
     });

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

@@ -43,6 +43,8 @@ namespace margelo::nitro::nitroark { struct Bolt11PaymentResult; }
 namespace margelo::nitro::nitroark { struct Bolt12PaymentResult; }
 // Forward declaration of `LnurlPaymentResult` to properly resolve imports.
 namespace margelo::nitro::nitroark { struct LnurlPaymentResult; }
+// Forward declaration of `RoundStatus` to properly resolve imports.
+namespace margelo::nitro::nitroark { struct RoundStatus; }
 // Forward declaration of `Bolt11Invoice` to properly resolve imports.
 namespace margelo::nitro::nitroark { struct Bolt11Invoice; }
 // Forward declaration of `LightningReceive` to properly resolve imports.
@@ -67,6 +69,7 @@ namespace margelo::nitro::nitroark { struct LightningReceive; }
 #include "Bolt11PaymentResult.hpp"
 #include "Bolt12PaymentResult.hpp"
 #include "LnurlPaymentResult.hpp"
+#include "RoundStatus.hpp"
 #include "Bolt11Invoice.hpp"
 #include "LightningReceive.hpp"
 
@@ -106,17 +109,18 @@ namespace margelo::nitro::nitroark {
       virtual std::shared_ptr<Promise<void>> loadWallet(const std::string& datadir, const BarkCreateOpts& config) = 0;
       virtual std::shared_ptr<Promise<bool>> isWalletLoaded() = 0;
       virtual std::shared_ptr<Promise<void>> closeWallet() = 0;
+      virtual std::shared_ptr<Promise<void>> checkConnection() = 0;
       virtual std::shared_ptr<Promise<void>> syncPendingBoards() = 0;
       virtual std::shared_ptr<Promise<void>> maintenance() = 0;
       virtual std::shared_ptr<Promise<void>> maintenanceWithOnchain() = 0;
       virtual std::shared_ptr<Promise<void>> maintenanceRefresh() = 0;
       virtual std::shared_ptr<Promise<void>> sync() = 0;
       virtual std::shared_ptr<Promise<void>> syncExits() = 0;
-      virtual std::shared_ptr<Promise<void>> syncPastRounds() = 0;
       virtual std::shared_ptr<Promise<BarkArkInfo>> getArkInfo() = 0;
       virtual std::shared_ptr<Promise<OffchainBalanceResult>> offchainBalance() = 0;
       virtual std::shared_ptr<Promise<KeyPairResult>> deriveStoreNextKeypair() = 0;
       virtual std::shared_ptr<Promise<KeyPairResult>> peakKeyPair(double index) = 0;
+      virtual std::shared_ptr<Promise<NewAddressResult>> peakAddress(double index) = 0;
       virtual std::shared_ptr<Promise<NewAddressResult>> newAddress() = 0;
       virtual std::shared_ptr<Promise<std::string>> signMessage(const std::string& message, double index) = 0;
       virtual std::shared_ptr<Promise<std::string>> signMesssageWithMnemonic(const std::string& message, const std::string& mnemonic, const std::string& network, double index) = 0;
@@ -139,16 +143,16 @@ namespace margelo::nitro::nitroark {
       virtual std::shared_ptr<Promise<BoardResult>> boardAll() = 0;
       virtual std::shared_ptr<Promise<void>> validateArkoorAddress(const std::string& address) = 0;
       virtual std::shared_ptr<Promise<ArkoorPaymentResult>> sendArkoorPayment(const std::string& destination, double amountSat) = 0;
-      virtual std::shared_ptr<Promise<Bolt11PaymentResult>> sendLightningPayment(const std::string& destination, std::optional<double> amountSat) = 0;
-      virtual std::shared_ptr<Promise<Bolt12PaymentResult>> payOffer(const std::string& offer, 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>> sendRoundOnchainPayment(const std::string& destination, double amountSat) = 0;
+      virtual std::shared_ptr<Promise<Bolt11PaymentResult>> payLightningInvoice(const std::string& destination, std::optional<double> amountSat) = 0;
+      virtual std::shared_ptr<Promise<Bolt12PaymentResult>> payLightningOffer(const std::string& offer, std::optional<double> amountSat) = 0;
+      virtual std::shared_ptr<Promise<LnurlPaymentResult>> payLightningAddress(const std::string& addr, double amountSat, const std::string& comment) = 0;
+      virtual std::shared_ptr<Promise<RoundStatus>> sendRoundOnchainPayment(const std::string& destination, double amountSat) = 0;
       virtual std::shared_ptr<Promise<Bolt11Invoice>> bolt11Invoice(double amountMsat) = 0;
       virtual std::shared_ptr<Promise<std::optional<LightningReceive>>> lightningReceiveStatus(const std::string& paymentHash) = 0;
-      virtual std::shared_ptr<Promise<void>> checkAndClaimLnReceive(const std::string& paymentHash, bool wait) = 0;
-      virtual std::shared_ptr<Promise<void>> checkAndClaimAllOpenLnReceives(bool wait) = 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<void>> tryClaimLightningReceive(const std::string& paymentHash, bool wait, const std::optional<std::string>& token) = 0;
+      virtual std::shared_ptr<Promise<void>> tryClaimAllLightningReceives(bool wait) = 0;
+      virtual std::shared_ptr<Promise<RoundStatus>> offboardSpecific(const std::vector<std::string>& vtxoIds, const std::string& destinationAddress) = 0;
+      virtual std::shared_ptr<Promise<RoundStatus>> offboardAll(const std::string& destinationAddress) = 0;
 
     protected:
       // Hybrid Setup

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

@@ -0,0 +1,99 @@
+///
+/// RoundStatus.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
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `RoundStatusType` to properly resolve imports.
+namespace margelo::nitro::nitroark { enum class RoundStatusType; }
+
+#include "RoundStatusType.hpp"
+#include <string>
+#include <optional>
+#include <vector>
+
+namespace margelo::nitro::nitroark {
+
+  /**
+   * A struct which can be represented as a JavaScript object (RoundStatus).
+   */
+  struct RoundStatus {
+  public:
+    RoundStatusType status     SWIFT_PRIVATE;
+    std::optional<std::string> funding_txid     SWIFT_PRIVATE;
+    std::optional<std::vector<std::string>> unsigned_funding_txids     SWIFT_PRIVATE;
+    std::optional<std::string> error     SWIFT_PRIVATE;
+    bool is_final     SWIFT_PRIVATE;
+    bool is_success     SWIFT_PRIVATE;
+
+  public:
+    RoundStatus() = default;
+    explicit RoundStatus(RoundStatusType status, std::optional<std::string> funding_txid, std::optional<std::vector<std::string>> unsigned_funding_txids, std::optional<std::string> error, bool is_final, bool is_success): status(status), funding_txid(funding_txid), unsigned_funding_txids(unsigned_funding_txids), error(error), is_final(is_final), is_success(is_success) {}
+  };
+
+} // namespace margelo::nitro::nitroark
+
+namespace margelo::nitro {
+
+  // C++ RoundStatus <> JS RoundStatus (object)
+  template <>
+  struct JSIConverter<margelo::nitro::nitroark::RoundStatus> final {
+    static inline margelo::nitro::nitroark::RoundStatus fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::nitroark::RoundStatus(
+        JSIConverter<margelo::nitro::nitroark::RoundStatusType>::fromJSI(runtime, obj.getProperty(runtime, "status")),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, "funding_txid")),
+        JSIConverter<std::optional<std::vector<std::string>>>::fromJSI(runtime, obj.getProperty(runtime, "unsigned_funding_txids")),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, "error")),
+        JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, "is_final")),
+        JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, "is_success"))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::nitroark::RoundStatus& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, "status", JSIConverter<margelo::nitro::nitroark::RoundStatusType>::toJSI(runtime, arg.status));
+      obj.setProperty(runtime, "funding_txid", JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.funding_txid));
+      obj.setProperty(runtime, "unsigned_funding_txids", JSIConverter<std::optional<std::vector<std::string>>>::toJSI(runtime, arg.unsigned_funding_txids));
+      obj.setProperty(runtime, "error", JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.error));
+      obj.setProperty(runtime, "is_final", JSIConverter<bool>::toJSI(runtime, arg.is_final));
+      obj.setProperty(runtime, "is_success", JSIConverter<bool>::toJSI(runtime, arg.is_success));
+      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 (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<margelo::nitro::nitroark::RoundStatusType>::canConvert(runtime, obj.getProperty(runtime, "status"))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, "funding_txid"))) return false;
+      if (!JSIConverter<std::optional<std::vector<std::string>>>::canConvert(runtime, obj.getProperty(runtime, "unsigned_funding_txids"))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, "error"))) return false;
+      if (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, "is_final"))) return false;
+      if (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, "is_success"))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,84 @@
+///
+/// RoundStatusType.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/NitroHash.hpp>)
+#include <NitroModules/NitroHash.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#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 {
+
+  /**
+   * An enum which can be represented as a JavaScript union (RoundStatusType).
+   */
+  enum class RoundStatusType {
+    CONFIRMED      SWIFT_NAME(confirmed) = 0,
+    UNCONFIRMED      SWIFT_NAME(unconfirmed) = 1,
+    PENDING      SWIFT_NAME(pending) = 2,
+    FAILED      SWIFT_NAME(failed) = 3,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::nitroark
+
+namespace margelo::nitro {
+
+  // C++ RoundStatusType <> JS RoundStatusType (union)
+  template <>
+  struct JSIConverter<margelo::nitro::nitroark::RoundStatusType> final {
+    static inline margelo::nitro::nitroark::RoundStatusType fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("confirmed"): return margelo::nitro::nitroark::RoundStatusType::CONFIRMED;
+        case hashString("unconfirmed"): return margelo::nitro::nitroark::RoundStatusType::UNCONFIRMED;
+        case hashString("pending"): return margelo::nitro::nitroark::RoundStatusType::PENDING;
+        case hashString("failed"): return margelo::nitro::nitroark::RoundStatusType::FAILED;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum RoundStatusType - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::nitroark::RoundStatusType arg) {
+      switch (arg) {
+        case margelo::nitro::nitroark::RoundStatusType::CONFIRMED: return JSIConverter<std::string>::toJSI(runtime, "confirmed");
+        case margelo::nitro::nitroark::RoundStatusType::UNCONFIRMED: return JSIConverter<std::string>::toJSI(runtime, "unconfirmed");
+        case margelo::nitro::nitroark::RoundStatusType::PENDING: return JSIConverter<std::string>::toJSI(runtime, "pending");
+        case margelo::nitro::nitroark::RoundStatusType::FAILED: return JSIConverter<std::string>::toJSI(runtime, "failed");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert RoundStatusType to JS - invalid value: "
+                                    + std::to_string(static_cast<int>(arg)) + "!");
+      }
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isString()) {
+        return false;
+      }
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, value);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("confirmed"):
+        case hashString("unconfirmed"):
+        case hashString("pending"):
+        case hashString("failed"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-ark",
-  "version": "0.0.71",
+  "version": "0.0.73",
   "description": "Pure C++ Nitro Modules for Ark client",
   "source": "./src/index.tsx",
   "main": "./lib/module/index.js",

package/src/NitroArk.nitro.ts

@@ -15,7 +15,7 @@ export interface BarkConfigOpts {
   fallback_fee_rate?: number;
   htlc_recv_claim_delta: number;
   vtxo_exit_margin: number;
-  deep_round_confirmations: number;
+  round_tx_required_confirmations: number;
 }
 
 export interface BarkCreateOpts {
@@ -147,19 +147,47 @@ export interface LightningReceive {
   preimage_revealed_at?: number;
 }
 
-export interface BarkMovementRecipient {
-  recipient: string;
+export interface BarkMovementSubsystem {
+  name: string;
+  kind: string;
+}
+
+export interface BarkMovementDestination {
+  destination: string;
   amount_sat: number;
 }
 
 export interface BarkMovement {
   id: number;
-  kind: string;
-  fees: number;
-  spends: BarkVtxo[];
-  receives: BarkVtxo[];
-  recipients: BarkMovementRecipient[];
+  status: string; // 'pending' | 'finished' | 'failed' | 'cancelled'
+  subsystem: BarkMovementSubsystem;
+  metadata_json: string;
+  intended_balance_sat: number;
+  effective_balance_sat: number;
+  offchain_fee_sat: number;
+  sent_to: BarkMovementDestination[];
+  received_on: BarkMovementDestination[];
+  input_vtxos: string[];
+  output_vtxos: string[];
+  exited_vtxos: string[];
   created_at: string;
+  updated_at: string;
+  completed_at?: string;
+}
+
+export type RoundStatusType =
+  | 'confirmed'
+  | 'unconfirmed'
+  | 'pending'
+  | 'failed';
+
+export interface RoundStatus {
+  status: RoundStatusType;
+  funding_txid?: string;
+  unsigned_funding_txids?: string[];
+  error?: string;
+  is_final: boolean;
+  is_success: boolean;
 }
 
 // --- Nitro Module Interface ---
@@ -171,19 +199,20 @@ export interface NitroArk extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
   loadWallet(datadir: string, config: BarkCreateOpts): Promise<void>;
   isWalletLoaded(): Promise<boolean>;
   closeWallet(): Promise<void>;
+  checkConnection(): Promise<void>;
   syncPendingBoards(): Promise<void>;
   maintenance(): Promise<void>;
   maintenanceWithOnchain(): Promise<void>;
   maintenanceRefresh(): Promise<void>;
   sync(): Promise<void>;
   syncExits(): Promise<void>;
-  syncPastRounds(): Promise<void>;
 
   // --- Wallet Info ---
   getArkInfo(): Promise<BarkArkInfo>;
   offchainBalance(): Promise<OffchainBalanceResult>;
   deriveStoreNextKeypair(): Promise<KeyPairResult>;
   peakKeyPair(index: number): Promise<KeyPairResult>;
+  peakAddress(index: number): Promise<NewAddressResult>;
   newAddress(): Promise<NewAddressResult>;
   signMessage(message: string, index: number): Promise<string>;
   signMesssageWithMnemonic(
@@ -239,12 +268,15 @@ export interface NitroArk extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
     destination: string,
     amountSat: number
   ): Promise<ArkoorPaymentResult>;
-  sendLightningPayment(
+  payLightningInvoice(
     destination: string,
     amountSat?: number
   ): Promise<Bolt11PaymentResult>;
-  payOffer(offer: string, amountSat?: number): Promise<Bolt12PaymentResult>;
-  sendLnaddr(
+  payLightningOffer(
+    offer: string,
+    amountSat?: number
+  ): Promise<Bolt12PaymentResult>;
+  payLightningAddress(
     addr: string,
     amountSat: number,
     comment: string
@@ -252,20 +284,24 @@ export interface NitroArk extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
   sendRoundOnchainPayment(
     destination: string,
     amountSat: number
-  ): Promise<string>; // Returns JSON status
+  ): Promise<RoundStatus>;
 
   // --- Lightning Invoicing ---
   bolt11Invoice(amountMsat: number): Promise<Bolt11Invoice>;
   lightningReceiveStatus(
     paymentHash: string
   ): Promise<LightningReceive | undefined>;
-  checkAndClaimLnReceive(paymentHash: string, wait: boolean): Promise<void>; // Throws on error
-  checkAndClaimAllOpenLnReceives(wait: boolean): Promise<void>; // Throws on error
+  tryClaimLightningReceive(
+    paymentHash: string,
+    wait: boolean,
+    token?: string
+  ): Promise<void>; // Throws on error
+  tryClaimAllLightningReceives(wait: boolean): Promise<void>; // Throws on error
 
   // --- Offboarding / Exiting ---
   offboardSpecific(
     vtxoIds: string[],
     destinationAddress: string
-  ): Promise<string>; // Returns JSON result
-  offboardAll(destinationAddress: string): Promise<string>; // Returns JSON result
+  ): Promise<RoundStatus>;
+  offboardAll(destinationAddress: string): Promise<RoundStatus>;
 }

package/src/index.tsx

@@ -15,7 +15,9 @@ import type {
   NewAddressResult,
   KeyPairResult,
   LightningReceive,
+  BarkMovement as NitroBarkMovement,
   BoardResult,
+  RoundStatus,
 } from './NitroArk.nitro';
 
 export type BarkVtxo = {
@@ -28,28 +30,10 @@ export type BarkVtxo = {
   state: 'Spendable' | 'Spent' | 'Locked' | 'unknown';
 };
 
-export interface BarkMovementRecipient {
-  recipient: string;
-  amount_sat: number;
-}
-
-export type BarkMovement = {
-  id: number;
-  kind:
-    | 'onboard'
-    | 'round'
-    | 'offboard'
-    | 'arkoor-send'
-    | 'arkoor-receive'
-    | 'lightning-send'
-    | 'lightning-send-revocation'
-    | 'lightning-receive'
-    | 'exit';
-  fees: number;
-  spends: BarkVtxo[];
-  receives: BarkVtxo[];
-  recipients: BarkMovementRecipient[];
-  created_at: string;
+export type MovementStatus = 'pending' | 'finished' | 'failed' | 'cancelled';
+
+export type BarkMovement = NitroBarkMovement & {
+  status: MovementStatus;
 };
 
 // Create the hybrid object instance
@@ -101,6 +85,10 @@ export function closeWallet(): Promise<void> {
   return NitroArkHybridObject.closeWallet();
 }
 
+export function checkConnection(): Promise<void> {
+  return NitroArkHybridObject.checkConnection();
+}
+
 /**
  * Checks if a wallet is currently loaded.
  * @returns A promise resolving to true if a wallet is loaded, false otherwise.
@@ -159,14 +147,6 @@ export function syncExits(): Promise<void> {
   return NitroArkHybridObject.syncExits();
 }
 
-/**
- * Synchronizes the rounds of the wallet.
- * @returns A promise that resolves on success.
- */
-export function syncPastRounds(): Promise<void> {
-  return NitroArkHybridObject.syncPastRounds();
-}
-
 // --- Wallet Info ---
 
 /**
@@ -202,6 +182,15 @@ export function peakKeyPair(index: number): Promise<KeyPairResult> {
   return NitroArkHybridObject.peakKeyPair(index);
 }
 
+/**
+ * Peeks a derived address without advancing the wallet's address index.
+ * @param index Index of the address to preview.
+ * @returns A promise resolving to the NewAddressResult object.
+ */
+export function peakAddress(index: number): Promise<NewAddressResult> {
+  return NitroArkHybridObject.peakAddress(index);
+}
+
 /**
  * Gets the wallet's Address.
  * @returns A promise resolving to NewAddressResult object.
@@ -422,15 +411,22 @@ export function lightningReceiveStatus(
 }
 
 /**
- * Checks and claims a Lightning payment.
+ * Attempts to claim a Lightning payment, optionally using a claim token.
  * @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 that resolves on success or rejects on error.
  */
-export function checkAndClaimLnReceive(
+export function tryClaimLightningReceive(
   paymentHash: string,
-  wait: boolean
+  wait: boolean,
+  token?: string
 ): Promise<void> {
-  return NitroArkHybridObject.checkAndClaimLnReceive(paymentHash, wait);
+  return NitroArkHybridObject.tryClaimLightningReceive(
+    paymentHash,
+    wait,
+    token
+  );
 }
 
 /**
@@ -438,21 +434,21 @@ export function checkAndClaimLnReceive(
  * @param wait Whether to wait for the claim to complete.
  * @returns A promise that resolves on success or rejects on error.
  */
-export function checkAndClaimAllOpenLnReceives(wait: boolean): Promise<void> {
-  return NitroArkHybridObject.checkAndClaimAllOpenLnReceives(wait);
+export function tryClaimAllLightningReceives(wait: boolean): Promise<void> {
+  return NitroArkHybridObject.tryClaimAllLightningReceives(wait);
 }
 
 /**
- * Sends a Lightning payment.
+ * Pays a Bolt11 Lightning invoice.
  * @param destination The Lightning invoice.
  * @param amountSat The amount in satoshis to send. Use 0 for invoice amount.
  * @returns A promise resolving to a Bolt11PaymentResult object
  */
-export function sendLightningPayment(
+export function payLightningInvoice(
   destination: string,
   amountSat?: number
 ): Promise<Bolt11PaymentResult> {
-  return NitroArkHybridObject.sendLightningPayment(destination, amountSat);
+  return NitroArkHybridObject.payLightningInvoice(destination, amountSat);
 }
 
 /**
@@ -461,11 +457,11 @@ export function sendLightningPayment(
  * @param amountSat The amount in satoshis to send. Use 0 for invoice amount.
  * @returns A promise resolving to a Bolt12PaymentResult object
  */
-export function payOffer(
+export function payLightningOffer(
   offer: string,
   amountSat?: number
 ): Promise<Bolt12PaymentResult> {
-  return NitroArkHybridObject.payOffer(offer, amountSat);
+  return NitroArkHybridObject.payLightningOffer(offer, amountSat);
 }
 
 /**
@@ -475,12 +471,12 @@ export function payOffer(
  * @param comment An optional comment.
  * @returns A promise resolving to a LnurlPaymentResult object
  */
-export function sendLnaddr(
+export function payLightningAddress(
   addr: string,
   amountSat: number,
   comment: string
 ): Promise<LnurlPaymentResult> {
-  return NitroArkHybridObject.sendLnaddr(addr, amountSat, comment);
+  return NitroArkHybridObject.payLightningAddress(addr, amountSat, comment);
 }
 
 // --- Ark Operations ---
@@ -528,12 +524,12 @@ export function sendArkoorPayment(
  * Sends an onchain payment via an Ark round.
  * @param destination The destination Bitcoin address.
  * @param amountSat The amount in satoshis to send.
- * @returns A promise resolving to a JSON status string.
+ * @returns A promise resolving to the round status.
  */
 export function sendRoundOnchainPayment(
   destination: string,
   amountSat: number
-): Promise<string> {
+): Promise<RoundStatus> {
   return NitroArkHybridObject.sendRoundOnchainPayment(destination, amountSat);
 }
 
@@ -543,23 +539,21 @@ export function sendRoundOnchainPayment(
  * Offboards specific VTXOs to a destination address.
  * @param vtxoIds Array of VtxoId strings to offboard.
  * @param destinationAddress Destination Bitcoin address (if empty, sends to internal wallet).
- * @param no_sync If true, skips synchronization with the wallet. Defaults to false.
- * @returns A promise resolving to a JSON result string.
+ * @returns A promise resolving to the round status.
  */
 export function offboardSpecific(
   vtxoIds: string[],
   destinationAddress: string
-): Promise<string> {
+): Promise<RoundStatus> {
   return NitroArkHybridObject.offboardSpecific(vtxoIds, destinationAddress);
 }
 
 /**
  * Offboards all VTXOs to a destination address.
  * @param destinationAddress Destination Bitcoin address (if empty, sends to internal wallet).
- * @param no_sync If true, skips synchronization with the wallet. Defaults to false.
- * @returns A promise resolving to a JSON result string.
+ * @returns A promise resolving to the round status.
  */
-export function offboardAll(destinationAddress: string): Promise<string> {
+export function offboardAll(destinationAddress: string): Promise<RoundStatus> {
   return NitroArkHybridObject.offboardAll(destinationAddress);
 }
 
@@ -583,4 +577,5 @@ export type {
   KeyPairResult,
   LightningReceive,
   LightningReceiveBalance,
+  RoundStatus,
 } from './NitroArk.nitro';