react-native-candle 0.1.27 → 0.1.29

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

@@ -29,18 +29,24 @@ namespace margelo::nitro::rncandle { struct TradeExecutionResult; }
 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 `AssetAccountsResponse` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct AssetAccountsResponse; }
 // Forward declaration of `AssetAccountQuery` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct AssetAccountQuery; }
+// Forward declaration of `AssetAccount` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct AssetAccount; }
 // 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 `TradesResponse` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct TradesResponse; }
 // Forward declaration of `TradeQuery` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct TradeQuery; }
+// Forward declaration of `Trade` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct Trade; }
 // Forward declaration of `TradeRef` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct TradeRef; }
+// Forward declaration of `TradeQuotesResponse` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct TradeQuotesResponse; }
 // Forward declaration of `TradeQuoteRequest` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct TradeQuoteRequest; }
 // Forward declaration of `AnyMap` to properly resolve imports.
@@ -61,12 +67,15 @@ namespace margelo::nitro::rncandle { struct ToolCall; }
 #include "AppUser.hpp"
 #include <NitroModules/Promise.hpp>
 #include "LinkedAccountRef.hpp"
-#include "AssetAccount.hpp"
+#include "AssetAccountsResponse.hpp"
 #include "AssetAccountQuery.hpp"
+#include "AssetAccount.hpp"
 #include "AssetAccountRef.hpp"
-#include "Trade.hpp"
+#include "TradesResponse.hpp"
 #include "TradeQuery.hpp"
+#include "Trade.hpp"
 #include "TradeRef.hpp"
+#include "TradeQuotesResponse.hpp"
 #include "TradeQuoteRequest.hpp"
 #include <NitroModules/AnyMap.hpp>
 #include "ToolCall.hpp"
@@ -104,15 +113,15 @@ namespace margelo::nitro::rncandle {
       // 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 void initialize(const AppUser& appUser, const std::optional<std::string>& accessGroup) = 0;
       virtual std::shared_ptr<Promise<std::vector<LinkedAccount>>> getLinkedAccounts() = 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<AssetAccountsResponse>> 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<TradesResponse>> 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<TradeQuotesResponse>> getTradeQuotes(const TradeQuoteRequest& 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++/LinkedAccountStatusRef.hpp

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

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

@@ -0,0 +1,82 @@
+///
+/// StatePayload.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::rncandle {
+
+  /**
+   * An enum which can be represented as a JavaScript union (StatePayload).
+   */
+  enum class StatePayload {
+    ACTIVE      SWIFT_NAME(active) = 0,
+    INACTIVE      SWIFT_NAME(inactive) = 1,
+    UNAVAILABLE      SWIFT_NAME(unavailable) = 2,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::rncandle
+
+namespace margelo::nitro {
+
+  using namespace margelo::nitro::rncandle;
+
+  // C++ StatePayload <> JS StatePayload (union)
+  template <>
+  struct JSIConverter<StatePayload> final {
+    static inline StatePayload 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("active"): return StatePayload::ACTIVE;
+        case hashString("inactive"): return StatePayload::INACTIVE;
+        case hashString("unavailable"): return StatePayload::UNAVAILABLE;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum StatePayload - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, StatePayload arg) {
+      switch (arg) {
+        case StatePayload::ACTIVE: return JSIConverter<std::string>::toJSI(runtime, "active");
+        case StatePayload::INACTIVE: return JSIConverter<std::string>::toJSI(runtime, "inactive");
+        case StatePayload::UNAVAILABLE: return JSIConverter<std::string>::toJSI(runtime, "unavailable");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert StatePayload 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("active"):
+        case hashString("inactive"):
+        case hashString("unavailable"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -34,10 +34,11 @@ namespace margelo::nitro::rncandle {
     TradeAsset lost     SWIFT_PRIVATE;
     TradeAsset gained     SWIFT_PRIVATE;
     std::string context     SWIFT_PRIVATE;
+    std::string expirationDateTime     SWIFT_PRIVATE;
 
   public:
     TradeQuote() = default;
-    explicit TradeQuote(TradeAsset lost, TradeAsset gained, std::string context): lost(lost), gained(gained), context(context) {}
+    explicit TradeQuote(TradeAsset lost, TradeAsset gained, std::string context, std::string expirationDateTime): lost(lost), gained(gained), context(context), expirationDateTime(expirationDateTime) {}
   };
 
 } // namespace margelo::nitro::rncandle
@@ -54,7 +55,8 @@ namespace margelo::nitro {
       return TradeQuote(
         JSIConverter<TradeAsset>::fromJSI(runtime, obj.getProperty(runtime, "lost")),
         JSIConverter<TradeAsset>::fromJSI(runtime, obj.getProperty(runtime, "gained")),
-        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "context"))
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "context")),
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "expirationDateTime"))
       );
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const TradeQuote& arg) {
@@ -62,6 +64,7 @@ namespace margelo::nitro {
       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));
