react-native-candle 0.1.17 → 0.1.19

package/src/index.ts

@@ -1,11 +1,35 @@
 import { NitroModules } from "react-native-nitro-modules";
 import type {
   AppUser,
+  AssetAccount as NitroAssetAccount,
+  AssetAccountQuery,
+  FiatAsset,
+  FiatAssetQuoteRequest,
   LinkedAccount,
+  MarketAssetQuoteRequest,
+  MarketTradeAsset,
+  NothingAsset,
+  NothingAssetQuoteRequest,
+  OtherAsset,
   PresentationBackground,
   PresentationStyle,
   RNCandle,
   Service,
+  TradeAsset as InternalTradeAsset,
+  TradeAssetQuoteRequest,
+  TradeQuery,
+  TransportAsset,
+  TransportAssetQuoteRequest,
+  LegalAccountKind,
+  WireDetails,
+  ACHDetails,
+  TradeState,
+  MerchantCounterparty,
+  UserCounterparty,
+  ServiceCounterparty,
+  Counterparty as InternalCounterparty,
+  ActiveLinkedAccountDetails,
+  ExecuteTradeRequest,
 } from "./specs/RNCandle.nitro";
 
 export class CandleClient {
@@ -48,8 +72,38 @@ export class CandleClient {
     );
   }
 
