react-native-candle 19.0.12-beta → 40.0.8-beta

package/README.md

@@ -1,33 +1,25 @@
-# React Native SDK Module
+# Candle React Native Example App(s)
 
-This directory is the workspace source for `react-native-candle`.
+#### Supported Platforms
 
-User-facing installation and API docs live in `web-docs/`. This README only covers the repo-local workflow that is specific to this module.
+<div style="flex-wrap: wrap; display: flex;">
 
-## What Is Here
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="Images/ios.svg">
+  <source media="(prefers-color-scheme: light)" srcset="Images/ios-active.svg">
+  <img alt="ios" src="Images/ios-active.svg" height="24">
+</picture>&nbsp;
 
-- `src/specs/RNCandle.nitro.ts`: Nitro bridge schema and generated native bindings source of truth
-- `src/types.ts`: public TypeScript wrapper layer over the Nitro-generated models
-- `ios/Sources/`: handwritten Swift bridge code
-- `sdk-react-native-example-app/`: the local app used to exercise the package in development
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="Images/ipados.svg">
+  <source media="(prefers-color-scheme: light)" srcset="Images/ipados-active.svg">
+  <img alt="ipad" src="Images/ipados-active.svg" height="24">
+</picture>&nbsp;
 
-## Module-Specific Workflow
+---
 
-- After changing `src/specs/RNCandle.nitro.ts`, run `pnpm run gen:nitro`.
-- After changing the public TS wrapper layer or native bridge code, run:
-  - `pnpm run lintCheck`
-  - `pnpm run formatCheck`
-  - `pnpm run compileCheck`
-- Before finishing, run `pnpm turbo check` from the repo root.
+</div>
 
