react-native-candle 0.1.19 → 0.1.21

package/ReactNativeCandle.podspec

@@ -30,7 +30,7 @@ Pod::Spec.new do |s|
   load 'nitrogen/generated/ios/ReactNativeCandle+autolinking.rb'
   add_nitrogen_files(s)
 
-  s.dependency 'Candle', '3.0.241-beta'
+  s.dependency 'Candle', '3.0.258-beta'
   s.dependency 'React-jsi'
   s.dependency 'React-callinvoker'
   install_modules_dependencies(s)

package/ios/Sources/CandleActionViewModel.swift

@@ -0,0 +1,13 @@
+import Candle
+import Combine
+
+@available(iOS 17.0, *)
+final class CandleActionViewModel: ObservableObject {
+
+  @Published var tradeQuote: Models.TradeQuote?
+  @Published var tradeResult: Result<Candle.Models.Trade, Candle.Models.ExecuteTrade.Error>?
+
+  init(tradeQuote: Models.TradeQuote?) {
+    self.tradeQuote = tradeQuote
+  }
+}

package/ios/Sources/CandleTradeExecutionSheetWrapper.swift

@@ -0,0 +1,31 @@
+import Candle
+import SwiftUI
+
+@available(iOS 17.0, *)
+struct CandleTradeExecutionSheetWrapper: View {
+
+  let candleClient: CandleClient
+
+  @ObservedObject var viewModel: CandleActionViewModel
+  let presentationBackground: PresentationBackground
+
+  var toCandlePresentationBackground: AnyShapeStyle {
+    switch presentationBackground {
+    case .default:
+      return AnyShapeStyle(Material.regular)
+    case .blur:
+      return AnyShapeStyle(Material.ultraThick)
+    }
+  }
+
+  var body: some View {
+    Color.clear
+      .candleTradeExecutionSheet(
+        item: $viewModel.tradeQuote,
+        presentationBackground: toCandlePresentationBackground
+      ) { result in
+        viewModel.tradeResult = result
+      }
+      .environment(candleClient)
+  }
+}

package/ios/Sources/HostingViewController.swift

@@ -8,6 +8,13 @@ extension UIViewController {
     child.view.pinEdges(to: view)
     child.didMove(toParent: self)
   }
+
+  func embedOnTop(_ child: UIViewController) {
+    addChild(child)
+    view.insertSubview(child.view, aboveSubview: view)
+    child.view.pinEdges(to: view)
+    child.didMove(toParent: self)
+  }
 }
 
 extension UIView {

package/ios/Sources/RNCandle.swift

@@ -91,12 +91,75 @@ final class HybridRNCandle: HybridRNCandleSpec {
     }
   }
 
+  public func candleTradeExecutionSheet(
+    tradeQuote: TradeQuote,
+    presentationBackground: PresentationBackground,
+    completion: @escaping (TradeExecutionResult) -> Void
+  ) throws {
+    Task { @MainActor in
+      let wrapperView = CandleTradeExecutionSheetWrapper(
+        candleClient: try viewModel.candleClient,
+        viewModel: .init(tradeQuote: nil),
+        presentationBackground: presentationBackground
+      )
+
+      let hostingVC = UIHostingController(rootView: wrapperView)
+      hostingVC.view.backgroundColor = .clear
+      guard
+        let rootHostingVC = UIApplication.keyWindow?
+          .rootViewController
+      else {
+        throw RNClientError.badInitialization(
+          message:
+            "\(#function) \(#line): Candle client was not initialized."
+        )
+      }
+      rootHostingVC.embedOnTop(hostingVC)
+      let tradeQuote = try tradeQuote.toCandleModel
+      DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) {
+        wrapperView.viewModel.tradeQuote = tradeQuote
+      }
+      wrapperView.viewModel.$tradeQuote
+        .dropFirst()
+        .receive(on: RunLoop.main)
+        .sink { [weak hostingVC] trade in
+          if trade == nil {
+            DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) {
+              hostingVC?.willMove(toParent: nil)
+              hostingVC?.view.removeFromSuperview()
+              hostingVC?.removeFromParent()
+            }
+          }
+        }
+        .store(in: &cancellables)
+
+      wrapperView.viewModel.$tradeResult
+        .receive(on: RunLoop.main)
+        .sink { result in
+          switch result {
+          case .success(let trade):
+            completion(
+              .init(
+                trade: trade.toTrade,
+                error: nil
+              )
+            )
+          case .failure(let error):
+            completion(.init(trade: nil, error: "We encountered an error: \(error)"))
+          case .none:
+            break
+          }
+        }
+        .store(in: &cancellables)
+    }
+  }
+
   // MARK: - Public
 