+      obj.setProperty(runtime, "expirationDateTime", JSIConverter<std::string>::toJSI(runtime, arg.expirationDateTime));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -72,6 +75,7 @@ namespace margelo::nitro {
       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;
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "expirationDateTime"))) return false;
       return true;
     }
   };

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

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

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

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

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

@@ -48,12 +48,14 @@ namespace margelo::nitro::rncandle {
     Coordinates destinationCoordinates     SWIFT_PRIVATE;
     Address destinationAddress     SWIFT_PRIVATE;
     double seats     SWIFT_PRIVATE;
+    std::string departureDateTime     SWIFT_PRIVATE;
+    std::string arrivalDateTime     SWIFT_PRIVATE;
     std::string linkedAccountID     SWIFT_PRIVATE;
     Service service     SWIFT_PRIVATE;
 
   public:
     TransportAsset() = default;
-    explicit TransportAsset(std::string assetKind, std::string serviceTradeID, std::string serviceAssetID, std::string name, std::string description, std::string imageURL, Coordinates originCoordinates, Address originAddress, Coordinates destinationCoordinates, Address destinationAddress, double seats, std::string linkedAccountID, Service service): assetKind(assetKind), serviceTradeID(serviceTradeID), serviceAssetID(serviceAssetID), name(name), description(description), imageURL(imageURL), originCoordinates(originCoordinates), originAddress(originAddress), destinationCoordinates(destinationCoordinates), destinationAddress(destinationAddress), seats(seats), linkedAccountID(linkedAccountID), service(service) {}
+    explicit TransportAsset(std::string assetKind, std::string serviceTradeID, std::string serviceAssetID, std::string name, std::string description, std::string imageURL, Coordinates originCoordinates, Address originAddress, Coordinates destinationCoordinates, Address destinationAddress, double seats, std::string departureDateTime, std::string arrivalDateTime, std::string linkedAccountID, Service service): assetKind(assetKind), serviceTradeID(serviceTradeID), serviceAssetID(serviceAssetID), name(name), description(description), imageURL(imageURL), originCoordinates(originCoordinates), originAddress(originAddress), destinationCoordinates(destinationCoordinates), destinationAddress(destinationAddress), seats(seats), departureDateTime(departureDateTime), arrivalDateTime(arrivalDateTime), linkedAccountID(linkedAccountID), service(service) {}
   };
 
 } // namespace margelo::nitro::rncandle
@@ -79,6 +81,8 @@ namespace margelo::nitro {
         JSIConverter<Coordinates>::fromJSI(runtime, obj.getProperty(runtime, "destinationCoordinates")),
         JSIConverter<Address>::fromJSI(runtime, obj.getProperty(runtime, "destinationAddress")),
         JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, "seats")),
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "departureDateTime")),
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "arrivalDateTime")),
         JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "linkedAccountID")),
         JSIConverter<Service>::fromJSI(runtime, obj.getProperty(runtime, "service"))
       );
@@ -96,6 +100,8 @@ namespace margelo::nitro {
       obj.setProperty(runtime, "destinationCoordinates", JSIConverter<Coordinates>::toJSI(runtime, arg.destinationCoordinates));
       obj.setProperty(runtime, "destinationAddress", JSIConverter<Address>::toJSI(runtime, arg.destinationAddress));
       obj.setProperty(runtime, "seats", JSIConverter<double>::toJSI(runtime, arg.seats));
+      obj.setProperty(runtime, "departureDateTime", JSIConverter<std::string>::toJSI(runtime, arg.departureDateTime));
+      obj.setProperty(runtime, "arrivalDateTime", JSIConverter<std::string>::toJSI(runtime, arg.arrivalDateTime));
       obj.setProperty(runtime, "linkedAccountID", JSIConverter<std::string>::toJSI(runtime, arg.linkedAccountID));
       obj.setProperty(runtime, "service", JSIConverter<Service>::toJSI(runtime, arg.service));
       return obj;
@@ -116,6 +122,8 @@ namespace margelo::nitro {
       if (!JSIConverter<Coordinates>::canConvert(runtime, obj.getProperty(runtime, "destinationCoordinates"))) return false;
       if (!JSIConverter<Address>::canConvert(runtime, obj.getProperty(runtime, "destinationAddress"))) return false;
       if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, "seats"))) return false;
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "departureDateTime"))) return false;
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "arrivalDateTime"))) return false;
       if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "linkedAccountID"))) return false;
       if (!JSIConverter<Service>::canConvert(runtime, obj.getProperty(runtime, "service"))) return false;
       return true;

package/package.json

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

package/src/index.ts