-## iOS Development Notes
+The Candle React Native SDK is a simple & secure way for developers to connect external services to LLMs, agents, and apps. Visit our [quick start](https://docs.candle.fi) guide to get started.
 
-- The package is currently iOS-only at runtime. The docs and example app assume iOS 17+.
-- The example app injects the local Swift SDK pod path in `plugins/withLocalSwiftPod.js`, so native iOS dependency changes usually require `cd ../sdk-react-native-example-app && pnpm prebuild` before rebuilding.
-- `ReactNativeCandle.podspec` now pins `Candle` to the same version as this package. If those versions ever stop moving in lockstep, the release wiring will need to change.
-
-## Release Notes
-
-- `publish.sh` prepares the public repo contents.
-- `pnpm run script -- apply-public-package-metadata ...` rewrites package metadata for release outputs.
-- `public/README.md` is the public-facing README template for this module and should stay aligned with the actual package capabilities.
+![Candle](Images/sdk-readme.png)

package/android/gradle.properties

@@ -1,2 +1,7 @@
 ReactNativeCandle_kotlinVersion=2.1.21
 org.gradle.caching=true
+org.gradle.daemon=true
+org.gradle.parallel=true
+org.gradle.caching=true
+org.gradle.configureondemand=true
+org.gradle.jvmargs=-Xmx4g -XX:MaxMetaspaceSize=1g -Dkotlin.daemon.jvm.options=-Xmx2g

package/android/src/main/java/com/margelo/nitro/rncandle/BridgeTypes.kt

@@ -24,6 +24,11 @@ import fi.candle.generated.http.models.FiatAsset as CandleFiatAsset
 import fi.candle.generated.http.models.FiatAssetQuoteRequest as CandleFiatAssetQuoteRequest
 import fi.candle.generated.http.models.FiatAssetRef as CandleFiatAssetRef
 import fi.candle.generated.http.models.FinancialAccountKind as CandleFinancialAccountKind
+import fi.candle.generated.http.models.FriendRequestAsset as CandleFriendRequestAsset
+import fi.candle.generated.http.models.FriendRequestAssetDirection as CandleFriendRequestAssetDirection
+import fi.candle.generated.http.models.FriendRequestAssetQuoteRequest as CandleFriendRequestAssetQuoteRequest
+import fi.candle.generated.http.models.FriendRequestAssetQuoteRequestAction as CandleFriendRequestAssetQuoteRequestAction
+import fi.candle.generated.http.models.FriendRequestAssetRef as CandleFriendRequestAssetRef
 import fi.candle.generated.http.models.InactiveLinkedAccountDetails as CandleInactiveLinkedAccountDetails
 import fi.candle.generated.http.models.LinkedAccount as CandleLinkedAccount
 import fi.candle.generated.http.models.LinkedAccountDetails as CandleLinkedAccountDetails
@@ -32,6 +37,10 @@ import fi.candle.generated.http.models.LinkedAccountStatusRefState as CandleLink
 import fi.candle.generated.http.models.MerchantCounterparty as CandleMerchantCounterparty
 import fi.candle.generated.http.models.MerchantCounterpartyQuoteRequest as CandleMerchantCounterpartyQuoteRequest
 import fi.candle.generated.http.models.MerchantLocation as CandleMerchantLocation
+import fi.candle.generated.http.models.MessageThreadAsset as CandleMessageThreadAsset
+import fi.candle.generated.http.models.MessageThreadAssetQuoteRequest as CandleMessageThreadAssetQuoteRequest
+import fi.candle.generated.http.models.MessageThreadAssetRef as CandleMessageThreadAssetRef
+import fi.candle.generated.http.models.MessageThreadMessage as CandleMessageThreadMessage
 import fi.candle.generated.http.models.NothingAsset as CandleNothingAsset
 import fi.candle.generated.http.models.NothingAssetQuoteRequest as CandleNothingAssetQuoteRequest
 import fi.candle.generated.http.models.OtherAsset as CandleOtherAsset
@@ -39,6 +48,7 @@ import fi.candle.generated.http.models.OtherAssetQuoteRequest as CandleOtherAsse
 import fi.candle.generated.http.models.Service as CandleService
 import fi.candle.generated.http.models.ServiceCounterparty as CandleServiceCounterparty
 import fi.candle.generated.http.models.ServiceCounterpartyQuoteRequest as CandleServiceCounterpartyQuoteRequest
+import fi.candle.generated.http.models.ServiceID as CandleServiceID
 import fi.candle.generated.http.models.StockAccount as CandleStockAccount
 import fi.candle.generated.http.models.StockAsset as CandleStockAsset
 import fi.candle.generated.http.models.StockAssetQuoteRequest as CandleStockAssetQuoteRequest
@@ -65,9 +75,29 @@ import fi.candle.generated.http.models.WireDetails as CandleWireDetails
 import java.math.BigDecimal
 import java.util.UUID
 
-internal fun Service.toCandleModel(): CandleService = CandleService.valueOf(name)
+internal fun ServiceID.toCandleModel(): CandleServiceID = CandleServiceID.valueOf(name)
 
-internal fun CandleService.toReactModel(): Service = Service.valueOf(name)
+internal fun CandleServiceID.toReactModel(): ServiceID = ServiceID.valueOf(name)
+
+internal fun Service.toCandleModel(): CandleService {
+    return CandleService(
+        id = id.toCandleModel(),
+        displayName = displayName,
+        logoURL = logoURL,
+        thumbhash = thumbhash,
+        accentColor = accentColor,
+    )
+}
+
+internal fun CandleService.toReactModel(): Service {
+    return Service(
+        id = id.toReactModel(),
+        displayName = displayName,
+        logoURL = logoURL,
+        thumbhash = thumbhash,
+        accentColor = accentColor,
+    )
+}
 
 internal fun LinkedAccountRef.toGetLinkedAccountRef(): Operations.GetLinkedAccount.Input.Path {
     return Operations.GetLinkedAccount.Input.Path(
@@ -350,6 +380,8 @@ internal fun CandleTradeAsset.toReactModel(): TradeAsset {
                 stockAsset = null,
                 transportAsset = null,
                 eventAsset = null,
+                messageThreadAsset = null,
+                friendRequestAsset = null,
                 otherAsset = null,
                 nothingAsset = null,
             )
@@ -374,6 +406,8 @@ internal fun CandleTradeAsset.toReactModel(): TradeAsset {
                 stockAsset = null,
                 transportAsset = null,
                 eventAsset = null,
+                messageThreadAsset = null,
+                friendRequestAsset = null,
                 otherAsset = null,
                 nothingAsset = null,
             )
@@ -398,6 +432,8 @@ internal fun CandleTradeAsset.toReactModel(): TradeAsset {
                     ),
                 transportAsset = null,
                 eventAsset = null,
+                messageThreadAsset = null,
+                friendRequestAsset = null,
                 otherAsset = null,
                 nothingAsset = null,
             )
@@ -427,6 +463,8 @@ internal fun CandleTradeAsset.toReactModel(): TradeAsset {
                         service = service.toReactModel(),
                     ),
                 eventAsset = null,
+                messageThreadAsset = null,
+                friendRequestAsset = null,
                 otherAsset = null,
                 nothingAsset = null,
             )
@@ -452,6 +490,67 @@ internal fun CandleTradeAsset.toReactModel(): TradeAsset {
                         linkedAccountID = linkedAccountID.toString(),
                         service = service.toReactModel(),
                     ),
+                messageThreadAsset = null,
+                friendRequestAsset = null,
+                otherAsset = null,
+                nothingAsset = null,
+            )
+
+        is CandleMessageThreadAsset ->
+            TradeAsset(
+                fiatAsset = null,
+                cryptoAsset = null,
+                stockAsset = null,
+                transportAsset = null,
+                eventAsset = null,
+                messageThreadAsset =
+                    MessageThreadAsset(
+                        assetKind = "message_thread",
+                        serviceTradeID = serviceTradeID,
+                        messages =
+                            messages
+                                .map {
+                                    MessageThreadMessage(
+                                        serviceMessageID = it.serviceMessageID,
+                                        senderProfileURN = it.senderProfileURN,
+                                        senderLegalName = it.senderLegalName,
+                                        senderUsername = it.senderUsername,
+                                        text = it.text,
+                                        dateTime = it.dateTime,
+                                    )
+                                }
+                                .toTypedArray(),
+                        linkedAccountID = linkedAccountID.toString(),
+                        service = service.toReactModel(),
+                    ),
+                friendRequestAsset = null,
+                otherAsset = null,
+                nothingAsset = null,
+            )
+
+        is CandleFriendRequestAsset ->
+            TradeAsset(
+                fiatAsset = null,
+                cryptoAsset = null,
+                stockAsset = null,
+                transportAsset = null,
+                eventAsset = null,
+                messageThreadAsset = null,
+                friendRequestAsset =
+                    FriendRequestAsset(
+                        assetKind = "friend_request",
+                        serviceTradeID = serviceTradeID,
+                        direction = direction.toReactModel(),
+                        user =
+                            UserCounterparty(
+                                kind = "user",
+                                legalName = user.legalName,
+                                avatarURL = user.avatarURL,
+                                username = user.username,
+                            ),
+                        linkedAccountID = linkedAccountID.toString(),
+                        service = service.toReactModel(),
+                    ),
                 otherAsset = null,
                 nothingAsset = null,
             )
