react-native-candle 0.1.20 → 0.1.21

package/nitrogen/generated/ios/ReactNativeCandle-Swift-Cxx-Umbrella.hpp

@@ -34,8 +34,6 @@ namespace margelo::nitro::rncandle { struct AssetAccount; }
 namespace margelo::nitro::rncandle { struct Coordinates; }
 // Forward declaration of `Counterparty` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct Counterparty; }
-// Forward declaration of `ExecuteTradeRequest` to properly resolve imports.
-namespace margelo::nitro::rncandle { struct ExecuteTradeRequest; }
 // Forward declaration of `FiatAccountDetails` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct FiatAccountDetails; }
 // Forward declaration of `FiatAssetQuoteRequest` to properly resolve imports.
@@ -94,6 +92,8 @@ namespace margelo::nitro::rncandle { struct TradeAssetQuoteRequest; }
 namespace margelo::nitro::rncandle { struct TradeAssetRef; }
 // Forward declaration of `TradeAsset` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct TradeAsset; }
+// Forward declaration of `TradeExecutionResult` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct TradeExecutionResult; }
 // Forward declaration of `TradeQuery` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct TradeQuery; }
 // Forward declaration of `TradeQuoteRequest` to properly resolve imports.
@@ -130,7 +130,6 @@ namespace margelo::nitro::rncandle { struct WireDetails; }
 #include "AssetAccountRef.hpp"
 #include "Coordinates.hpp"
 #include "Counterparty.hpp"
-#include "ExecuteTradeRequest.hpp"
 #include "FiatAccountDetails.hpp"
 #include "FiatAsset.hpp"
 #include "FiatAssetQuoteRequest.hpp"
@@ -161,6 +160,7 @@ namespace margelo::nitro::rncandle { struct WireDetails; }
 #include "TradeAsset.hpp"
 #include "TradeAssetQuoteRequest.hpp"
 #include "TradeAssetRef.hpp"
+#include "TradeExecutionResult.hpp"
 #include "TradeQuery.hpp"
 #include "TradeQuote.hpp"
 #include "TradeQuoteRequest.hpp"

package/nitrogen/generated/ios/c++/HybridRNCandleSpecSwift.hpp

@@ -26,6 +26,40 @@ namespace margelo::nitro::rncandle { struct LinkedAccountDetails; }
 namespace margelo::nitro::rncandle { struct ActiveLinkedAccountDetails; }
 // Forward declaration of `InactiveLinkedAccountDetails` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct InactiveLinkedAccountDetails; }
+// Forward declaration of `TradeQuote` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct TradeQuote; }
+// Forward declaration of `TradeAsset` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct TradeAsset; }
+// Forward declaration of `FiatAsset` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct FiatAsset; }
+// Forward declaration of `MarketTradeAsset` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct MarketTradeAsset; }
+// Forward declaration of `TransportAsset` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct TransportAsset; }
+// Forward declaration of `Coordinates` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct Coordinates; }
+// Forward declaration of `Address` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct Address; }
+// Forward declaration of `OtherAsset` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct OtherAsset; }
+// Forward declaration of `NothingAsset` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct NothingAsset; }
+// Forward declaration of `TradeExecutionResult` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct TradeExecutionResult; }
+// Forward declaration of `Trade` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct Trade; }
+// Forward declaration of `TradeState` to properly resolve imports.
+namespace margelo::nitro::rncandle { enum class TradeState; }
+// Forward declaration of `Counterparty` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct Counterparty; }
+// Forward declaration of `MerchantCounterparty` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct MerchantCounterparty; }
+// Forward declaration of `MerchantLocation` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct MerchantLocation; }
+// Forward declaration of `UserCounterparty` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct UserCounterparty; }
+// Forward declaration of `ServiceCounterparty` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct ServiceCounterparty; }
 // Forward declaration of `AppUser` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct AppUser; }
 // Forward declaration of `LinkedAccountRef` to properly resolve imports.
