react-native-candle 0.1.19 → 0.1.21

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

@@ -0,0 +1,77 @@
+///
+/// TransportAssetRef.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 (TransportAssetRef).
+   */
+  struct TransportAssetRef {
+  public:
+    std::string assetKind     SWIFT_PRIVATE;
+    std::string serviceTradeID     SWIFT_PRIVATE;
+    std::string linkedAccountID     SWIFT_PRIVATE;
+
+  public:
+    TransportAssetRef() = default;
+    explicit TransportAssetRef(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++ TransportAssetRef <> JS TransportAssetRef (object)
+  template <>
+  struct JSIConverter<TransportAssetRef> final {
+    static inline TransportAssetRef fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return TransportAssetRef(
+        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 TransportAssetRef& 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/package.json

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

package/src/index.ts

@@ -1,7 +1,7 @@
 import { NitroModules } from "react-native-nitro-modules";
 import type {
   AppUser,
-  AssetAccount as NitroAssetAccount,
+  AssetAccount as InternalAssetAccount,
   AssetAccountQuery,
   FiatAsset,
   FiatAssetQuoteRequest,
@@ -17,7 +17,8 @@ import type {
   Service,
   TradeAsset as InternalTradeAsset,
   TradeAssetQuoteRequest,
-  TradeQuery,
+  TradeQuery as InternalTradeQuery,
+  TradeQuote as InternalTradeQuote,
   TransportAsset,
   TransportAssetQuoteRequest,
   LegalAccountKind,
@@ -29,7 +30,14 @@ import type {
   ServiceCounterparty,
   Counterparty as InternalCounterparty,
   ActiveLinkedAccountDetails,
-  ExecuteTradeRequest,
+  AssetAccountRef,
+  LinkedAccountRef,
+  NothingAssetRef,
+  TransportAssetRef,
+  OtherAssetRef,
+  FiatAssetRef,
+  MarketTradeAssetRef,
+  TradeAssetRef as InternalTradeAssetRef,
 } from "./specs/RNCandle.nitro";
 
 export class CandleClient {
@@ -42,6 +50,41 @@ export class CandleClient {
     this.candle.initialize(appUser);
   }
 
+  public presentTradeExecutionSheet(input: {
+    tradeQuote: TradeQuote;
+    presentationBackground?: PresentationBackground;
+    completion?: (
+      result: ({ kind: "success" } & Trade) | { kind: "failure"; error: string }
+    ) => void;
+  }): void {
+    const quote = this.convertTradeQuote(input.tradeQuote);
+    this.candle.candleTradeExecutionSheet(
+      quote,
+      input.presentationBackground ?? "default",
+      (result) => {
+        if (input.completion === undefined) {
+          return;
+        }
+        if (result.trade !== undefined) {
+          input.completion({
+            kind: "success",
+            ...result.trade,
+            counterparty: this.convertToCounterparty(result.trade.counterparty),
+            lost: this.convertTradeAsset(result.trade.lost),
+            gained: this.convertTradeAsset(result.trade.gained),
+          });
+        } else {
+          if (result.error === undefined) {
+            throw new Error(
+              "Internal Candle Error: corrupted trade execution result."
+            );
+          }
+          input.completion({ kind: "failure", error: result.error });
+        }
+      }
+    );
+  }
+
   public presentCandleLinkSheet({
     services = undefined,
     cornerRadius = 24,
@@ -106,8 +149,12 @@ export class CandleClient {
     });
   }
 
-  public async unlinkAccount(linkedAccountID: string): Promise<void> {
-    await this.candle.unlinkAccount(linkedAccountID);
+  public async getLinkedAccount(ref: LinkedAccountRef): Promise<LinkedAccount> {
+    return this.candle.getLinkedAccount(ref);
+  }
+
+  public async unlinkAccount(path: LinkedAccountRef): Promise<void> {
+    await this.candle.unlinkAccount(path);
   }
 
   public async deleteUser(): Promise<void> {
@@ -118,17 +165,6 @@ export class CandleClient {
     return this.candle.getAvailableTools();
   }
 
-  public async executeTrade(request: ExecuteTradeRequest): Promise<Trade> {
-    const result = await this.candle.executeTrade(request);
-    return {
-      dateTime: result.dateTime,
-      state: result.state,
-      counterparty: this.convertToCounterparty(result.counterparty),
-      lost: this.convertTradeAsset(result.lost),
-      gained: this.convertTradeAsset(result.gained),
-    };
-  }
-
   public async executeTool(tool: {
     name: string;
     arguments: string;
@@ -143,13 +179,12 @@ export class CandleClient {
     return accounts.map((account) => this.convertToAssetAccount(account));
   }
 
-  public async getTrades(
-    query: {
-      gainedAssetKind?: TradeQueryAssetKind;
-      lostAssetKind?: TradeQueryAssetKind;
-      counterpartyKind?: "merchant" | "user" | "service";
-    } & TradeQuery = {}
-  ): Promise<Trade[]> {
+  public async getAssetAccount(ref: AssetAccountRef): Promise<AssetAccount> {
+    const account = await this.candle.getAssetAccount(ref);
+    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,
@@ -160,6 +195,23 @@ export class CandleClient {
     }));
   }
 
+  public async getTrade(input: {
+    lost: TradeAssetRef;
+    gained: TradeAssetRef;
+  }): Promise<Trade> {
+    const trade = await this.candle.getTrade({
+      lost: this.convertTradeAssetRef(input.lost),
+      gained: this.convertTradeAssetRef(input.gained),
+    });
+    return {
+      dateTime: trade.dateTime,
+      state: trade.state,
+      counterparty: this.convertToCounterparty(trade.counterparty),
+      lost: this.convertTradeAsset(trade.lost),
+      gained: this.convertTradeAsset(trade.gained),
+    };
+  }
+
   public async getTradeQuotes(request: {
     linkedAccountIDs?: string;
     gained:
@@ -169,12 +221,7 @@ export class CandleClient {
       | ({ assetKind: "transport" } & TransportAssetQuoteRequest)
       | ({ assetKind: "fiat" } & FiatAssetQuoteRequest)
       | ({ assetKind: "stock" | "crypto" } & MarketAssetQuoteRequest);
-  }): Promise<
-    {
-      gained: TradeAsset;
-      lost: TradeAsset;
-    }[]
-  > {
+  }): Promise<TradeQuote[]> {
     let gainedRequest: TradeAssetQuoteRequest;
 
     switch (request.gained.assetKind) {
@@ -202,10 +249,85 @@ export class CandleClient {
       return {
         gained: this.convertTradeAsset(quote.gained),
         lost: this.convertTradeAsset(quote.lost),
+        context: quote.context,
       };
     });
   }
 
+  private convertTradeAssetRef(
+    tradeAssetRef: TradeAssetRef
+  ): InternalTradeAssetRef {
+    switch (tradeAssetRef.assetKind) {
+      case "fiat":
+        return {
+          fiatAssetRef: {
+            assetKind: "fiat",
+            linkedAccountID: tradeAssetRef.linkedAccountID,
+            serviceTradeID: tradeAssetRef.serviceTradeID,
+          },
+        };
+      case "stock":
+      case "crypto":
+        return {
+          marketTradeAssetRef: {
+            assetKind: tradeAssetRef.assetKind,
+            linkedAccountID: tradeAssetRef.linkedAccountID,
+            serviceTradeID: tradeAssetRef.serviceTradeID,
+          },
+        };
+      case "transport":
+        return {
+          transportAssetRef: {
+            assetKind: "transport",
+            linkedAccountID: tradeAssetRef.linkedAccountID,
+            serviceTradeID: tradeAssetRef.serviceTradeID,
+          },
+        };
+      case "other":
+        return {
+          otherAssetRef: {
+            assetKind: "other",
+          },
+        };
+      case "nothing":
+        return {
+          nothingAssetRef: {
+            assetKind: "nothing",
+          },
+        };
+    }
+  }
+
+  private toInternalTradeAsset(asset: TradeAsset): InternalTradeAsset {
+    switch (asset.assetKind) {
+      case "fiat":
+        return { fiatAsset: asset };
+      case "stock":
+      case "crypto":
+        return {
+          marketTradeAsset: {
+            ...asset,
+            assetKind: asset.assetKind,
+          },
+        };
+      case "transport":
+        return { transportAsset: asset };
+      case "other":
+        return { otherAsset: asset };
+      case "nothing":
+        return { nothingAsset: asset };
+    }
+  }
+
+  private convertTradeQuote(tradeQuote: TradeQuote): InternalTradeQuote {
+    const { context, gained, lost } = tradeQuote;
+    return {
+      context,
+      gained: this.toInternalTradeAsset(gained),
+      lost: this.toInternalTradeAsset(lost),
+    };
+  }
+
   private convertTradeAsset(tradeAsset: InternalTradeAsset): TradeAsset {
     if (tradeAsset.fiatAsset !== undefined) {
       return {
@@ -213,9 +335,12 @@ export class CandleClient {
         assetKind: "fiat",
       };
     } else if (tradeAsset.marketTradeAsset !== undefined) {
+      this.assertMarketAssetKind(tradeAsset.marketTradeAsset.assetKind);
       return {
         ...tradeAsset.marketTradeAsset,
-        assetKind: tradeAsset.marketTradeAsset.assetKind as "stock" | "crypto",
+        assetKind: this.assertMarketAssetKind(
+          tradeAsset.marketTradeAsset.assetKind
+        ),
       };
     } else if (tradeAsset.transportAsset !== undefined) {
       return {
@@ -254,7 +379,15 @@ export class CandleClient {
     }
   }
 
-  private convertToAssetAccount(account: NitroAssetAccount): AssetAccount {
+  private assertMarketAssetKind(kind: string): "stock" | "crypto" {
+    if (kind !== "stock" && kind !== "crypto") {
+      throw new Error("Internal Candle Error: corrupted market account.");
+    } else {
+      return kind;
+    }
+  }
+
+  private convertToAssetAccount(account: InternalAssetAccount): AssetAccount {
     const { legalAccountKind, nickname } = account;
     const { fiatAccountDetails, marketAccountDetails } = account.details;
 
@@ -273,7 +406,7 @@ export class CandleClient {
         nickname,
         details: {
           ...marketAccountDetails,
-          assetKind: marketAccountDetails.assetKind as "stock" | "crypto",
+          assetKind: this.assertMarketAssetKind(marketAccountDetails.assetKind),
         },
       };
     } else {
@@ -302,6 +435,18 @@ type Counterparty =
       kind: "service";
     } & ServiceCounterparty);
 
+type TradeQuery = {
+  gainedAssetKind?: TradeQueryAssetKind;
+  lostAssetKind?: TradeQueryAssetKind;
+  counterpartyKind?: "merchant" | "user" | "service";
+} & InternalTradeQuery;
+
+type TradeQuote = {
+  gained: TradeAsset;
+  lost: TradeAsset;
+  context: string;
+};
+
 type TradeQueryAssetKind =
   | "fiat"
   | "stock"
@@ -340,4 +485,25 @@ type Trade = {
   gained: TradeAsset;
 };
 
-export type { LinkedAccount, AppUser, Service, TradeState, TradeAsset, Trade };
+type TradeAssetRef =
+  | ({ assetKind: "transport" } & TransportAssetRef)
+  | ({ assetKind: "nothing" } & NothingAssetRef)
+  | ({ assetKind: "other" } & OtherAssetRef)
+  | ({ assetKind: "fiat" } & FiatAssetRef)
+  | ({ assetKind: "stock" | "crypto" } & MarketTradeAssetRef);
+
+export type {
+  LinkedAccountRef,
+  AssetAccountRef,
+  TradeAssetRef,
+  LinkedAccount,
+  AppUser,
+  Service,
+  TradeState,
+  TradeAsset,
+  Trade,
+  TradeQuery,
+  Counterparty,
+  AssetAccount,
+  TradeQuote,
+};

package/src/specs/RNCandle.nitro.ts

@@ -226,6 +226,7 @@ export type ExecuteTradeRequest = {
 export type TradeQuote = {
   lost: TradeAsset;
   gained: TradeAsset;
+  context: string;
 };
 
 export type Service =
@@ -344,6 +345,60 @@ export type ToolCall = {
   arguments: string;
 };
 
+export type LinkedAccountRef = {
+  linkedAccountID: string;
+};
+
+export type AssetAccountRef = {
+  linkedAccountID: string;
+  assetKind: string; // "fiat" | "stock" | "crypto"
+  serviceAccountID: string;
+};
+
+export type FiatAssetRef = {
+  assetKind: string; // fiat
+  serviceTradeID?: string;
+  linkedAccountID: string;
+};
+
+export type MarketTradeAssetRef = {
+  assetKind: string; // "stock" | "crypto"
+  serviceTradeID: string;
+  linkedAccountID: string;
+};
+
+export type TransportAssetRef = {
+  assetKind: string; // "transport"
+  serviceTradeID: string;
+  linkedAccountID: string;
+};
+
+export type OtherAssetRef = {
+  assetKind: string; // "other"
+};
+
+export type NothingAssetRef = {
+  assetKind: string; // "nothing"
+};
+
+export type TradeAssetRef = {
+  fiatAssetRef?: FiatAssetRef;
+  marketTradeAssetRef?: MarketTradeAssetRef;
+  transportAssetRef?: TransportAssetRef;
+  otherAssetRef?: OtherAssetRef;
+  nothingAssetRef?: NothingAssetRef;
+};
+
+export type TradeRef = {
+  lost: TradeAssetRef;
+  gained: TradeAssetRef;
+};
+
+export type TradeExecutionResult = {
+  trade?: Trade;
+  error?: string;
+};
+
 export interface RNCandle extends HybridObject<{ ios: "swift" }> {
   candleLinkSheet(
     isPresented: boolean,
@@ -355,13 +410,20 @@ export interface RNCandle extends HybridObject<{ ios: "swift" }> {
     presentationStyle: PresentationStyle,
     onSuccess: (account: LinkedAccount) => void
   ): void;
+  candleTradeExecutionSheet(
+    tradeQuote: TradeQuote,
+    presentationBackground: PresentationBackground,
+    completion: (result: TradeExecutionResult) => void
+  ): void;
   initialize(appUser: AppUser): void;
   getLinkedAccounts(): Promise<LinkedAccount[]>;
-  unlinkAccount(linkedAccountID: string): Promise<void>;
+  getLinkedAccount(ref: LinkedAccountRef): Promise<LinkedAccount>;
+  unlinkAccount(ref: LinkedAccountRef): Promise<void>;
   getAssetAccounts(query: AssetAccountQuery): Promise<AssetAccount[]>;
+  getAssetAccount(ref: AssetAccountRef): Promise<AssetAccount>;
   getTrades(query: TradeQuery): Promise<Trade[]>;
+  getTrade(ref: TradeRef): Promise<Trade>;
   getTradeQuotes(request: TradeQuoteRequest): Promise<TradeQuote[]>;
-  executeTrade(request: ExecuteTradeRequest): Promise<Trade>;
   deleteUser(): Promise<void>;
   // FIXME: The return type should be a more specific type based on the actual tool calls available.
   getAvailableTools(): Promise<Array<AnyMap>>;

package/nitrogen/generated/ios/swift/ExecuteTradeRequest.swift

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