@@ -463,6 +562,8 @@ internal fun CandleTradeAsset.toReactModel(): TradeAsset {
                 stockAsset = null,
                 transportAsset = null,
                 eventAsset = null,
+                messageThreadAsset = null,
+                friendRequestAsset = null,
                 otherAsset = OtherAsset(assetKind = "other"),
                 nothingAsset = null,
             )
@@ -474,6 +575,8 @@ internal fun CandleTradeAsset.toReactModel(): TradeAsset {
                 stockAsset = null,
                 transportAsset = null,
                 eventAsset = null,
+                messageThreadAsset = null,
+                friendRequestAsset = null,
                 otherAsset = null,
                 nothingAsset = NothingAsset(assetKind = "nothing"),
             )
@@ -553,6 +656,33 @@ internal fun TradeAsset.toCandleModel(): CandleTradeAsset {
             service = it.service.toCandleModel(),
         )
     }
+    messageThreadAsset?.let {
+        return CandleMessageThreadAsset(
+            serviceTradeID = it.serviceTradeID,
+            linkedAccountID = UUID.fromString(it.linkedAccountID),
+            messages =
+                it.messages.map { message ->
+                    CandleMessageThreadMessage(
+                        serviceMessageID = message.serviceMessageID,
+                        senderProfileURN = message.senderProfileURN,
+                        senderLegalName = message.senderLegalName,
+                        senderUsername = message.senderUsername,
+                        text = message.text,
+                        dateTime = message.dateTime,
+                    )
+                },
+            service = it.service.toCandleModel(),
+        )
+    }
+    friendRequestAsset?.let {
+        return CandleFriendRequestAsset(
+            serviceTradeID = it.serviceTradeID,
+            direction = it.direction.toCandleModel(),
+            user = it.user.toCandleModel(),
+            linkedAccountID = UUID.fromString(it.linkedAccountID),
+            service = it.service.toCandleModel(),
+        )
+    }
     if (otherAsset != null) return CandleOtherAsset
     if (nothingAsset != null) return CandleNothingAsset
     error("Internal Candle Error: corrupted trade asset.")