@@ -52,36 +86,6 @@ namespace margelo::nitro::rncandle { struct AssetAccountQuery; }
 namespace margelo::nitro::rncandle { enum class AssetAccountKind; }
 // Forward declaration of `AssetAccountRef` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct AssetAccountRef; }
-// Forward declaration of `Trade` to properly resolve imports.
-namespace margelo::nitro::rncandle { struct Trade; }
-// Forward declaration of `TradeState` to properly resolve imports.
-namespace margelo::nitro::rncandle { enum class TradeState; }
-// Forward declaration of `Counterparty` to properly resolve imports.
-namespace margelo::nitro::rncandle { struct Counterparty; }
-// Forward declaration of `MerchantCounterparty` to properly resolve imports.
-namespace margelo::nitro::rncandle { struct MerchantCounterparty; }
-// Forward declaration of `MerchantLocation` to properly resolve imports.
-namespace margelo::nitro::rncandle { struct MerchantLocation; }
-// Forward declaration of `UserCounterparty` to properly resolve imports.
-namespace margelo::nitro::rncandle { struct UserCounterparty; }
-// Forward declaration of `ServiceCounterparty` to properly resolve imports.
-namespace margelo::nitro::rncandle { struct ServiceCounterparty; }
-// Forward declaration of `TradeAsset` to properly resolve imports.
-namespace margelo::nitro::rncandle { struct TradeAsset; }
-// Forward declaration of `FiatAsset` to properly resolve imports.
-namespace margelo::nitro::rncandle { struct FiatAsset; }
-// Forward declaration of `MarketTradeAsset` to properly resolve imports.
-namespace margelo::nitro::rncandle { struct MarketTradeAsset; }
-// Forward declaration of `TransportAsset` to properly resolve imports.
-namespace margelo::nitro::rncandle { struct TransportAsset; }
-// Forward declaration of `Coordinates` to properly resolve imports.
-namespace margelo::nitro::rncandle { struct Coordinates; }
-// Forward declaration of `Address` to properly resolve imports.
-namespace margelo::nitro::rncandle { struct Address; }
-// Forward declaration of `OtherAsset` to properly resolve imports.
-namespace margelo::nitro::rncandle { struct OtherAsset; }
-// Forward declaration of `NothingAsset` to properly resolve imports.
-namespace margelo::nitro::rncandle { struct NothingAsset; }
 // Forward declaration of `TradeQuery` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct TradeQuery; }
 // Forward declaration of `TradeRef` to properly resolve imports.
@@ -98,8 +102,6 @@ namespace margelo::nitro::rncandle { struct TransportAssetRef; }
 namespace margelo::nitro::rncandle { struct OtherAssetRef; }
 // Forward declaration of `NothingAssetRef` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct NothingAssetRef; }
-// Forward declaration of `TradeQuote` to properly resolve imports.
-namespace margelo::nitro::rncandle { struct TradeQuote; }
 // Forward declaration of `TradeQuoteRequest` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct TradeQuoteRequest; }
 // Forward declaration of `TradeAssetQuoteRequest` to properly resolve imports.
@@ -112,8 +114,6 @@ namespace margelo::nitro::rncandle { struct MarketAssetQuoteRequest; }
 namespace margelo::nitro::rncandle { struct TransportAssetQuoteRequest; }
 // Forward declaration of `NothingAssetQuoteRequest` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct NothingAssetQuoteRequest; }
-// Forward declaration of `ExecuteTradeRequest` to properly resolve imports.
-namespace margelo::nitro::rncandle { struct ExecuteTradeRequest; }
 // Forward declaration of `AnyMap` to properly resolve imports.
 namespace NitroModules { class AnyMap; }
 // Forward declaration of `ToolCall` to properly resolve imports.
@@ -130,6 +130,23 @@ namespace margelo::nitro::rncandle { struct ToolCall; }
 #include "LinkedAccountDetails.hpp"
 #include "ActiveLinkedAccountDetails.hpp"
 #include "InactiveLinkedAccountDetails.hpp"
