react-native-candle 0.1.19 → 0.1.21

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

@@ -26,8 +26,44 @@ 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.
+namespace margelo::nitro::rncandle { struct LinkedAccountRef; }
 // Forward declaration of `AssetAccount` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct AssetAccount; }
 // Forward declaration of `LegalAccountKind` to properly resolve imports.
@@ -48,40 +84,24 @@ namespace margelo::nitro::rncandle { struct MarketAccountDetails; }
 namespace margelo::nitro::rncandle { struct AssetAccountQuery; }
 // Forward declaration of `AssetAccountKind` to properly resolve imports.
 namespace margelo::nitro::rncandle { enum class AssetAccountKind; }
-// 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 `AssetAccountRef` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct AssetAccountRef; }
 // 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 `TradeAssetRef` to properly resolve imports.
+namespace margelo::nitro::rncandle { struct TradeAssetRef; }
+// 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; }
 // Forward declaration of `TradeQuoteRequest` to properly resolve imports.
 namespace margelo::nitro::rncandle { struct TradeQuoteRequest; }
 // Forward declaration of `TradeAssetQuoteRequest` to properly resolve imports.
@@ -94,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.
@@ -112,8 +130,26 @@ 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"
 #include "AssetAccount.hpp"
 #include "LegalAccountKind.hpp"
 #include "AssetAccountDetails.hpp"
@@ -124,30 +160,21 @@ namespace margelo::nitro::rncandle { struct ToolCall; }
 #include "MarketAccountDetails.hpp"
 #include "AssetAccountQuery.hpp"
 #include "AssetAccountKind.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 "AssetAccountRef.hpp"
 #include "TradeQuery.hpp"
-#include "TradeQuote.hpp"
+#include "TradeRef.hpp"
+#include "TradeAssetRef.hpp"
+#include "FiatAssetRef.hpp"
+#include "MarketTradeAssetRef.hpp"
+#include "TransportAssetRef.hpp"
+#include "OtherAssetRef.hpp"
+#include "NothingAssetRef.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"
 