-  public async getLinkedAccounts(): Promise<LinkedAccount[]> {
-    return this.candle.getLinkedAccounts();
+  public async getLinkedAccounts(): Promise<
+    (
+      | (LinkedAccount & {
+          details: { state: "active" } & ActiveLinkedAccountDetails;
+        })
+      | (LinkedAccount & {
+          details: { state: "inactive" };
+        })
+    )[]
+  > {
+    const accounts = await this.candle.getLinkedAccounts();
+    return accounts.map((account) => {
+      if (account.details.activeLinkedAccountDetails !== undefined) {
+        return {
+          ...account,
+          details: {
+            ...account.details.activeLinkedAccountDetails,
+            state: "active",
+          },
+        };
+      } else if (account.details.inactiveLinkedAccountDetails !== undefined) {
+        return {
+          ...account,
+          details: {
+            ...account.details.inactiveLinkedAccountDetails,
+            state: "inactive",
+          },
+        };
+      } else {
+        throw new Error("Internal Candle Error: corrupted linked account.");
+      }
+    });
   }
 
   public async unlinkAccount(linkedAccountID: string): Promise<void> {
@@ -64,12 +118,226 @@ 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;
   }): Promise<string> {
     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 getTrades(
+    query: {
+      gainedAssetKind?: TradeQueryAssetKind;
+      lostAssetKind?: TradeQueryAssetKind;
+      counterpartyKind?: "merchant" | "user" | "service";
+    } & 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 getTradeQuotes(request: {
+    linkedAccountIDs?: string;
+    gained:
+      | ({
+          assetKind: "nothing";
+        } & NothingAssetQuoteRequest)
+      | ({ assetKind: "transport" } & TransportAssetQuoteRequest)
+      | ({ assetKind: "fiat" } & FiatAssetQuoteRequest)
+      | ({ assetKind: "stock" | "crypto" } & MarketAssetQuoteRequest);
+  }): Promise<
+    {
+      gained: TradeAsset;
+      lost: TradeAsset;
+    }[]
+  > {
+    let gainedRequest: TradeAssetQuoteRequest;
+
+    switch (request.gained.assetKind) {
+      case "fiat":
+        gainedRequest = { fiatAssetQuoteRequest: request.gained };
+        break;
+      case "stock":
+      case "crypto":
+        gainedRequest = { marketAssetQuoteRequest: request.gained };
+        break;
+      case "transport":
+        gainedRequest = { transportAssetQuoteRequest: request.gained };
+        break;
+      case "nothing":
+        gainedRequest = { nothingAssetQuoteRequest: request.gained };
+        break;
+    }
+
+    const quotes = await this.candle.getTradeQuotes({
+      linkedAccountIDs: request.linkedAccountIDs,
+      gained: gainedRequest,
+    });
+
+    return quotes.map((quote) => {
+      return {
+        gained: this.convertTradeAsset(quote.gained),
+        lost: this.convertTradeAsset(quote.lost),
+      };
+    });
+  }
+
+  private convertTradeAsset(tradeAsset: InternalTradeAsset): TradeAsset {
+    if (tradeAsset.fiatAsset !== undefined) {
+      return {
+        ...tradeAsset.fiatAsset,
+        assetKind: "fiat",
+      };
+    } else if (tradeAsset.marketTradeAsset !== undefined) {
+      return {
+        ...tradeAsset.marketTradeAsset,
+        assetKind: tradeAsset.marketTradeAsset.assetKind as "stock" | "crypto",
+      };
+    } else if (tradeAsset.transportAsset !== undefined) {
+      return {
+        ...tradeAsset.transportAsset,
+        assetKind: "transport",
+      };
+    } else if (tradeAsset.otherAsset !== undefined) {
+      return { assetKind: "other" };
+    } else if (tradeAsset.nothingAsset !== undefined) {
+      return { assetKind: "nothing" };
+    } else {
+      throw new Error("Internal Candle Error: corrupted trade asset.");
+    }
+  }
+
+  private convertToCounterparty(
+    counterparty: InternalCounterparty
+  ): Counterparty {
+    if (counterparty.merchantCounterparty !== undefined) {
+      return {
+        ...counterparty.merchantCounterparty,
+        kind: "merchant",
+      };
+    } else if (counterparty.userCounterparty !== undefined) {
+      return {
+        ...counterparty.userCounterparty,
+        kind: "user",
+      };
+    } else if (counterparty.serviceCounterparty !== undefined) {
+      return {
+        ...counterparty.serviceCounterparty,
+        kind: "service",
+      };
+    } else {
+      throw new Error("Unknown counterparty kind");
+    }
+  }
+
+  private convertToAssetAccount(account: NitroAssetAccount): AssetAccount {
+    const { legalAccountKind, nickname } = account;
+    const { fiatAccountDetails, marketAccountDetails } = account.details;
+
+    if (fiatAccountDetails !== undefined) {
+      return {
+        legalAccountKind,
+        nickname,
+        details: {
+          ...fiatAccountDetails,
+          assetKind: "fiat",
+        },
+      };
+    } else if (marketAccountDetails !== undefined) {
+      return {
+        legalAccountKind,
+        nickname,
+        details: {
+          ...marketAccountDetails,
+          assetKind: marketAccountDetails.assetKind as "stock" | "crypto",
+        },
+      };
+    } else {
+      throw new Error("Internal Candle Error: corrupted asset account.");
+    }
+  }
 }
 
-export type { LinkedAccount, AppUser };
+type TradeAsset =
+  | ({
+      assetKind: "nothing";
+    } & NothingAsset)
+  | ({
+      assetKind: "other";
+    } & OtherAsset)
+  | ({ assetKind: "transport" } & TransportAsset)
+  | ({ assetKind: "fiat" } & FiatAsset)
+  | ({ assetKind: "stock" | "crypto" } & MarketTradeAsset);
+
+type Counterparty =
+  | ({ kind: "merchant" } & MerchantCounterparty)
+  | ({
+      kind: "user";
+    } & UserCounterparty)
+  | ({
+      kind: "service";
+    } & ServiceCounterparty);
+
+type TradeQueryAssetKind =
+  | "fiat"
+  | "stock"
+  | "crypto"
+  | "transport"
+  | "other"
+  | "nothing";
+
+type AssetAccount = {
+  legalAccountKind: LegalAccountKind;
+  nickname: string;
+  details:
+    | {
+        assetKind: "fiat";
+        serviceAccountID: string;
+        currencyCode: string;
+        balance?: number;
+        linkedAccountID: string;
+        service: Service;
+        ach?: ACHDetails;
+        wire?: WireDetails;
+      }
+    | {
+        assetKind: "stock" | "crypto";
+        serviceAccountID: string;
+        linkedAccountID: string;
+        service: Service;
+      };
+};
+
+type Trade = {
+  dateTime: string;
+  state: TradeState;
+  counterparty: Counterparty;
+  lost: TradeAsset;
+  gained: TradeAsset;
+};
+
+export type { LinkedAccount, AppUser, Service, TradeState, TradeAsset, Trade };

package/src/specs/RNCandle.nitro.ts

@@ -6,6 +6,228 @@ export type AppUser = {
   appUserID?: string;
 };
 
+type ACHAccountKind = "checking" | "savings";
+
+export type ACHDetails = {
+  accountNumber: string;
+  routingNumber: string;
+  accountKind: ACHAccountKind;
+};
+
+export type WireDetails = {
+  accountNumber: string;
+  routingNumber: string;
+};
+
+type FiatAccountDetails = {
+  assetKind: string; // fiat
+  serviceAccountID: string;
+  currencyCode: string;
+  balance?: number;
+  ach?: ACHDetails;
+  wire?: WireDetails;
+  linkedAccountID: string;
+  service: Service;
+};
+
+type MarketAccountDetails = {
+  assetKind: string; // "stock" | "crypto"
+  serviceAccountID: string;
+  linkedAccountID: string;
+  service: Service;
+};
+
+type AssetAccountDetails = {
+  fiatAccountDetails?: FiatAccountDetails;
+  marketAccountDetails?: MarketAccountDetails;
+};
+
+export type LegalAccountKind =
+  | "individual"
+  | "joint"
+  | "traditionalIra"
+  | "rothIra";
+
+export type AssetAccount = {
+  legalAccountKind: LegalAccountKind;
+  nickname: string;
+  details: AssetAccountDetails;
+};
+
+type AssetAccountKind = "fiat" | "stock" | "crypto";
+
+export type AssetAccountQuery = {
+  linkedAccountIDs?: string;
+  assetKind?: AssetAccountKind;
+};
+
+export type FiatAsset = {
+  assetKind: string; // fiat
+  serviceTradeID?: string;
+  serviceAccountID: string;
+  currencyCode: string;
+  amount: number;
+  linkedAccountID: string;
+  service: Service;
+};
+
+export type MarketTradeAsset = {
+  assetKind: string; // "stock" | "crypto"
+  serviceAccountID: string;
+  serviceAssetID: string;
+  symbol: string;
+  amount: number;
+  serviceTradeID: string;
+  linkedAccountID: string;
+  name: string;
+  color: string;
+  logoURL: string;
+  service: Service;
+};
+
+type Coordinates = {
+  latitude: number;
+  longitude: number;
+};
+
+type Address = {
+  value: string;
+};
+
+export type TransportAsset = {
+  assetKind: string; // "transport"
+  serviceTradeID: string;
+  serviceAssetID: string;
+  name: string;
+  description: string;
+  // FIXME: use URL type for url fields
+  imageURL: string;
+  originCoordinates: Coordinates;
+  originAddress: Address;
+  destinationCoordinates: Coordinates;
+  destinationAddress: Address;
+  seats: number;
+  linkedAccountID: string;
+  service: Service;
+};
+
+export type OtherAsset = {
+  assetKind: string; // "other"
+};
+
+export type NothingAsset = {
+  assetKind: string; // "nothing"
+};
+
+export type TradeAsset = {
+  fiatAsset?: FiatAsset;
+  marketTradeAsset?: MarketTradeAsset;
+  transportAsset?: TransportAsset;
+  otherAsset?: OtherAsset;
+  nothingAsset?: NothingAsset;
+};
+
+type MerchantLocation = {
+  countryCode: string;
+  countrySubdivisionCode: string;
+  localityName: string;
+};
+
+export type MerchantCounterparty = {
+  kind: string; // "merchant";
+  name: string;
+  logoURL: string;
+  location?: MerchantLocation;
+};
+
+export type UserCounterparty = {
+  kind: string; // "user"
+  legalName: string;
+  avatarURL: string;
+  username: string;
+};
+
+export type ServiceCounterparty = {
+  kind: string; // "service"
+  service: Service;
+};
+
+export type Counterparty = {
+  merchantCounterparty?: MerchantCounterparty;
+  userCounterparty?: UserCounterparty;
+  serviceCounterparty?: ServiceCounterparty;
+};
+
+export type TradeState = "success" | "inProgress" | "failure";
+
+export type Trade = {
+  dateTime: string;
+  state: TradeState;
+  counterparty: Counterparty;
+  lost: TradeAsset;
+  gained: TradeAsset;
+};
+
+export type TradeQuery = {
+  linkedAccountIDs?: string;
+  dateTimeSpan?: string;
+  // FIXME: define enum here rather than in JS wrapper layer
+  gainedAssetKind?: string; // "fiat" | "stock" | "crypto" | "transport" | "other" | "nothing"
+  lostAssetKind?: string; // "fiat" | "stock" | "crypto" | "transport" | "other" | "nothing"
+  counterpartyKind?: string; // "merchant" | "user" | "service"
+};
+
+export type FiatAssetQuoteRequest = {
+  assetKind: string; // fiat
+  serviceAccountID?: string;
+  currencyCode?: string;
+  amount?: number;
+};
+
+export type MarketAssetQuoteRequest = {
+  assetKind: string; // "stock" | "crypto"
+  serviceAccountID?: string;
+  serviceAssetID?: string;
+  symbol?: string;
+  amount?: number;
+};
+
+export type TransportAssetQuoteRequest = {
+  assetKind: string; // "transport"
+  serviceAssetID?: string;
+  originCoordinates?: Coordinates;
+  originAddress?: Address;
+  destinationCoordinates?: Coordinates;
+  destinationAddress?: Address;
+  seats?: number;
+};
+
+export type NothingAssetQuoteRequest = {
+  assetKind: string; // "nothing"
+};
+
+export type TradeAssetQuoteRequest = {
+  fiatAssetQuoteRequest?: FiatAssetQuoteRequest;
+  marketAssetQuoteRequest?: MarketAssetQuoteRequest;
+  transportAssetQuoteRequest?: TransportAssetQuoteRequest;
+  nothingAssetQuoteRequest?: NothingAssetQuoteRequest;
+};
+
+export type TradeQuoteRequest = {
+  linkedAccountIDs?: string;
+  gained: TradeAssetQuoteRequest;
+};
+
+export type ExecuteTradeRequest = {
+  linkedAccountID: string;
+  context: string;
+};
+
+export type TradeQuote = {
+  lost: TradeAsset;
+  gained: TradeAsset;
+};
+
 export type Service =
   | "robinhood"
   | "cash_app"
@@ -93,18 +315,28 @@ export type PresentationStyle = "sheet" | "fullScreen";
 
 export type State = "active" | "inactive";
 
-export type Details = {
-  state: State;
-  username: string | undefined;
+export type ActiveLinkedAccountDetails = {
+  state: string; // "active"
+  accountOpened?: string;
+  username?: string;
+  emailAddress?: string;
   legalName: string;
-  accountOpened: string | undefined;
+};
+
+export type InactiveLinkedAccountDetails = {
+  state: string; // "inactive"
+};
+
+export type LinkedAccountDetails = {
+  activeLinkedAccountDetails?: ActiveLinkedAccountDetails;
+  inactiveLinkedAccountDetails?: InactiveLinkedAccountDetails;
 };
 
 export type LinkedAccount = {
-  serviceUserID: string;
-  details: Details | undefined;
   linkedAccountID: string;
   service: Service;
+  serviceUserID: string;
+  details: LinkedAccountDetails;
 };
 
 export type ToolCall = {
@@ -126,10 +358,10 @@ export interface RNCandle extends HybridObject<{ ios: "swift" }> {
   initialize(appUser: AppUser): void;
   getLinkedAccounts(): Promise<LinkedAccount[]>;
   unlinkAccount(linkedAccountID: string): Promise<void>;
-  // FIXME: Make this type safe
-  getAssetAccounts(): Promise<string>;
-  getTrades(span: string | undefined): Promise<string>;
-  getTradeQuotes(span: string | undefined): Promise<string>;
+  getAssetAccounts(query: AssetAccountQuery): Promise<AssetAccount[]>;
+  getTrades(query: TradeQuery): 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/State.swift

@@ -1,38 +0,0 @@
-///
-/// State.swift
-/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
-/// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
-///
-
-/// Represents the JS union `State`, backed by a C++ enum.
-public typealias State = margelo.nitro.rncandle.State
-
-extension State {
-  /**
-   * Get a State for the given String value, or
-   * return `nil` if the given value was invalid/unknown.
-   */
-  public init?(fromString string: String) {
-    switch string {
-    case "active":
-      self = .active
-    case "inactive":
-      self = .inactive
-    default:
-      return nil
-    }
-  }
-
-  /**
-   * Get the String value this State represents.
-   */
-  public var stringValue: String {
-    switch self {
-    case .active:
-      return "active"
-    case .inactive:
-      return "inactive"
-    }
-  }
-}