react-native-candle 0.1.19 → 0.1.21

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

@@ -15,13 +15,16 @@ 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);
       prototype.registerHybridMethod("unlinkAccount", &HybridRNCandleSpec::unlinkAccount);
       prototype.registerHybridMethod("getAssetAccounts", &HybridRNCandleSpec::getAssetAccounts);
+      prototype.registerHybridMethod("getAssetAccount", &HybridRNCandleSpec::getAssetAccount);
       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,22 +21,28 @@ 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.
+namespace margelo::nitro::rncandle { struct LinkedAccountRef; }
 // Forward declaration of `AssetAccount` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct AssetAccount; }
 // Forward declaration of `AssetAccountQuery` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct AssetAccountQuery; }
+// 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 `TradeQuery` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct TradeQuery; }
-// Forward declaration of `TradeQuote` to properly resolve imports.
-namespace margelo::nitro::rncandle { struct TradeQuote; }
+// Forward declaration of `TradeRef` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct TradeRef; }
 // 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.
@@ -50,15 +56,18 @@ 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"
 #include "AssetAccount.hpp"
 #include "AssetAccountQuery.hpp"
+#include "AssetAccountRef.hpp"
 #include "Trade.hpp"
 #include "TradeQuery.hpp"
-#include "TradeQuote.hpp"
+#include "TradeRef.hpp"
 #include "TradeQuoteRequest.hpp"
-#include "ExecuteTradeRequest.hpp"
 #include <NitroModules/AnyMap.hpp>
 #include "ToolCall.hpp"
 
@@ -94,13 +103,16 @@ 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<void>> unlinkAccount(const std::string& linkedAccountID) = 0;
+      virtual std::shared_ptr<Promise<LinkedAccount>> getLinkedAccount(const LinkedAccountRef& ref) = 0;
+      virtual std::shared_ptr<Promise<void>> unlinkAccount(const LinkedAccountRef& ref) = 0;
       virtual std::shared_ptr<Promise<std::vector<AssetAccount>>> getAssetAccounts(const AssetAccountQuery& query) = 0;
+      virtual std::shared_ptr<Promise<AssetAccount>> getAssetAccount(const AssetAccountRef& ref) = 0;
       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++/{ExecuteTradeRequest.hpp → LinkedAccountRef.hpp}

@@ -1,5 +1,5 @@
 ///
-/// ExecuteTradeRequest.hpp
+/// LinkedAccountRef.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © 2025 Marc Rousavy @ Margelo
@@ -25,16 +25,15 @@
 namespace margelo::nitro::rncandle {
 
   /**
-   * A struct which can be represented as a JavaScript object (ExecuteTradeRequest).
+   * A struct which can be represented as a JavaScript object (LinkedAccountRef).
    */
-  struct ExecuteTradeRequest {
+  struct LinkedAccountRef {
   public:
     std::string linkedAccountID     SWIFT_PRIVATE;
-    std::string context     SWIFT_PRIVATE;
 
   public:
-    ExecuteTradeRequest() = default;
-    explicit ExecuteTradeRequest(std::string linkedAccountID, std::string context): linkedAccountID(linkedAccountID), context(context) {}
+    LinkedAccountRef() = default;
+    explicit LinkedAccountRef(std::string linkedAccountID): linkedAccountID(linkedAccountID) {}
   };
 
 } // namespace margelo::nitro::rncandle
@@ -43,20 +42,18 @@ namespace margelo::nitro {
 
   using namespace margelo::nitro::rncandle;
 
-  // C++ ExecuteTradeRequest <> JS ExecuteTradeRequest (object)
+  // C++ LinkedAccountRef <> JS LinkedAccountRef (object)
   template <>
-  struct JSIConverter<ExecuteTradeRequest> final {
-    static inline ExecuteTradeRequest fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+  struct JSIConverter<LinkedAccountRef> final {
+    static inline LinkedAccountRef fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       jsi::Object obj = arg.asObject(runtime);
-      return ExecuteTradeRequest(
-        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "linkedAccountID")),
-        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "context"))
+      return LinkedAccountRef(
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "linkedAccountID"))
       );
     }
-    static inline jsi::Value toJSI(jsi::Runtime& runtime, const ExecuteTradeRequest& arg) {
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const LinkedAccountRef& arg) {
       jsi::Object obj(runtime);
       obj.setProperty(runtime, "linkedAccountID", JSIConverter<std::string>::toJSI(runtime, arg.linkedAccountID));
-      obj.setProperty(runtime, "context", JSIConverter<std::string>::toJSI(runtime, arg.context));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -65,7 +62,6 @@ namespace margelo::nitro {
       }
       jsi::Object obj = value.getObject(runtime);
       if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "linkedAccountID"))) return false;