@@ -579,6 +709,10 @@ internal fun Counterparty.toCandleModel(): CandleCounterparty {
     error("Internal Candle Error: corrupted counterparty.")
 }
 
+internal fun UserCounterparty.toCandleModel(): CandleUserCounterparty {
+    return CandleUserCounterparty(legalName = legalName, avatarURL = avatarURL, username = username)
+}
+
 internal fun CandleMerchantLocation.toReactModel(): MerchantLocation {
     return MerchantLocation(
         countryCode = countryCode,
@@ -664,6 +798,12 @@ internal fun TradeAssetQuoteRequest.toCandleModel(): CandleTradeAssetQuoteReques
             dateTime = it.dateTime,
         )
     }
+    messageThreadAssetQuoteRequest?.let {
+        return CandleMessageThreadAssetQuoteRequest(text = it.text)
+    }
+    friendRequestAssetQuoteRequest?.let {
+        return CandleFriendRequestAssetQuoteRequest(action = it.action.toCandleModel())
+    }
     if (nothingAssetQuoteRequest != null) return CandleNothingAssetQuoteRequest
     if (otherAssetQuoteRequest != null) return CandleOtherAssetQuoteRequest
     error("Internal Candle Error: corrupted trade asset quote request.")
@@ -716,6 +856,18 @@ internal fun TradeAssetRef.toCandleModel(): CandleTradeAssetRef {
             serviceTradeID = it.serviceTradeID,
         )
     }
+    messageThreadAssetRef?.let {
+        return CandleMessageThreadAssetRef(
+            linkedAccountID = UUID.fromString(it.linkedAccountID),
+            serviceTradeID = it.serviceTradeID,
+        )
+    }
+    friendRequestAssetRef?.let {
+        return CandleFriendRequestAssetRef(
+            linkedAccountID = UUID.fromString(it.linkedAccountID),
+            serviceTradeID = it.serviceTradeID,
+        )
+    }
     if (otherAssetRef != null) return CandleOtherAsset
     if (nothingAssetRef != null) return CandleNothingAsset
     error("Internal Candle Error: corrupted trade asset ref.")
@@ -737,6 +889,33 @@ internal fun CandleLinkedAccountStatusRefState.toReactModel(): LinkedAccountStat
     }
 }
 
