react-native-candle 0.1.20 → 0.1.21

package/src/index.ts

@@ -18,6 +18,7 @@ import type {
   TradeAsset as InternalTradeAsset,
   TradeAssetQuoteRequest,
   TradeQuery as InternalTradeQuery,
+  TradeQuote as InternalTradeQuote,
   TransportAsset,
   TransportAssetQuoteRequest,
   LegalAccountKind,
@@ -29,7 +30,6 @@ import type {
   ServiceCounterparty,
   Counterparty as InternalCounterparty,
   ActiveLinkedAccountDetails,
-  ExecuteTradeRequest,
   AssetAccountRef,
   LinkedAccountRef,
   NothingAssetRef,
@@ -50,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,
@@ -130,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;
@@ -197,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) {
@@ -230,6 +249,7 @@ export class CandleClient {
       return {
         gained: this.convertTradeAsset(quote.gained),
         lost: this.convertTradeAsset(quote.lost),
+        context: quote.context,
       };
     });
   }
@@ -278,6 +298,36 @@ export class CandleClient {
     }
   }
 
+  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 {
@@ -285,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 {
@@ -326,6 +379,14 @@ export class CandleClient {
     }
   }
 
+  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;
@@ -345,7 +406,7 @@ export class CandleClient {
         nickname,
         details: {
           ...marketAccountDetails,
-          assetKind: marketAccountDetails.assetKind as "stock" | "crypto",
+          assetKind: this.assertMarketAssetKind(marketAccountDetails.assetKind),
         },
       };
     } else {
@@ -380,6 +441,12 @@ type TradeQuery = {
   counterpartyKind?: "merchant" | "user" | "service";
 } & InternalTradeQuery;
 
+type TradeQuote = {
+  gained: TradeAsset;
+  lost: TradeAsset;
+  context: string;
+};
+
 type TradeQueryAssetKind =
   | "fiat"
   | "stock"
@@ -438,4 +505,5 @@ export type {
   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 =
@@ -393,6 +394,11 @@ export type TradeRef = {
   gained: TradeAssetRef;
 };
 
+export type TradeExecutionResult = {
+  trade?: Trade;
+  error?: string;
+};
+
 export interface RNCandle extends HybridObject<{ ios: "swift" }> {
   candleLinkSheet(
     isPresented: boolean,
@@ -404,6 +410,11 @@ 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[]>;
   getLinkedAccount(ref: LinkedAccountRef): Promise<LinkedAccount>;
@@ -413,7 +424,6 @@ export interface RNCandle extends HybridObject<{ ios: "swift" }> {
   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)
-    }
-  }
-}

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

@@ -1,73 +0,0 @@
-///
-/// ExecuteTradeRequest.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 (ExecuteTradeRequest).
-   */
-  struct ExecuteTradeRequest {
-  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) {}
-  };
-
-} // namespace margelo::nitro::rncandle
-
-namespace margelo::nitro {
-
-  using namespace margelo::nitro::rncandle;
-
-  // C++ ExecuteTradeRequest <> JS ExecuteTradeRequest (object)
-  template <>
-  struct JSIConverter<ExecuteTradeRequest> final {
-    static inline ExecuteTradeRequest 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"))
-      );
-    }
-    static inline jsi::Value toJSI(jsi::Runtime& runtime, const ExecuteTradeRequest& 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) {
-      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<std::string>::canConvert(runtime, obj.getProperty(runtime, "context"))) return false;
-      return true;
-    }
-  };
-
-} // namespace margelo::nitro