+#include "TradeQuote.hpp"
+#include "TradeAsset.hpp"
+#include "FiatAsset.hpp"
+#include "MarketTradeAsset.hpp"
+#include "TransportAsset.hpp"
+#include "Coordinates.hpp"
+#include "Address.hpp"
+#include "OtherAsset.hpp"
+#include "NothingAsset.hpp"
+#include "TradeExecutionResult.hpp"
+#include "Trade.hpp"
+#include "TradeState.hpp"
+#include "Counterparty.hpp"
+#include "MerchantCounterparty.hpp"
+#include "MerchantLocation.hpp"
+#include "UserCounterparty.hpp"
+#include "ServiceCounterparty.hpp"
 #include "AppUser.hpp"
 #include <NitroModules/Promise.hpp>
 #include "LinkedAccountRef.hpp"
@@ -144,21 +161,6 @@ namespace margelo::nitro::rncandle { struct ToolCall; }
 #include "AssetAccountQuery.hpp"
 #include "AssetAccountKind.hpp"
 #include "AssetAccountRef.hpp"
-#include "Trade.hpp"
-#include "TradeState.hpp"
-#include "Counterparty.hpp"
-#include "MerchantCounterparty.hpp"
-#include "MerchantLocation.hpp"
-#include "UserCounterparty.hpp"
-#include "ServiceCounterparty.hpp"
-#include "TradeAsset.hpp"
-#include "FiatAsset.hpp"
-#include "MarketTradeAsset.hpp"
-#include "TransportAsset.hpp"
-#include "Coordinates.hpp"
-#include "Address.hpp"
-#include "OtherAsset.hpp"
-#include "NothingAsset.hpp"
 #include "TradeQuery.hpp"
 #include "TradeRef.hpp"
 #include "TradeAssetRef.hpp"
@@ -167,14 +169,12 @@ namespace margelo::nitro::rncandle { struct ToolCall; }
 #include "TransportAssetRef.hpp"
 #include "OtherAssetRef.hpp"
 #include "NothingAssetRef.hpp"
-#include "TradeQuote.hpp"
 #include "TradeQuoteRequest.hpp"
 #include "TradeAssetQuoteRequest.hpp"
 #include "FiatAssetQuoteRequest.hpp"
 #include "MarketAssetQuoteRequest.hpp"
 #include "TransportAssetQuoteRequest.hpp"
 #include "NothingAssetQuoteRequest.hpp"
-#include "ExecuteTradeRequest.hpp"
 #include <NitroModules/AnyMap.hpp>
 #include "ToolCall.hpp"
 
@@ -223,6 +223,12 @@ namespace margelo::nitro::rncandle {
         std::rethrow_exception(__result.error());
       }
     }