+internal fun CandleFriendRequestAssetDirection.toReactModel(): FriendRequestAssetDirection {
+    return when (this) {
+        CandleFriendRequestAssetDirection.RECEIVED -> FriendRequestAssetDirection.RECEIVED
+        CandleFriendRequestAssetDirection.SENT -> FriendRequestAssetDirection.SENT
+    }
+}
+
+internal fun FriendRequestAssetDirection.toCandleModel(): CandleFriendRequestAssetDirection {
+    return when (this) {
+        FriendRequestAssetDirection.RECEIVED -> CandleFriendRequestAssetDirection.RECEIVED
+        FriendRequestAssetDirection.SENT -> CandleFriendRequestAssetDirection.SENT
+    }
+}
+
+internal fun FriendRequestAssetQuoteRequestAction.toCandleModel():
+    CandleFriendRequestAssetQuoteRequestAction {
+    return when (this) {
+        FriendRequestAssetQuoteRequestAction.ACCEPT ->
+            CandleFriendRequestAssetQuoteRequestAction.ACCEPT
+        FriendRequestAssetQuoteRequestAction.REJECT ->
+            CandleFriendRequestAssetQuoteRequestAction.REJECT
+        FriendRequestAssetQuoteRequestAction.SEND -> CandleFriendRequestAssetQuoteRequestAction.SEND
+        FriendRequestAssetQuoteRequestAction.WITHDRAW ->
+            CandleFriendRequestAssetQuoteRequestAction.WITHDRAW
+    }
+}
+
 internal fun CandleACHAccountKind.toReactModel(): ACHAccountKind = ACHAccountKind.valueOf(name)
 
 internal fun CandleFinancialAccountKind.toReactModel(): FinancialAccountKind {
@@ -783,6 +962,10 @@ internal fun TradeAssetKind.toCandleGainedAssetKind():
         TradeAssetKind.TRANSPORT ->
             Operations.GetTrades.Input.Query.GainedAssetKindPayload.TRANSPORT
         TradeAssetKind.EVENT -> Operations.GetTrades.Input.Query.GainedAssetKindPayload.EVENT
+        TradeAssetKind.MESSAGE_THREAD ->
+            Operations.GetTrades.Input.Query.GainedAssetKindPayload.MESSAGE_THREAD
+        TradeAssetKind.FRIEND_REQUEST ->
+            Operations.GetTrades.Input.Query.GainedAssetKindPayload.FRIEND_REQUEST
         TradeAssetKind.OTHER -> Operations.GetTrades.Input.Query.GainedAssetKindPayload.OTHER
         TradeAssetKind.NOTHING -> Operations.GetTrades.Input.Query.GainedAssetKindPayload.NOTHING
     }
@@ -796,6 +979,10 @@ internal fun TradeAssetKind.toCandleLostAssetKind():
         TradeAssetKind.CRYPTO -> Operations.GetTrades.Input.Query.LostAssetKindPayload.CRYPTO
         TradeAssetKind.TRANSPORT -> Operations.GetTrades.Input.Query.LostAssetKindPayload.TRANSPORT
         TradeAssetKind.EVENT -> Operations.GetTrades.Input.Query.LostAssetKindPayload.EVENT
+        TradeAssetKind.MESSAGE_THREAD ->
+            Operations.GetTrades.Input.Query.LostAssetKindPayload.MESSAGE_THREAD
+        TradeAssetKind.FRIEND_REQUEST ->
+            Operations.GetTrades.Input.Query.LostAssetKindPayload.FRIEND_REQUEST
         TradeAssetKind.OTHER -> Operations.GetTrades.Input.Query.LostAssetKindPayload.OTHER
         TradeAssetKind.NOTHING -> Operations.GetTrades.Input.Query.LostAssetKindPayload.NOTHING
     }

package/android/src/main/java/com/margelo/nitro/rncandle/HybridRNCandle.kt

@@ -10,18 +10,19 @@ import androidx.compose.ui.platform.ViewCompositionStrategy
 import com.margelo.nitro.NitroModules
 import com.margelo.nitro.core.Promise
 import fi.candle.Candle