-  public func unlinkAccount(linkedAccountID: String) throws -> Promise<Void> {
+  public func unlinkAccount(ref: LinkedAccountRef) throws -> Promise<Void> {
     .async {
       try await self.viewModel.candleClient.unlinkAccount(
-        linkedAccountID: linkedAccountID)
+        path: .init(linkedAccountID: ref.linkedAccountID))
     }
   }
 
@@ -108,6 +171,14 @@ final class HybridRNCandle: HybridRNCandleSpec {
     }
   }
 
+  public func getLinkedAccount(ref: LinkedAccountRef) throws -> Promise<LinkedAccount> {
+    .async {
+      let account = try await self.viewModel.candleClient.getLinkedAccount(
+        ref: .init(linkedAccountID: ref.linkedAccountID))
+      return account.toLinkedAccount
+    }
+  }
+
   public func getAssetAccounts(query: AssetAccountQuery) throws -> Promise<
     [AssetAccount]
   > {
@@ -119,57 +190,32 @@ final class HybridRNCandle: HybridRNCandleSpec {
             assetKind: query.assetKind?.asCandleModel
           )
         )
-      return accounts.map { model in
-        let legalAccountKind = model.legalAccountKind.toRNModel
-        switch model.details {
-        case .FiatAccountDetails(let fiatDetails):
-          let ach = fiatDetails.ach.map { details in
-            ACHDetails(
-              accountNumber: details.accountNumber,
-              routingNumber: details.routingNumber,
-              accountKind: details.accountKind.toRNModel
-            )
-          }
+      return accounts.map(\.toRNModel)
+    }
+  }
 
-          let wire = fiatDetails.wire.map { details in
-            WireDetails(
-              accountNumber: details.accountNumber,
-              routingNumber: details.routingNumber
-            )
-          }
-          return AssetAccount(
-            legalAccountKind: legalAccountKind,
-            nickname: model.nickname,
-            details: .init(
-              fiatAccountDetails: .init(
-                assetKind: fiatDetails.assetKind.rawValue,
-                serviceAccountID: fiatDetails.serviceAccountID,
-                currencyCode: fiatDetails.currencyCode,
-                balance: fiatDetails.balance,
-                ach: ach,
-                wire: wire,
-                linkedAccountID: fiatDetails.linkedAccountID,
-                service: fiatDetails.service.toService),
-              marketAccountDetails: nil
-            )
-          )
-        case .MarketAccountDetails(let marketDetails):
-          return AssetAccount(
-            legalAccountKind: legalAccountKind,
-            nickname: model.nickname,
-            details: .init(
-              fiatAccountDetails: nil,
-              marketAccountDetails: .init(
-                assetKind: marketDetails.assetKind.rawValue,
-                serviceAccountID: marketDetails
-                  .serviceAccountID,
-                linkedAccountID: marketDetails.linkedAccountID,
-                service: marketDetails.service.toService
-              )
-            )
-          )
-        }
-      }
+  public func getAssetAccount(ref: AssetAccountRef) throws -> Promise<AssetAccount> {
+    .async {
+      let account = try await self.viewModel.candleClient.getAssetAccount(
+        ref: .init(
+          linkedAccountID: ref.linkedAccountID,
+          assetKind: .init(rawValue: ref.assetKind)!,
+          serviceAccountID: ref.serviceAccountID
+        )
+      )
+      return account.toRNModel
+    }
+  }
+
+  public func getTrade(ref: TradeRef) throws -> Promise<Trade> {
+    .async {
+      let trade = try await self.viewModel.candleClient.getTrade(
+        ref: .init(
+          lost: try ref.lost.toTradeAssetRef,
+          gained: try ref.gained.toTradeAssetRef
+        )
+      )
+      return trade.toTrade
     }
   }
 
@@ -183,15 +229,7 @@ final class HybridRNCandle: HybridRNCandleSpec {
           lostAssetKind: query.toLostAssetKind,
           counterpartyKind: query.toCounterpartyKindPayload
         ))