@@ -38,16 +38,19 @@ import type {
   FiatAssetRef,
   MarketTradeAssetRef,
   TradeAssetRef as InternalTradeAssetRef,
+  LinkedAccountStatusRef,
+  Coordinates,
+  Address,
 } from "./specs/RNCandle.nitro";
 
 export class CandleClient {
   private candle: RNCandle;
 
-  constructor(appUser: AppUser) {
+  constructor(appUser: AppUser, accessGroup?: string) {
     const CandleHybridObject =
       NitroModules.createHybridObject<RNCandle>("RNCandle");
     this.candle = CandleHybridObject;
-    this.candle.initialize(appUser);
+    this.candle.initialize(appUser, accessGroup);
   }
 
   public presentTradeExecutionSheet(input: {
@@ -182,11 +185,18 @@ export class CandleClient {
     return this.candle.executeTool(tool);
   }
 
-  public async getAssetAccounts(
-    query: AssetAccountQuery = {}
-  ): Promise<AssetAccount[]> {
-    const accounts = await this.candle.getAssetAccounts(query);
-    return accounts.map((account) => this.convertToAssetAccount(account));
+  public async getAssetAccounts(query: AssetAccountQuery = {}): Promise<{
+    assetAccounts: AssetAccount[];
+    linkedAccounts: LinkedAccountStatusRef[];
+  }> {
+    const { assetAccounts, linkedAccounts } =
+      await this.candle.getAssetAccounts(query);
+    return {
+      assetAccounts: assetAccounts.map((account) =>
+        this.convertToAssetAccount(account)
+      ),
+      linkedAccounts,
+    };
   }
 
   public async getAssetAccount(ref: AssetAccountRef): Promise<AssetAccount> {
@@ -194,15 +204,21 @@ export class CandleClient {
     return this.convertToAssetAccount(account);
   }
 
-  public async getTrades(query: TradeQuery = {}): Promise<Trade[]> {
-    const trades = await this.candle.getTrades(query);
-    return trades.map(({ dateTime, counterparty, gained, lost, state }) => ({
-      dateTime,
-      state,
-      counterparty: this.convertToCounterparty(counterparty),
-      lost: this.convertTradeAsset(lost),
-      gained: this.convertTradeAsset(gained),
-    }));
+  public async getTrades(query: TradeQuery = {}): Promise<{
+    trades: Trade[];
+    linkedAccounts: LinkedAccountStatusRef[];
+  }> {
+    const { trades, linkedAccounts } = await this.candle.getTrades(query);
+    return {
+      trades: trades.map(({ dateTime, counterparty, gained, lost, state }) => ({
+        dateTime,
+        state,
+        counterparty: this.convertToCounterparty(counterparty),
+        lost: this.convertTradeAsset(lost),
+        gained: this.convertTradeAsset(gained),
+      })),
+      linkedAccounts,
+    };
   }
 
   public async getTrade(input: {
@@ -231,7 +247,10 @@ export class CandleClient {
       | ({ assetKind: "transport" } & TransportAssetQuoteRequest)
       | ({ assetKind: "fiat" } & FiatAssetQuoteRequest)
       | ({ assetKind: "stock" | "crypto" } & MarketAssetQuoteRequest);
-  }): Promise<TradeQuote[]> {
+  }): Promise<{
+    tradeQuotes: TradeQuote[];
+    linkedAccounts: LinkedAccountStatusRef[];
+  }> {
     let gainedRequest: TradeAssetQuoteRequest;
 
     switch (request.gained.assetKind) {
@@ -250,18 +269,22 @@ export class CandleClient {
         break;
     }
 
-    const quotes = await this.candle.getTradeQuotes({
+    const { linkedAccounts, tradeQuotes } = await this.candle.getTradeQuotes({
       linkedAccountIDs: request.linkedAccountIDs,
       gained: gainedRequest,
     });
 
-    return quotes.map((quote) => {
-      return {
-        gained: this.convertTradeAsset(quote.gained),
-        lost: this.convertTradeAsset(quote.lost),
-        context: quote.context,
-      };
-    });
+    return {
+      tradeQuotes: tradeQuotes.map((quote) => {
+        return {
+          gained: this.convertTradeAsset(quote.gained),
+          lost: this.convertTradeAsset(quote.lost),
+          context: quote.context,
+          expirationDateTime: quote.expirationDateTime,
+        };
+      }),
+      linkedAccounts,
+    };
   }
 
   private convertTradeAssetRef(
@@ -335,6 +358,7 @@ export class CandleClient {
       context,
       gained: this.toInternalTradeAsset(gained),
       lost: this.toInternalTradeAsset(lost),
+      expirationDateTime: tradeQuote.expirationDateTime,
     };
   }
 
@@ -455,6 +479,7 @@ type TradeQuote = {
   gained: TradeAsset;
   lost: TradeAsset;
   context: string;
+  expirationDateTime: string;
 };
 
 type TradeQueryAssetKind =
@@ -516,4 +541,6 @@ export type {
   Counterparty,
   AssetAccount,
   TradeQuote,
+  Coordinates,
+  Address,
 };