-      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "context"))) return false;
       return true;
     }
   };

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

@@ -0,0 +1,77 @@
+///
+/// MarketTradeAssetRef.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
+
+
+
+#include <string>
+
+namespace margelo::nitro::rncandle {
+
+  /**
+   * A struct which can be represented as a JavaScript object (MarketTradeAssetRef).
+   */
+  struct MarketTradeAssetRef {
+  public:
+    std::string assetKind     SWIFT_PRIVATE;
+    std::string serviceTradeID     SWIFT_PRIVATE;
+    std::string linkedAccountID     SWIFT_PRIVATE;
+
+  public:
+    MarketTradeAssetRef() = default;
+    explicit MarketTradeAssetRef(std::string assetKind, std::string serviceTradeID, std::string linkedAccountID): assetKind(assetKind), serviceTradeID(serviceTradeID), linkedAccountID(linkedAccountID) {}
+  };
+
+} // namespace margelo::nitro::rncandle
+
+namespace margelo::nitro {
+
+  using namespace margelo::nitro::rncandle;
+
+  // C++ MarketTradeAssetRef <> JS MarketTradeAssetRef (object)
+  template <>
+  struct JSIConverter<MarketTradeAssetRef> final {
+    static inline MarketTradeAssetRef fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return MarketTradeAssetRef(
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "assetKind")),
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "serviceTradeID")),
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "linkedAccountID"))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const MarketTradeAssetRef& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, "assetKind", JSIConverter<std::string>::toJSI(runtime, arg.assetKind));
+      obj.setProperty(runtime, "serviceTradeID", JSIConverter<std::string>::toJSI(runtime, arg.serviceTradeID));
+      obj.setProperty(runtime, "linkedAccountID", JSIConverter<std::string>::toJSI(runtime, arg.linkedAccountID));
+      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::string>::canConvert(runtime, obj.getProperty(runtime, "assetKind"))) return false;
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "serviceTradeID"))) return false;
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "linkedAccountID"))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,69 @@
+///
+/// NothingAssetRef.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
+
+
+
+#include <string>
+
+namespace margelo::nitro::rncandle {
+
+  /**
+   * A struct which can be represented as a JavaScript object (NothingAssetRef).
+   */
+  struct NothingAssetRef {
+  public:
+    std::string assetKind     SWIFT_PRIVATE;
+
+  public:
+    NothingAssetRef() = default;
+    explicit NothingAssetRef(std::string assetKind): assetKind(assetKind) {}
+  };
+
+} // namespace margelo::nitro::rncandle
+
+namespace margelo::nitro {
+
+  using namespace margelo::nitro::rncandle;
+
+  // C++ NothingAssetRef <> JS NothingAssetRef (object)
+  template <>
+  struct JSIConverter<NothingAssetRef> final {
+    static inline NothingAssetRef fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return NothingAssetRef(
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "assetKind"))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const NothingAssetRef& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, "assetKind", JSIConverter<std::string>::toJSI(runtime, arg.assetKind));
+      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::string>::canConvert(runtime, obj.getProperty(runtime, "assetKind"))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,69 @@
+///
+/// OtherAssetRef.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
+
+
+
+#include <string>
+
+namespace margelo::nitro::rncandle {
+
+  /**
+   * A struct which can be represented as a JavaScript object (OtherAssetRef).
+   */
+  struct OtherAssetRef {
+  public:
+    std::string assetKind     SWIFT_PRIVATE;
+
+  public:
+    OtherAssetRef() = default;
+    explicit OtherAssetRef(std::string assetKind): assetKind(assetKind) {}
+  };
+
+} // namespace margelo::nitro::rncandle
+
+namespace margelo::nitro {
+
+  using namespace margelo::nitro::rncandle;
+
+  // C++ OtherAssetRef <> JS OtherAssetRef (object)
+  template <>
+  struct JSIConverter<OtherAssetRef> final {
+    static inline OtherAssetRef fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return OtherAssetRef(
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "assetKind"))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const OtherAssetRef& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, "assetKind", JSIConverter<std::string>::toJSI(runtime, arg.assetKind));
+      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::string>::canConvert(runtime, obj.getProperty(runtime, "assetKind"))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

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

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

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/nitrogen/generated/shared/c++/TradeRef.hpp

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