+    inline void candleTradeExecutionSheet(const TradeQuote& tradeQuote, PresentationBackground presentationBackground, const std::function<void(const TradeExecutionResult& /* result */)>& completion) override {
+      auto __result = _swiftPart.candleTradeExecutionSheet(tradeQuote, static_cast<int>(presentationBackground), completion);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
     inline void initialize(const AppUser& appUser) override {
       auto __result = _swiftPart.initialize(appUser);
       if (__result.hasError()) [[unlikely]] {
@@ -293,14 +299,6 @@ namespace margelo::nitro::rncandle {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline std::shared_ptr<Promise<Trade>> executeTrade(const ExecuteTradeRequest& request) override {
-      auto __result = _swiftPart.executeTrade(request);
-      if (__result.hasError()) [[unlikely]] {
-        std::rethrow_exception(__result.error());
-      }
-      auto __value = std::move(__result.value());
-      return __value;
-    }
     inline std::shared_ptr<Promise<void>> deleteUser() override {
       auto __result = _swiftPart.deleteUser();
       if (__result.hasError()) [[unlikely]] {

package/nitrogen/generated/ios/swift/Func_void_TradeExecutionResult.swift

@@ -0,0 +1,46 @@
+///
+/// Func_void_TradeExecutionResult.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/// Wraps a Swift `(_ result: TradeExecutionResult) -> Void` as a class.
+/// This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
+public final class Func_void_TradeExecutionResult {
+  public typealias bridge = margelo.nitro.rncandle.bridge.swift
+
+  private let closure: (_ result: TradeExecutionResult) -> Void
+
+  public init(_ closure: @escaping (_ result: TradeExecutionResult) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(result: TradeExecutionResult) {
+    self.closure(result)
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  @inline(__always)
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `Func_void_TradeExecutionResult`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_TradeExecutionResult>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer)
+    -> Func_void_TradeExecutionResult
+  {
+    return Unmanaged<Func_void_TradeExecutionResult>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/HybridRNCandleSpec.swift

@@ -18,6 +18,9 @@ public protocol HybridRNCandleSpec_protocol: HybridObject {
     showDynamicLoading: Bool, presentationBackground: PresentationBackground,
     presentationStyle: PresentationStyle, onSuccess: @escaping (_ account: LinkedAccount) -> Void)
     throws
+  func candleTradeExecutionSheet(
+    tradeQuote: TradeQuote, presentationBackground: PresentationBackground,
+    completion: @escaping (_ result: TradeExecutionResult) -> Void) throws
   func initialize(appUser: AppUser) throws
   func getLinkedAccounts() throws -> Promise<[LinkedAccount]>
   func getLinkedAccount(ref: LinkedAccountRef) throws -> Promise<LinkedAccount>
@@ -27,7 +30,6 @@ public protocol HybridRNCandleSpec_protocol: HybridObject {
   func getTrades(query: TradeQuery) throws -> Promise<[Trade]>
   func getTrade(ref: TradeRef) throws -> Promise<Trade>
   func getTradeQuotes(request: TradeQuoteRequest) throws -> Promise<[TradeQuote]>
-  func executeTrade(request: ExecuteTradeRequest) throws -> Promise<Trade>
   func deleteUser() throws -> Promise<Void>
   func getAvailableTools() throws -> Promise<[AnyMapHolder]>
   func executeTool(tool: ToolCall) throws -> Promise<String>

package/nitrogen/generated/ios/swift/HybridRNCandleSpec_cxx.swift

@@ -137,6 +137,29 @@ public class HybridRNCandleSpec_cxx {
     }
   }
 
+  @inline(__always)
+  public final func candleTradeExecutionSheet(
+    tradeQuote: TradeQuote, presentationBackground: Int32,
+    completion: bridge.Func_void_TradeExecutionResult
+  ) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.candleTradeExecutionSheet(
+        tradeQuote: tradeQuote,
+        presentationBackground: margelo.nitro.rncandle.PresentationBackground(
+          rawValue: presentationBackground)!,
+        completion: { () -> (TradeExecutionResult) -> Void in
+          let __wrappedFunction = bridge.wrap_Func_void_TradeExecutionResult(completion)
+          return { (__result: TradeExecutionResult) -> Void in
+            __wrappedFunction.call(__result)
+          }
+        }())
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+
   @inline(__always)
   public final func initialize(appUser: AppUser) -> bridge.Result_void_ {
     do {
@@ -355,27 +378,6 @@ public class HybridRNCandleSpec_cxx {
     }
   }
 
-  @inline(__always)
-  public final func executeTrade(request: ExecuteTradeRequest)
-    -> bridge.Result_std__shared_ptr_Promise_Trade___
-  {
-    do {
-      let __result = try self.__implementation.executeTrade(request: request)
-      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_Trade__ in
-        let __promise = bridge.create_std__shared_ptr_Promise_Trade__()
-        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_Trade__(__promise)
-        __result
-          .then({ __result in __promiseHolder.resolve(__result) })
-          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
-        return __promise
-      }()
-      return bridge.create_Result_std__shared_ptr_Promise_Trade___(__resultCpp)
-    } catch (let __error) {
-      let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_std__shared_ptr_Promise_Trade___(__exceptionPtr)
-    }
-  }
-
   @inline(__always)
   public final func deleteUser() -> bridge.Result_std__shared_ptr_Promise_void___ {
     do {

package/nitrogen/generated/ios/swift/TradeExecutionResult.swift

@@ -0,0 +1,82 @@
+///
+/// TradeExecutionResult.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/// Represents an instance of `TradeExecutionResult`, backed by a C++ struct.
+public typealias TradeExecutionResult = margelo.nitro.rncandle.TradeExecutionResult
+
+extension TradeExecutionResult {
+  private typealias bridge = margelo.nitro.rncandle.bridge.swift
+
+  /**
+   * Create a new instance of `TradeExecutionResult`.
+   */
+  public init(trade: Trade?, error: String?) {
+    self.init(
+      { () -> bridge.std__optional_Trade_ in
+        if let __unwrappedValue = trade {
+          return bridge.create_std__optional_Trade_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }(),
+      { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = error {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }())
+  }
+
+  public var trade: Trade? {
+    @inline(__always)
+    get {
+      return { () -> Trade? in
+        if let __unwrapped = self.__trade.value {
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__trade = { () -> bridge.std__optional_Trade_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_Trade_(__unwrappedValue)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+
+  public var error: String? {
+    @inline(__always)
+    get {
+      return { () -> String? in
+        if let __unwrapped = self.__error.value {
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__error = { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+}

package/nitrogen/generated/ios/swift/TradeQuote.swift

@@ -16,8 +16,8 @@ extension TradeQuote {
   /**
    * Create a new instance of `TradeQuote`.
    */
-  public init(lost: TradeAsset, gained: TradeAsset) {
-    self.init(lost, gained)
+  public init(lost: TradeAsset, gained: TradeAsset, context: String) {
+    self.init(lost, gained, std.string(context))
   }
 
   public var lost: TradeAsset {
@@ -41,4 +41,15 @@ extension TradeQuote {
       self.__gained = newValue
     }
   }
+
+  public var context: String {
+    @inline(__always)
+    get {
+      return String(self.__context)
+    }
+    @inline(__always)
+    set {
+      self.__context = std.string(newValue)
+    }
+  }
 }

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

@@ -15,6 +15,7 @@ namespace margelo::nitro::rncandle {
     // load custom methods/properties
     registerHybrids(this, [](Prototype& prototype) {
       prototype.registerHybridMethod("candleLinkSheet", &HybridRNCandleSpec::candleLinkSheet);
+      prototype.registerHybridMethod("candleTradeExecutionSheet", &HybridRNCandleSpec::candleTradeExecutionSheet);
       prototype.registerHybridMethod("initialize", &HybridRNCandleSpec::initialize);
       prototype.registerHybridMethod("getLinkedAccounts", &HybridRNCandleSpec::getLinkedAccounts);
       prototype.registerHybridMethod("getLinkedAccount", &HybridRNCandleSpec::getLinkedAccount);
@@ -24,7 +25,6 @@ namespace margelo::nitro::rncandle {
       prototype.registerHybridMethod("getTrades", &HybridRNCandleSpec::getTrades);
       prototype.registerHybridMethod("getTrade", &HybridRNCandleSpec::getTrade);
       prototype.registerHybridMethod("getTradeQuotes", &HybridRNCandleSpec::getTradeQuotes);
-      prototype.registerHybridMethod("executeTrade", &HybridRNCandleSpec::executeTrade);
       prototype.registerHybridMethod("deleteUser", &HybridRNCandleSpec::deleteUser);
       prototype.registerHybridMethod("getAvailableTools", &HybridRNCandleSpec::getAvailableTools);
       prototype.registerHybridMethod("executeTool", &HybridRNCandleSpec::executeTool);

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

@@ -21,6 +21,10 @@ namespace margelo::nitro::rncandle { enum class PresentationBackground; }
 namespace margelo::nitro::rncandle { enum class PresentationStyle; }
 // Forward declaration of `LinkedAccount` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct LinkedAccount; }
+// Forward declaration of `TradeQuote` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct TradeQuote; }
+// Forward declaration of `TradeExecutionResult` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct TradeExecutionResult; }
 // Forward declaration of `AppUser` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct AppUser; }
 // Forward declaration of `LinkedAccountRef` to properly resolve imports.
@@ -37,12 +41,8 @@ namespace margelo::nitro::rncandle { struct Trade; }
 namespace margelo::nitro::rncandle { struct TradeQuery; }
 // Forward declaration of `TradeRef` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct TradeRef; }
-// Forward declaration of `TradeQuote` to properly resolve imports.
-namespace margelo::nitro::rncandle { struct TradeQuote; }
 // Forward declaration of `TradeQuoteRequest` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct TradeQuoteRequest; }
-// Forward declaration of `ExecuteTradeRequest` to properly resolve imports.
-namespace margelo::nitro::rncandle { struct ExecuteTradeRequest; }
 // Forward declaration of `AnyMap` to properly resolve imports.
 namespace NitroModules { class AnyMap; }
 // Forward declaration of `ToolCall` to properly resolve imports.
@@ -56,6 +56,8 @@ namespace margelo::nitro::rncandle { struct ToolCall; }
 #include "PresentationStyle.hpp"
 #include <functional>
 #include "LinkedAccount.hpp"
+#include "TradeQuote.hpp"
+#include "TradeExecutionResult.hpp"
 #include "AppUser.hpp"
 #include <NitroModules/Promise.hpp>
 #include "LinkedAccountRef.hpp"
@@ -65,9 +67,7 @@ namespace margelo::nitro::rncandle { struct ToolCall; }
 #include "Trade.hpp"
 #include "TradeQuery.hpp"
 #include "TradeRef.hpp"
-#include "TradeQuote.hpp"
 #include "TradeQuoteRequest.hpp"
-#include "ExecuteTradeRequest.hpp"
 #include <NitroModules/AnyMap.hpp>
 #include "ToolCall.hpp"
 
@@ -103,6 +103,7 @@ namespace margelo::nitro::rncandle {
     public:
       // Methods
       virtual void candleLinkSheet(bool isPresented, const std::optional<std::vector<Service>>& services, double cornerRadius, const std::optional<std::string>& customerName, bool showDynamicLoading, PresentationBackground presentationBackground, PresentationStyle presentationStyle, const std::function<void(const LinkedAccount& /* account */)>& onSuccess) = 0;
+      virtual void candleTradeExecutionSheet(const TradeQuote& tradeQuote, PresentationBackground presentationBackground, const std::function<void(const TradeExecutionResult& /* result */)>& completion) = 0;
       virtual void initialize(const AppUser& appUser) = 0;
       virtual std::shared_ptr<Promise<std::vector<LinkedAccount>>> getLinkedAccounts() = 0;
       virtual std::shared_ptr<Promise<LinkedAccount>> getLinkedAccount(const LinkedAccountRef& ref) = 0;
@@ -112,7 +113,6 @@ namespace margelo::nitro::rncandle {
       virtual std::shared_ptr<Promise<std::vector<Trade>>> getTrades(const TradeQuery& query) = 0;
       virtual std::shared_ptr<Promise<Trade>> getTrade(const TradeRef& ref) = 0;
       virtual std::shared_ptr<Promise<std::vector<TradeQuote>>> getTradeQuotes(const TradeQuoteRequest& request) = 0;
-      virtual std::shared_ptr<Promise<Trade>> executeTrade(const ExecuteTradeRequest& request) = 0;
       virtual std::shared_ptr<Promise<void>> deleteUser() = 0;
       virtual std::shared_ptr<Promise<std::vector<std::shared_ptr<AnyMap>>>> getAvailableTools() = 0;
       virtual std::shared_ptr<Promise<std::string>> executeTool(const ToolCall& tool) = 0;

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

@@ -0,0 +1,76 @@
+///
+/// TradeExecutionResult.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
+
+// Forward declaration of `Trade` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct Trade; }
+
+#include <optional>
+#include "Trade.hpp"
+#include <string>
+
+namespace margelo::nitro::rncandle {
+
+  /**
+   * A struct which can be represented as a JavaScript object (TradeExecutionResult).
+   */
+  struct TradeExecutionResult {
+  public:
+    std::optional<Trade> trade     SWIFT_PRIVATE;
+    std::optional<std::string> error     SWIFT_PRIVATE;
+
+  public:
+    TradeExecutionResult() = default;
+    explicit TradeExecutionResult(std::optional<Trade> trade, std::optional<std::string> error): trade(trade), error(error) {}
+  };
+
+} // namespace margelo::nitro::rncandle
+
+namespace margelo::nitro {
+
+  using namespace margelo::nitro::rncandle;
+
+  // C++ TradeExecutionResult <> JS TradeExecutionResult (object)
+  template <>
+  struct JSIConverter<TradeExecutionResult> final {
+    static inline TradeExecutionResult fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return TradeExecutionResult(
+        JSIConverter<std::optional<Trade>>::fromJSI(runtime, obj.getProperty(runtime, "trade")),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, "error"))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const TradeExecutionResult& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, "trade", JSIConverter<std::optional<Trade>>::toJSI(runtime, arg.trade));
+      obj.setProperty(runtime, "error", JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.error));
+      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<std::optional<Trade>>::canConvert(runtime, obj.getProperty(runtime, "trade"))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, "error"))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -22,6 +22,7 @@
 namespace margelo::nitro::rncandle { struct TradeAsset; }
 
 #include "TradeAsset.hpp"
+#include <string>
 
 namespace margelo::nitro::rncandle {
 
@@ -32,10 +33,11 @@ namespace margelo::nitro::rncandle {
   public:
     TradeAsset lost     SWIFT_PRIVATE;
     TradeAsset gained     SWIFT_PRIVATE;
+    std::string context     SWIFT_PRIVATE;
 
   public:
     TradeQuote() = default;
-    explicit TradeQuote(TradeAsset lost, TradeAsset gained): lost(lost), gained(gained) {}
+    explicit TradeQuote(TradeAsset lost, TradeAsset gained, std::string context): lost(lost), gained(gained), context(context) {}
   };
 
 } // namespace margelo::nitro::rncandle
@@ -51,13 +53,15 @@ namespace margelo::nitro {
       jsi::Object obj = arg.asObject(runtime);
       return TradeQuote(
         JSIConverter<TradeAsset>::fromJSI(runtime, obj.getProperty(runtime, "lost")),
-        JSIConverter<TradeAsset>::fromJSI(runtime, obj.getProperty(runtime, "gained"))
+        JSIConverter<TradeAsset>::fromJSI(runtime, obj.getProperty(runtime, "gained")),
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "context"))
       );
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const TradeQuote& arg) {
       jsi::Object obj(runtime);
       obj.setProperty(runtime, "lost", JSIConverter<TradeAsset>::toJSI(runtime, arg.lost));
       obj.setProperty(runtime, "gained", JSIConverter<TradeAsset>::toJSI(runtime, arg.gained));
+      obj.setProperty(runtime, "context", JSIConverter<std::string>::toJSI(runtime, arg.context));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -67,6 +71,7 @@ namespace margelo::nitro {
       jsi::Object obj = value.getObject(runtime);
       if (!JSIConverter<TradeAsset>::canConvert(runtime, obj.getProperty(runtime, "lost"))) return false;
       if (!JSIConverter<TradeAsset>::canConvert(runtime, obj.getProperty(runtime, "gained"))) return false;
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "context"))) return false;
       return true;
     }
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-candle",
-  "version": "0.1.20",
+  "version": "0.1.21",
   "description": "Candle SDK for React Native",
   "main": "./lib/commonjs/index.js",
   "module": "./lib/module/index.js",