-      return trades.map { trade in
-        return Trade(
-          dateTime: trade.dateTime,
-          state: TradeState(fromString: trade.state.rawValue)!,
-          counterparty: trade.toCounterparty,
-          lost: trade.lost.toAsset,
-          gained: trade.gained.toAsset
-        )
-      }
+      return trades.map(\.toTrade)
     }
   }
 
@@ -209,31 +247,13 @@ final class HybridRNCandle: HybridRNCandleSpec {
       return accounts.map { account in
         TradeQuote(
           lost: account.lost.toAsset,
-          gained: account.gained.toAsset
+          gained: account.gained.toAsset,
+          context: account.context
         )
       }
     }
   }
 
-  public func executeTrade(request: ExecuteTradeRequest) throws -> Promise<
-    Trade
-  > {
-    .async {
-      let trade = try await self.viewModel.candleClient.executeTrade(
-        context: .init(
-          linkedAccountID: request.linkedAccountID,
-          context: request.context)
-      )
-      return Trade(
-        dateTime: trade.dateTime,
-        state: trade.state.toRNModel,
-        counterparty: trade.toCounterparty,
-        lost: trade.lost.toAsset,
-        gained: trade.gained.toAsset
-      )
-    }
-  }
-
   public func deleteUser() throws -> Promise<Void> {
     .async {
       try await self.viewModel.candleClient.deleteUser()
@@ -500,6 +520,18 @@ extension Models.TradeAsset {
   }
 }
 
+extension Models.Trade {
+  var toTrade: Trade {
+    .init(
+      dateTime: dateTime,
+      state: state.toRNModel,
+      counterparty: toCounterparty,
+      lost: lost.toAsset,
+      gained: gained.toAsset
+    )
+  }
+}
+
 extension TradeQuoteRequest {
   var toGained: Models.TradeAssetQuoteRequest {
     get throws {
@@ -516,11 +548,15 @@ extension TradeQuoteRequest {
       } else if let marketAssetQuoteRequest = gained
         .marketAssetQuoteRequest
       {
+        guard
+          let assetKind = Models.MarketAssetQuoteRequest.AssetKindPayload(
+            rawValue: marketAssetQuoteRequest.assetKind)
+        else {
+          throw RNClientError.badEncoding
+        }
         return Models.TradeAssetQuoteRequest.MarketAssetQuoteRequest(
           .init(
-            assetKind: .init(
-              rawValue: marketAssetQuoteRequest.assetKind)
-              ?? .stock,
+            assetKind: assetKind,
             serviceAccountID: marketAssetQuoteRequest
               .serviceAccountID,
             serviceAssetID: marketAssetQuoteRequest.serviceAssetID,
@@ -989,3 +1025,183 @@ extension TradeQuery {
     return nil
   }
 }
+
+extension Models.AssetAccount {
+  var toRNModel: AssetAccount {
+    let legalAccountKind = legalAccountKind.toRNModel
+    switch details {
+    case .FiatAccountDetails(let fiatDetails):
+      let ach = fiatDetails.ach.map { details in
+        ACHDetails(
+          accountNumber: details.accountNumber,
+          routingNumber: details.routingNumber,
+          accountKind: details.accountKind.toRNModel
+        )
+      }
+
+      let wire = fiatDetails.wire.map { details in
+        WireDetails(
+          accountNumber: details.accountNumber,
+          routingNumber: details.routingNumber
+        )
+      }
+      return AssetAccount(
+        legalAccountKind: legalAccountKind,
+        nickname: nickname,
+        details: .init(
+          fiatAccountDetails: .init(
+            assetKind: fiatDetails.assetKind.rawValue,
+            serviceAccountID: fiatDetails.serviceAccountID,
+            currencyCode: fiatDetails.currencyCode,
+            balance: fiatDetails.balance,
+            ach: ach,
+            wire: wire,
+            linkedAccountID: fiatDetails.linkedAccountID,
+            service: fiatDetails.service.toService),
+          marketAccountDetails: nil
+        )
+      )
+    case .MarketAccountDetails(let marketDetails):
+      return AssetAccount(
+        legalAccountKind: legalAccountKind,
+        nickname: nickname,
+        details: .init(
+          fiatAccountDetails: nil,
+          marketAccountDetails: .init(
+            assetKind: marketDetails.assetKind.rawValue,
+            serviceAccountID: marketDetails
+              .serviceAccountID,
+            linkedAccountID: marketDetails.linkedAccountID,
+            service: marketDetails.service.toService
+          )
+        )
+      )
+    }
+  }
+}
+
+extension TradeAssetRef {
+  var toTradeAssetRef: Models.TradeAssetRef {
+    get throws {
+      if let fiatAssetRef {
+        return .FiatAssetRef(
+          .init(
+            assetKind: .fiat,
+            serviceTradeID: fiatAssetRef.serviceTradeID,
+            linkedAccountID: fiatAssetRef.linkedAccountID
+          )
+        )
+      } else if let nothingAssetRef {
+        return .NothingAsset(.init(assetKind: .nothing))
+      } else if let marketTradeAssetRef {
+        guard
+          let assetKind = Models.MarketAssetRef.AssetKindPayload.init(
+            rawValue: marketTradeAssetRef.assetKind)
+        else {
+          throw RNClientError.badEncoding
+        }
+        return .MarketAssetRef(
+          .init(
+            assetKind: assetKind,
+            serviceTradeID: marketTradeAssetRef.serviceTradeID,
+            linkedAccountID: marketTradeAssetRef.linkedAccountID
+          )
+        )
+      } else if let otherAssetRef {
+        return .OtherAsset(
+          .init(assetKind: .other)
+        )
+      } else if let transportAssetRef {
+        return .TransportAssetRef(
+          .init(
+            assetKind: .transport,
+            serviceTradeID: transportAssetRef.serviceTradeID,
+            linkedAccountID: transportAssetRef.linkedAccountID
+          )
+        )
+      } else {
+        throw RNClientError.badEncoding
+      }
+    }
+  }
+}
+
+extension TradeAsset {
+  var toCandleModel: Models.TradeAsset {
+    get throws {
+      if let fiat = fiatAsset {
+        return .FiatAsset(
+          .init(
+            assetKind: .fiat,
+            serviceTradeID: fiat.serviceTradeID,
+            serviceAccountID: fiat.serviceAccountID,
+            currencyCode: fiat.currencyCode,
+            amount: fiat.amount,
+            linkedAccountID: fiat.linkedAccountID,
+            service: fiat.service.toService
+          )
+        )
+      } else if let market = marketTradeAsset {
+        guard let assetKind = Models.MarketTradeAsset.AssetKindPayload(rawValue: market.assetKind)
+        else {
+          throw RNClientError.badEncoding
+        }
+        return .MarketTradeAsset(
+          .init(
+            assetKind: assetKind,
+            serviceAccountID: market.serviceAccountID,
+            serviceAssetID: market.serviceAssetID,
+            symbol: market.symbol,
+            amount: market.amount,
+            serviceTradeID: market.serviceTradeID,
+            linkedAccountID: market.linkedAccountID,
+            service: market.service.toService,
+            name: market.name,
+            color: market.color,
+            logoURL: market.logoURL
+          )
+        )
+      } else if let transport = transportAsset {
+        return .TransportAsset(
+          .init(
+            assetKind: .transport,
+            serviceTradeID: transport.serviceTradeID,
+            serviceAssetID: transport.serviceAssetID,
+            name: transport.name,
+            description: transport.description,
+            imageURL: transport.imageURL,
+            originCoordinates: .init(
+              latitude: transport.originCoordinates.latitude,
+              longitude: transport.originCoordinates.longitude
+            ),
+            originAddress: .init(value: transport.originAddress.value),
+            destinationCoordinates: .init(
+              latitude: transport.destinationCoordinates.latitude,
+              longitude: transport.destinationCoordinates.longitude
+            ),
+            destinationAddress: .init(value: transport.destinationAddress.value),
+            seats: transport.seats,
+            linkedAccountID: transport.linkedAccountID,
+            service: transport.service.toService
+          )
+        )
+      } else if otherAsset != nil {
+        return .OtherAsset(.init(assetKind: .other))
+      } else {
+        return .NothingAsset(.init(assetKind: .nothing))
+      }
+    }
+  }
+}
+
+extension TradeQuote {
+  var toCandleModel: Models.TradeQuote {
+    get throws {
+      .init(
+        lost: try lost.toCandleModel,
+        gained: try gained.toCandleModel,
+        context: context
+      )
+    }
+  }
+}