@@ -196,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]] {
@@ -210,8 +243,16 @@ namespace margelo::nitro::rncandle {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline std::shared_ptr<Promise<void>> unlinkAccount(const std::string& linkedAccountID) override {
-      auto __result = _swiftPart.unlinkAccount(linkedAccountID);
+    inline std::shared_ptr<Promise<LinkedAccount>> getLinkedAccount(const LinkedAccountRef& ref) override {
+      auto __result = _swiftPart.getLinkedAccount(ref);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> unlinkAccount(const LinkedAccountRef& ref) override {
+      auto __result = _swiftPart.unlinkAccount(ref);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
@@ -226,6 +267,14 @@ namespace margelo::nitro::rncandle {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline std::shared_ptr<Promise<AssetAccount>> getAssetAccount(const AssetAccountRef& ref) override {
+      auto __result = _swiftPart.getAssetAccount(ref);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
     inline std::shared_ptr<Promise<std::vector<Trade>>> getTrades(const TradeQuery& query) override {
       auto __result = _swiftPart.getTrades(query);
       if (__result.hasError()) [[unlikely]] {
@@ -234,16 +283,16 @@ namespace margelo::nitro::rncandle {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline std::shared_ptr<Promise<std::vector<TradeQuote>>> getTradeQuotes(const TradeQuoteRequest& request) override {
-      auto __result = _swiftPart.getTradeQuotes(request);
+    inline std::shared_ptr<Promise<Trade>> getTrade(const TradeRef& ref) override {
+      auto __result = _swiftPart.getTrade(ref);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline std::shared_ptr<Promise<Trade>> executeTrade(const ExecuteTradeRequest& request) override {
-      auto __result = _swiftPart.executeTrade(request);
+    inline std::shared_ptr<Promise<std::vector<TradeQuote>>> getTradeQuotes(const TradeQuoteRequest& request) override {
+      auto __result = _swiftPart.getTradeQuotes(request);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }

package/nitrogen/generated/ios/swift/AssetAccountRef.swift

@@ -0,0 +1,55 @@
+///
+/// AssetAccountRef.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 `AssetAccountRef`, backed by a C++ struct.
+public typealias AssetAccountRef = margelo.nitro.rncandle.AssetAccountRef
+
+extension AssetAccountRef {
+  private typealias bridge = margelo.nitro.rncandle.bridge.swift
+
+  /**
+   * Create a new instance of `AssetAccountRef`.
+   */
+  public init(linkedAccountID: String, assetKind: String, serviceAccountID: String) {
+    self.init(std.string(linkedAccountID), std.string(assetKind), std.string(serviceAccountID))
+  }
+
+  public var linkedAccountID: String {
+    @inline(__always)
+    get {
+      return String(self.__linkedAccountID)
+    }
+    @inline(__always)
+    set {
+      self.__linkedAccountID = std.string(newValue)
+    }
+  }
+
+  public var assetKind: String {
+    @inline(__always)
+    get {
+      return String(self.__assetKind)
+    }
+    @inline(__always)
+    set {
+      self.__assetKind = std.string(newValue)
+    }
+  }
+
+  public var serviceAccountID: String {
+    @inline(__always)
+    get {
+      return String(self.__serviceAccountID)
+    }
+    @inline(__always)
+    set {
+      self.__serviceAccountID = std.string(newValue)
+    }
+  }
+}

package/nitrogen/generated/ios/swift/FiatAssetRef.swift

@@ -0,0 +1,75 @@
+///
+/// FiatAssetRef.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 `FiatAssetRef`, backed by a C++ struct.
+public typealias FiatAssetRef = margelo.nitro.rncandle.FiatAssetRef
+
+extension FiatAssetRef {
+  private typealias bridge = margelo.nitro.rncandle.bridge.swift
+
+  /**
+   * Create a new instance of `FiatAssetRef`.
+   */
+  public init(assetKind: String, serviceTradeID: String?, linkedAccountID: String) {
+    self.init(
+      std.string(assetKind),
+      { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = serviceTradeID {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }(), std.string(linkedAccountID))
+  }
+
+  public var assetKind: String {
+    @inline(__always)
+    get {
+      return String(self.__assetKind)
+    }
+    @inline(__always)
+    set {
+      self.__assetKind = std.string(newValue)
+    }
+  }
+
+  public var serviceTradeID: String? {
+    @inline(__always)
+    get {
+      return { () -> String? in
+        if let __unwrapped = self.__serviceTradeID.value {
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__serviceTradeID = { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+
+  public var linkedAccountID: String {
+    @inline(__always)
+    get {
+      return String(self.__linkedAccountID)
+    }
+    @inline(__always)
+    set {
+      self.__linkedAccountID = std.string(newValue)
+    }
+  }
+}

package/nitrogen/generated/ios/swift/Func_void_AssetAccount.swift

@@ -0,0 +1,44 @@
+///
+/// Func_void_AssetAccount.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 `(_ value: AssetAccount) -> 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_AssetAccount {
+  public typealias bridge = margelo.nitro.rncandle.bridge.swift
+
+  private let closure: (_ value: AssetAccount) -> Void
+
+  public init(_ closure: @escaping (_ value: AssetAccount) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(value: AssetAccount) {
+    self.closure(value)
+  }
+
+  /**
+   * 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_AssetAccount`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_AssetAccount>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_AssetAccount {
+    return Unmanaged<Func_void_AssetAccount>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/Func_void_LinkedAccount.swift

@@ -7,20 +7,20 @@
 
 import NitroModules
 
-/// Wraps a Swift `(_ account: LinkedAccount) -> Void` as a class.
+/// Wraps a Swift `(_ value: LinkedAccount) -> 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_LinkedAccount {
   public typealias bridge = margelo.nitro.rncandle.bridge.swift
 
-  private let closure: (_ account: LinkedAccount) -> Void
+  private let closure: (_ value: LinkedAccount) -> Void
 
-  public init(_ closure: @escaping (_ account: LinkedAccount) -> Void) {
+  public init(_ closure: @escaping (_ value: LinkedAccount) -> Void) {
     self.closure = closure
   }
 
   @inline(__always)
-  public func call(account: LinkedAccount) {
-    self.closure(account)
+  public func call(value: LinkedAccount) {
+    self.closure(value)
   }
 
   /**

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,13 +18,18 @@ 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 unlinkAccount(linkedAccountID: String) throws -> Promise<Void>
+  func getLinkedAccount(ref: LinkedAccountRef) throws -> Promise<LinkedAccount>
+  func unlinkAccount(ref: LinkedAccountRef) throws -> Promise<Void>
   func getAssetAccounts(query: AssetAccountQuery) throws -> Promise<[AssetAccount]>
+  func getAssetAccount(ref: AssetAccountRef) throws -> Promise<AssetAccount>
   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 {
@@ -181,12 +204,32 @@ public class HybridRNCandleSpec_cxx {
   }
 
   @inline(__always)
-  public final func unlinkAccount(linkedAccountID: std.string)
+  public final func getLinkedAccount(ref: LinkedAccountRef)
+    -> bridge.Result_std__shared_ptr_Promise_LinkedAccount___
+  {
+    do {
+      let __result = try self.__implementation.getLinkedAccount(ref: ref)
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_LinkedAccount__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_LinkedAccount__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_LinkedAccount__(__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_LinkedAccount___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_LinkedAccount___(__exceptionPtr)
+    }
+  }
+
+  @inline(__always)
+  public final func unlinkAccount(ref: LinkedAccountRef)
     -> bridge.Result_std__shared_ptr_Promise_void___
   {
     do {
-      let __result = try self.__implementation.unlinkAccount(
-        linkedAccountID: String(linkedAccountID))
+      let __result = try self.__implementation.unlinkAccount(ref: ref)
       let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
         let __promise = bridge.create_std__shared_ptr_Promise_void__()
         let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
@@ -234,6 +277,27 @@ public class HybridRNCandleSpec_cxx {
     }
   }
 
+  @inline(__always)
+  public final func getAssetAccount(ref: AssetAccountRef)
+    -> bridge.Result_std__shared_ptr_Promise_AssetAccount___
+  {
+    do {
+      let __result = try self.__implementation.getAssetAccount(ref: ref)
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_AssetAccount__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_AssetAccount__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_AssetAccount__(__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_AssetAccount___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_AssetAccount___(__exceptionPtr)
+    }
+  }
+
   @inline(__always)
   public final func getTrades(query: TradeQuery)
     -> bridge.Result_std__shared_ptr_Promise_std__vector_Trade____
@@ -264,6 +328,25 @@ public class HybridRNCandleSpec_cxx {
     }
   }
 
+  @inline(__always)
+  public final func getTrade(ref: TradeRef) -> bridge.Result_std__shared_ptr_Promise_Trade___ {
+    do {
+      let __result = try self.__implementation.getTrade(ref: ref)
+      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 getTradeQuotes(request: TradeQuoteRequest)
     -> bridge.Result_std__shared_ptr_Promise_std__vector_TradeQuote____
@@ -295,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 {