-import fi.candle.client.supportedServices
 import fi.candle.ui.CandleUiContent
 import fi.candle.ui.models.PresentationStyle as CandlePresentationStyle
 import java.util.concurrent.atomic.AtomicBoolean
 
 class HybridRNCandle : HybridRNCandleSpec() {
     private val mainHandler = Handler(Looper.getMainLooper())
+    private val hostedAuthorizationRequests =
+        mutableMapOf<String, Candle.Client.HostedAuthorizationRequest>()
 
     private var linkSheetView: ComposeView? = null
     private var tradeSheetView: ComposeView? = null
 
-    override fun initialize(appKey: String, appSecret: String, accessGroup: String?) {
+    override fun initialize(clientID: String, accessGroup: String?) {
         ReactNativeCandleOnLoad.initializeNative()
         val context =
             NitroModules.applicationContext
@@ -31,18 +32,19 @@ class HybridRNCandle : HybridRNCandleSpec() {
 
         // Android does not use the iOS keychain access-group concept.
         accessGroup?.let {}
-        Candle.Client.initialize(context, appKey, appSecret)
+        Candle.Client.initialize(context, clientID)
     }
 
     override fun candleLinkSheet(
         isPresented: Boolean,
-        services: Array<Service>?,
+        services: Array<ServiceID>?,
+        showSandbox: Boolean,
         cornerRadius: Double,
         customerName: String?,
         showDynamicLoading: Boolean,
         presentationBackground: PresentationBackground,
         presentationStyle: PresentationStyle,
-        onSuccess: (account: LinkedAccount) -> Unit,
+        onSuccess: (linkedAccount: LinkedAccount) -> Unit,
     ) {
         runOnMainThread {
             if (!isPresented) {
@@ -57,7 +59,8 @@ class HybridRNCandle : HybridRNCandleSpec() {
             val composeView = createOverlayView(activity)
             composeView.setContent(
                 CandleUiContent.candleLinkSheet(
-                    services = services?.map { it.toCandleModel() } ?: supportedServices,
+                    services = services?.map { it.toCandleModel() } ?: emptyList(),
+                    showSandbox = showSandbox,
                     customerName = customerName,
                     cornerRadiusDp = cornerRadius.toFloat(),
                     showDynamicLoading = showDynamicLoading,
@@ -179,12 +182,62 @@ class HybridRNCandle : HybridRNCandleSpec() {
         }
     }
 
-    override fun createUser(appUserID: String): Promise<Unit> {
-        return Promise.async { Candle.Client.shared.createUser(appUserID) }
+    override fun hostedAuthorizationUrl(
+        redirectUri: String,
+        state: String,
+        codeChallenge: String,
+        grantPackagePublicKey: String,
+    ): String {
+        return Candle.Client.shared.hostedAuthorizationUrl(
+            redirectUri = redirectUri,
+            state = state,
+            codeChallenge = codeChallenge,
+            grantPackagePublicKey = grantPackagePublicKey,
+        )
     }
 
-    override fun deleteUser(): Promise<Unit> {
-        return Promise.async { Candle.Client.shared.deleteUser() }
+    override fun makeHostedAuthorizationRequest(
+        redirectUri: String,
+        state: String?,
+    ): HostedAuthorizationRequest {
+        val request =
+            Candle.Client.shared.makeHostedAuthorizationRequest(
+                redirectUri = redirectUri,
+                state = state,
+            )
+        hostedAuthorizationRequests[request.state] = request
+        return HostedAuthorizationRequest(
+            url = request.url,
+            state = request.state,
+            codeVerifier = request.codeVerifier,
+            grantPackagePublicKey = request.grantPackagePublicKey,
+        )
+    }
+
+    override fun parseHostedAuthorizationCallback(
+        callbackUrl: String
+    ): HostedAuthorizationCallback {
+        val callback = Candle.Client.shared.parseHostedAuthorizationCallback(callbackUrl)
+        return HostedAuthorizationCallback(
+            authorizationCode = callback.authorizationCode,
+            encryptedGrantPackage = callback.encryptedGrantPackage,
+            state = callback.state,
+        )
+    }
+
+    override fun completeHostedAuthorization(callbackUrl: String): Promise<Unit> {
+        return Promise.async {
+            val callback = Candle.Client.shared.parseHostedAuthorizationCallback(callbackUrl)
+            val state = callback.state ?: error("Candle hosted auth callback is missing state.")
+            val request =
+                hostedAuthorizationRequests.remove(state)
+                    ?: error("Candle hosted auth state was not started.")
+            Candle.Client.shared.completeHostedAuthorization(request, callbackUrl)
+        }
+    }
+
+    override fun signOut(): Promise<Unit> {
+        return Promise.async { Candle.Client.shared.signOut() }
     }
 
     private fun runOnMainThread(block: () -> Unit) {

package/ios/Sources/CandleLinkSheetWrapperView.swift

@@ -27,7 +27,8 @@ import SwiftUI
                         isPresented: $viewModel.showSheet,
                         customerName: viewModel.customerName,
                         cornerRadius: viewModel.cornerRadius,
-                        services: services.map(Models.Service.init(reactModel:)),
+                        services: services.map(Models.ServiceID.init(reactModel:)),
+                        showSandbox: viewModel.showSandbox,
                         showDynamicLoading: viewModel.showDynamicLoading,
                         presentationStyle: viewModel.toCandlePresentationStyle,
                         presentationBackground: viewModel.toCandlePresentationBackground
@@ -39,7 +40,7 @@ import SwiftUI
                     isPresented: $viewModel.showSheet,
                     customerName: viewModel.customerName,
                     cornerRadius: viewModel.cornerRadius,
-                    services: .supported,
+                    showSandbox: viewModel.showSandbox,
                     showDynamicLoading: viewModel.showDynamicLoading,
                     presentationStyle: viewModel.toCandlePresentationStyle,
                     presentationBackground: viewModel.toCandlePresentationBackground

package/ios/Sources/CandleLinkViewModel.swift

@@ -6,7 +6,8 @@ import SwiftUI
     @Published var showSheet = false
     @Published var linkedAccount: Models.LinkedAccount?
     @Published var isPresented: Bool = false
-    @Published var services: [Service]?
+    @Published var services: [ServiceID]?
+    @Published var showSandbox = false
     @Published var cornerRadius: Double = 0
     @Published var customerName: String?
     @Published var showDynamicLoading: Bool = false

package/ios/Sources/RNCandle.swift

@@ -7,10 +7,13 @@ import UIKit
 
 @available(iOS 17.0, *) final class HybridRNCandle: HybridRNCandleSpec {
     private var rootVC: UIHostingController<CandleLinkSheetWrapper>?
+    private var hostedAuthorizationRequests = [String: Candle.HostedAuthorizationRequest]()
 
     private var cancellables = Set<AnyCancellable>()
     private var linkSheetPresentationCancellable: AnyCancellable?
     private var linkSheetSuccessCancellable: AnyCancellable?
+    private var linkSheetSuccessCallback: ((LinkedAccount) -> Void)?
+    private var linkSheetSuccessCallbackToken = 0
 
     var viewModel: CandleLinkViewModel {
         get throws {
@@ -21,8 +24,8 @@ import UIKit
 
     // MARK: - UI
 
-    public func initialize(appKey: String, appSecret: String, accessGroup: String?) throws {
-        try Client.initialize(appKey: appKey, appSecret: appSecret, accessGroup: accessGroup)
+    public func initialize(clientID: String, accessGroup: String?) throws {
+        try Client.initialize(clientID: clientID, accessGroup: accessGroup)
         Task { @MainActor in
             let wrapperView = CandleLinkSheetWrapper()
             let hostingVC = UIHostingController(rootView: wrapperView)
@@ -32,7 +35,8 @@ import UIKit
 
     public func candleLinkSheet(
         isPresented: Bool,
-        services: [Service]?,
+        services: [ServiceID]?,
+        showSandbox: Bool,
         cornerRadius: Double,
         customerName: String?,
         showDynamicLoading: Bool,
@@ -43,10 +47,14 @@ import UIKit
         Task { @MainActor in
             linkSheetPresentationCancellable?.cancel()
             linkSheetSuccessCancellable?.cancel()
+            linkSheetSuccessCallback = onSuccess
+            linkSheetSuccessCallbackToken += 1
+            let callbackToken = linkSheetSuccessCallbackToken
 
             try viewModel.linkedAccount = nil
             try viewModel.isPresented = isPresented
             try viewModel.services = services
+            try viewModel.showSandbox = showSandbox
             try viewModel.cornerRadius = cornerRadius
             try viewModel.customerName = customerName
             try viewModel.showDynamicLoading = showDynamicLoading
@@ -80,8 +88,15 @@ import UIKit
                     if let rootVC = self?.rootVC, !isPresented { parentVC.removeEmbedded(rootVC) }
                 })
             linkSheetSuccessCancellable = try viewModel.$linkedAccount.removeDuplicates()
-                .compactMap(\.?.reactModel).prefix(1).receive(on: RunLoop.main)
-                .sink(receiveValue: onSuccess)
+                .compactMap { $0 }.prefix(1).receive(on: RunLoop.main)
+                .sink { [weak self] linkedAccount in
+                    self?.linkSheetSuccessCallback?(linkedAccount.reactModel)
+                    DispatchQueue.main.asyncAfter(deadline: .now() + 10) { [weak self] in
+                        if self?.linkSheetSuccessCallbackToken == callbackToken {
+                            self?.linkSheetSuccessCallback = nil
+                        }
+                    }
+                }
         }
     }
 
@@ -215,13 +230,75 @@ import UIKit
         }
     }
 
-    public func createUser(appUserID: String) throws -> Promise<Void> {
-        .async { try await Client.shared.createUser(appUserID: appUserID) }
+    public func hostedAuthorizationUrl(
+        redirectUri: String,
+        state: String,
+        codeChallenge: String,
+        grantPackagePublicKey: String
+    ) throws -> String {
+        return Client.shared
+            .hostedAuthorizationURL(
+                redirectURI: redirectUri,
+                state: state,
+                codeChallenge: codeChallenge,
+                grantPackagePublicKey: grantPackagePublicKey
+            )
+            .absoluteString
+    }
+
+    public func makeHostedAuthorizationRequest(redirectUri: String, state: String?) throws
+        -> HostedAuthorizationRequest
+    {
+        let request = try Client.shared.makeHostedAuthorizationRequest(
+            redirectURI: redirectUri,
+            state: state
+        )
+        hostedAuthorizationRequests[request.state] = request
+        return HostedAuthorizationRequest(
+            url: request.url.absoluteString,
+            state: request.state,
+            codeVerifier: request.codeVerifier,
+            grantPackagePublicKey: request.grantPackagePublicKey
+        )
+    }
+
+    public func parseHostedAuthorizationCallback(callbackUrl: String) throws
+        -> HostedAuthorizationCallback
+    {
+        guard let url = URL(string: callbackUrl),
+            let components = URLComponents(url: url, resolvingAgainstBaseURL: false),
+            let authorizationCode = components.queryItems?.first(where: { $0.name == "code" })?
+                .value
+        else { throw CandleError.unexpected(message: "Invalid Candle hosted auth callback.") }
+        let encryptedGrantPackage =
+            components.queryItems?.first(where: { $0.name == "candle_grant_package" })?.value
+            ?? URLComponents(string: "?\(components.fragment ?? "")")?.queryItems?
+            .first(where: { $0.name == "candle_grant_package" })?
+            .value
+        guard let encryptedGrantPackage else {
+            throw CandleError.unexpected(message: "Invalid Candle hosted auth callback.")
+        }
+        return HostedAuthorizationCallback(
+            authorizationCode: authorizationCode,
+            state: components.queryItems?.first(where: { $0.name == "state" })?.value,
+            encryptedGrantPackage: encryptedGrantPackage
+        )
     }
 
-    public func deleteUser() throws -> Promise<Void> {
-        .async { try await Client.shared.deleteUser() }
+    public func completeHostedAuthorization(callbackUrl: String) throws -> Promise<Void> {
+        guard let url = URL(string: callbackUrl) else {
+            throw CandleError.unexpected(message: "Invalid Candle hosted auth callback.")
+        }
+        let callback = try parseHostedAuthorizationCallback(callbackUrl: callbackUrl)
+        guard let state = callback.state,
+            let request = hostedAuthorizationRequests.removeValue(forKey: state)
+        else { throw CandleError.unexpected(message: "Candle hosted auth state was not started.") }
+        return .async {
+            try await Client.shared.completeHostedAuthorization(request: request, callbackURL: url)
+        }
     }
+
+    public func signOut() throws -> Promise<Void> { .async { try await Client.shared.signOut() } }
 }
 
 extension UIViewController {