@procivis/react-native-one-core 1.26999.0 → 1.41710.0

package/android/src/main/java/ch/procivis/one/core/SerializeSpecific.kt

@@ -40,6 +40,9 @@ object SerializeSpecific {
             when (metadata) {
                 is HistoryMetadataBinding.UnexportableEntities ->
                     return convertToRN(metadata.value) as ReadableMap
+
+                is HistoryMetadataBinding.ErrorMetadata ->
+                    return convertToRN(metadata.value) as ReadableMap
             }
         }
 
@@ -53,7 +56,13 @@ object SerializeSpecific {
             when (val value = c.value) {
                 is ClaimValueBindingDto.Boolean -> result.putBoolean("value", value.value)
                 is ClaimValueBindingDto.Float -> result.putDouble("value", value.value)
-                is ClaimValueBindingDto.Integer -> result.putInt("value", value.value.toInt())
+                is ClaimValueBindingDto.Integer -> {
+                    if (value.value < Int.MIN_VALUE || value.value > Int.MAX_VALUE) {
+                        result.putDouble("value", value.value.toDouble())
+                    } else {
+                        result.putInt("value", value.value.toInt())
+                    }
+                }
                 is ClaimValueBindingDto.String -> result.putString("value", value.value)
                 is ClaimValueBindingDto.Nested ->
                     result.putArray("value", convertToRN(value.value) as ReadableArray)
@@ -113,6 +122,9 @@ object SerializeSpecific {
                 is CredentialSchemaTypeBindingEnum.Mdoc ->
                     "MDOC"
 
+                is CredentialSchemaTypeBindingEnum.SdJwtVc ->
+                    "SD_JWT_VC"
+
                 is CredentialSchemaTypeBindingEnum.Other ->
                     type.value
             }

package/android/src/main/java/ch/procivis/one/core/Util.kt

@@ -1,20 +1,52 @@
 package ch.procivis.one.core
 
+import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReadableMap
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
 
 object Util {
-    // error handling
-    fun asyncCall(promise: Promise, function: () -> Any?) {
-        try {
-            promise.resolve(function())
-        } catch (error: Throwable) {
-            promise.reject(
-                error.javaClass.simpleName.replaceFirst(Regex("Exception$"), "Error"),
-                error.message,
-                error
-            )
+    // error handling + running core code outside JS thread
+    fun syncCall(promise: Promise, function: () -> Any?) {
+        object : Thread() {
+            override fun run() {
+                try {
+                    promise.resolve(function())
+                } catch (error: BindingException.ErrorResponse) {
+                    handleBindingException(promise, error)
+                } catch (error: Throwable) {
+                    promise.reject(error)
+                }
+            }
+        }.start()
+    }
+
+    fun asyncCall(promise: Promise, scope: CoroutineScope, function: suspend () -> Any?) {
+        scope.launch {
+            try {
+                promise.resolve(function())
+            } catch (error: BindingException.ErrorResponse) {
+                handleBindingException(promise, error)
+            } catch (error: Throwable) {
+                promise.reject(error)
+            }
+        }
+    }
+
+    private fun handleBindingException(promise: Promise, error: BindingException.ErrorResponse) {
+        val userInfo = Arguments.createMap()
+        val cause = error.data.cause?.message
+        if (!cause.isNullOrEmpty()) {
+            userInfo.putString("cause", cause)
         }
+
+        promise.reject(
+            error.data.code,
+            error.data.message,
+            error,
+            userInfo
+        )
     }
 }
 

package/android/src/main/java/ch/procivis/one/core/ubiqu/PinPadRunner.kt

@@ -0,0 +1,123 @@
+package ch.procivis.one.core.ubiqu
+
+import android.content.Intent
+import ch.procivis.one.core.NativeKeyStorageException
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.ubiqu.eid.sdk.requests.UbqRequestFlow
+
+object PinPadRunner {
+    enum class RequestType {
+        SUBSCRIBE,
+        TRANSACTION,
+        ADD_BIOMETRICS,
+        CHANGE_PIN
+    }
+
+    enum class RNEvent {
+        RSE_SHOW_PIN,
+        RSE_HIDE_PIN,
+        RSE_DIGITS_ENTERED,
+        RSE_PIN_STAGE,
+        RSE_INCORRECT_PIN
+    }
+
+    enum class RNEventParam {
+        flowType,
+        digitsEntered,
+        stage,
+        attemptsLeft,
+    }
+
+    enum class RNEventStage {
+        CHECK_CURRENT_PIN,
+        NEW_FIRST_PIN,
+        NEW_SECOND_PIN,
+    }
+
+    data class Flow(
+        val flow: UbqRequestFlow,
+        val promise: Util.Promise<String?>,
+        val type: RequestType
+    )
+
+    @Volatile
+    private var activeFlow: Flow? = null
+
+    @Synchronized
+    fun getActiveFlow(): Flow {
+        return activeFlow ?: throw NativeKeyStorageException.Unknown("No active flow")
+    }
+
+    private fun sendRNEvent(context: ReactContext, eventName: String, params: WritableMap?) {
+        context
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(eventName, params)
+    }
+
+    // ==== called from UbiquKeyStorage
+    @Synchronized
+    fun startPinPadFlow(
+        context: ReactContext,
+        flow: UbqRequestFlow,
+        requestType: RequestType,
+        promise: Util.Promise<String?>
+    ) {
+        if (activeFlow != null) {
+            throw NativeKeyStorageException.Unknown("Another PinPad flow in progress")
+        }
+
+        activeFlow = Flow(flow, promise, requestType)
+
+        val params = Arguments.createMap()
+        params.putString(RNEventParam.flowType.name, requestType.name)
+
+        val initialStage = when (requestType) {
+            RequestType.SUBSCRIBE -> RNEventStage.NEW_FIRST_PIN
+            else -> RNEventStage.CHECK_CURRENT_PIN
+        }
+        params.putString(RNEventParam.stage.name, initialStage.name)
+        sendRNEvent(context, RNEvent.RSE_SHOW_PIN.name, params)
+    }
+
+    @Synchronized
+    fun cancelPinPadFlow() {
+        activeFlow?.promise?.fail(NativeKeyStorageException.Unknown("Canceled by user"))
+        activeFlow = null
+    }
+
+    // ==== called from PinPadWrapper
+    @Synchronized
+    fun finishPinPadFlowSuccess(context: ReactContext, data: String?) {
+        activeFlow?.promise?.succeed(data)
+        activeFlow = null
+        sendRNEvent(context, RNEvent.RSE_HIDE_PIN.name, null)
+    }
+
+    @Synchronized
+    fun finishPinPadFlowFailure(context: ReactContext, error: Throwable) {
+        activeFlow?.promise?.fail(error)
+        activeFlow = null
+        sendRNEvent(context, RNEvent.RSE_HIDE_PIN.name, null)
+    }
+
+    fun digitsEntered(context: ReactContext, numPins: Int) {
+        val params = Arguments.createMap()
+        params.putInt(RNEventParam.digitsEntered.name, numPins)
+        sendRNEvent(context, RNEvent.RSE_DIGITS_ENTERED.name, params)
+    }
+
+    fun pinStage(context: ReactContext, stage: RNEventStage) {
+        val params = Arguments.createMap()
+        params.putString(RNEventParam.stage.name, stage.name)
+        sendRNEvent(context, RNEvent.RSE_PIN_STAGE.name, params)
+    }
+
+    fun incorrectPin(context: ReactContext, attemptsLeft: Int) {
+        val params = Arguments.createMap()
+        params.putInt(RNEventParam.attemptsLeft.name, attemptsLeft)
+        sendRNEvent(context, RNEvent.RSE_INCORRECT_PIN.name, params)
+    }
+}

package/android/src/main/java/ch/procivis/one/core/ubiqu/PinPadViewManager.kt

@@ -0,0 +1,23 @@
+package ch.procivis.one.core.ubiqu
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.ubiqu.eid.sdk.components.UbqInternalPad
+import com.ubiqu.eid.sdk.components.UbqPinPad
+
+class PinPadViewManager(private val callerContext: ReactApplicationContext) :
+    SimpleViewManager<UbqPinPad>() {
+    companion object {
+        const val REACT_CLASS = "RCTProcivisRSEPinPad"
+    }
+
+    override fun getName() = REACT_CLASS
+
+    override fun createViewInstance(context: ThemedReactContext): UbqPinPad {
+        val pinPad = UbqPinPad(context, extraButton = UbqInternalPad.ExtraButtonFunctionality.BIOMETRICS_AUTO.code)
+        val activeFlow = PinPadRunner.getActiveFlow()
+        PinPadWrapper(callerContext, pinPad, activeFlow.flow, activeFlow.type)
+        return pinPad
+    }
+}

package/android/src/main/java/ch/procivis/one/core/ubiqu/PinPadViewManager.kt_opensource

@@ -0,0 +1,20 @@
+package ch.procivis.one.core.ubiqu
+
+import android.view.View
+import ch.procivis.one.core.NativeKeyStorageException
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+
+class PinPadViewManager(private val callerContext: ReactApplicationContext) :
+    SimpleViewManager<View>() {
+    companion object {
+        const val REACT_CLASS = "RCTProcivisRSEPinPad"
+    }
+
+    override fun getName() = REACT_CLASS
+
+    override fun createViewInstance(context: ThemedReactContext): View {
+        throw NativeKeyStorageException.Unsupported()
+    }
+}

package/android/src/main/java/ch/procivis/one/core/ubiqu/PinPadWrapper.kt

@@ -0,0 +1,396 @@
+package ch.procivis.one.core.ubiqu
+
+import android.annotation.SuppressLint
+import android.util.Log
+import androidx.fragment.app.FragmentActivity
+import ch.procivis.one.core.NativeKeyStorageException
+import ch.procivis.one.core.ubiqu.PinPadRunner.digitsEntered
+import ch.procivis.one.core.ubiqu.PinPadRunner.finishPinPadFlowFailure
+import ch.procivis.one.core.ubiqu.PinPadRunner.finishPinPadFlowSuccess
+import ch.procivis.one.core.ubiqu.PinPadRunner.incorrectPin
+import ch.procivis.one.core.ubiqu.PinPadRunner.pinStage
+import com.facebook.react.bridge.ReactContext
+import com.ubiqu.eid.sdk.backend.assets.UbqAsset
+import com.ubiqu.eid.sdk.components.UbqPinPad
+import com.ubiqu.eid.sdk.enums.AddBiometricsState
+import com.ubiqu.eid.sdk.enums.ChangePinState
+import com.ubiqu.eid.sdk.enums.SubscribeState
+import com.ubiqu.eid.sdk.enums.TransactionState
+import com.ubiqu.eid.sdk.exceptions.UbqSdkException
+import com.ubiqu.eid.sdk.interfaces.AddBiometricsFinishInterface
+import com.ubiqu.eid.sdk.interfaces.AddBiometricsUiInterface
+import com.ubiqu.eid.sdk.interfaces.ChangePinFinishInterface
+import com.ubiqu.eid.sdk.interfaces.ChangePinUiInterface
+import com.ubiqu.eid.sdk.interfaces.SubscribeFinishInterface
+import com.ubiqu.eid.sdk.interfaces.SubscribeUiInterface
+import com.ubiqu.eid.sdk.interfaces.TransactionFinishInterface
+import com.ubiqu.eid.sdk.interfaces.TransactionUiInterface
+import com.ubiqu.eid.sdk.interfaces.UbqPinPadReporting
+import com.ubiqu.eid.sdk.requests.UbqAddBiometrics
+import com.ubiqu.eid.sdk.requests.UbqChangePin
+import com.ubiqu.eid.sdk.requests.UbqRequestFlow
+import com.ubiqu.eid.sdk.requests.UbqSubscribe
+import com.ubiqu.eid.sdk.requests.UbqTransaction
+
+
+@SuppressLint("LogNotTimber")
+class PinPadWrapper(
+    private val context: ReactContext,
+    private val pinPad: UbqPinPad,
+    private val flow: UbqRequestFlow,
+    flowType: PinPadRunner.RequestType
+) : SubscribeUiInterface, SubscribeFinishInterface,
+    UbqPinPadReporting, TransactionUiInterface, TransactionFinishInterface,
+    AddBiometricsUiInterface, AddBiometricsFinishInterface, ChangePinUiInterface,
+    ChangePinFinishInterface {
+
+    companion object {
+        private const val TAG = "ch.procivis.one.core.ubiqu.PinPadWrapper"
+    }
+
+    init {
+        pinPad.setKeyPadOnKeyListener(this)
+        pinPad.setOnPinInputFinishListener(flow)
+
+        when (flowType) {
+            PinPadRunner.RequestType.SUBSCRIBE -> {
+                (flow as UbqSubscribe).update(this)
+            }
+
+            PinPadRunner.RequestType.TRANSACTION -> {
+                val fragmentActivity = context.currentActivity as? FragmentActivity
+                val transaction = flow as UbqTransaction
+                transaction.update(this, fragmentActivity = fragmentActivity)
+                if (transaction.ubqAsset?.biometricsEnabled == true) {
+                    pinPad.enableBiometrics(transaction)
+                }
+            }
+
+            PinPadRunner.RequestType.ADD_BIOMETRICS -> {
+                (flow as UbqAddBiometrics).update(this)
+            }
+
+            PinPadRunner.RequestType.CHANGE_PIN -> {
+                (flow as UbqChangePin).update(this)
+            }
+        }
+    }
+
+    // ========== SubscribeUiInterface
+    override fun onSubscribeFirstPinEntered() {
+        Log.d(TAG, "onSubscribeFirstPinEntered")
+        updateSubscribeFlow(flow as UbqSubscribe)
+    }
+
+    override fun onSubscribePinConfirmed() {
+        Log.d(TAG, "onSubscribePinConfirmed")
+        updateSubscribeFlow(flow as UbqSubscribe)
+    }
+
+    override fun onSubscribePinNotConfirmed() {
+        Log.d(TAG, "onSubscribePinNotConfirmed")
+        updateSubscribeFlow(flow as UbqSubscribe)
+    }
+
+    override fun onSubscribePukEntered() {
+        Log.d(TAG, "onSubscribePukEntered")
+        updateSubscribeFlow(flow as UbqSubscribe)
+    }
+
+    override fun onSubscribeUiError(error: UbqSdkException) {
+        Log.w(TAG, "onSubscribeUiError: $error")
+        finishPinPadFlowFailure(context, error)
+    }
+
+    override fun onSubscribeUnallowedPinEntered() {
+        Log.d(TAG, "onSubscribeUnallowedPinEntered")
+        updateSubscribeFlow(flow as UbqSubscribe)
+    }
+
+    // ========== SubscribeFinishInterface
+    override fun onSubscribeCompleted(ubqAsset: UbqAsset) {
+        Log.d(TAG, "onSubscribeCompleted")
+        updateSubscribeFlow(flow as UbqSubscribe)
+    }
+
+    override fun onSubscribeFinishFailure(error: UbqSdkException) {
+        Log.w(TAG, "onSubscribeFinishFailure: $error")
+        finishPinPadFlowFailure(context, error)
+    }
+
+    override fun onSubscribeIncorrectPukEntered(ubqAsset: UbqAsset) {
+        Log.d(TAG, "onSubscribeIncorrectPukEntered")
+        finishPinPadFlowFailure(context, NativeKeyStorageException.Unknown("Wrong PUK"))
+    }
+
+    // ========== TransactionUiInterface
+    override fun onTransactionBiometricsEntered() {
+        Log.d(TAG, "onTransactionBiometricsEntered")
+        updateTransactionFlow(flow as UbqTransaction)
+    }
+
+    override fun onTransactionPinEntered() {
+        Log.d(TAG, "onTransactionPinEntered")
+        updateTransactionFlow(flow as UbqTransaction)
+    }
+
+    override fun onTransactionUiError(error: UbqSdkException) {
+        Log.w(TAG, "onTransactionUiError: $error")
+        finishPinPadFlowFailure(context, error)
+    }
+
+    // ========== TransactionFinishInterface
+    override fun onTransactionCompleted(result: String?) {
+        Log.d(TAG, "onTransactionCompleted")
+        finishPinPadFlowSuccess(context, result)
+    }
+
+    override fun onTransactionIncorrectPinEntered(pinAttemptsLeft: Int) {
+        Log.d(TAG, "onTransactionIncorrectPinEntered (attempts left: $pinAttemptsLeft)")
+        incorrectPin(context, pinAttemptsLeft)
+        if (pinAttemptsLeft == 0) {
+            finishPinPadFlowFailure(
+                context,
+                NativeKeyStorageException.Unknown("Exceeded PIN input attempts")
+            )
+        } else {
+            pinPad.clear(true)
+            pinStage(context, PinPadRunner.RNEventStage.CHECK_CURRENT_PIN)
+        }
+    }
+
+    override fun onTransactionFinishFailure(error: UbqSdkException) {
+        Log.w(TAG, "onTransactionFinishFailure: $error")
+        finishPinPadFlowFailure(context, error)
+    }
+
+    // ========== AddBiometricsUiInterface
+    override fun onAddBiometricsIncorrectBiometricsEntered() {
+        Log.d(TAG, "onAddBiometricsIncorrectBiometricsEntered")
+        updateAddBiometricsFlow(flow as UbqAddBiometrics)
+    }
+
+    override fun onAddBiometricsPinEntered() {
+        Log.d(TAG, "onAddBiometricsPinEntered")
+        updateAddBiometricsFlow(flow as UbqAddBiometrics)
+    }
+
+    override fun onAddBiometricsUiError(error: UbqSdkException) {
+        Log.w(TAG, "onAddBiometricsUiError: $error")
+        finishPinPadFlowFailure(context, error)
+    }
+
+    // ========== AddBiometricsFinishInterface
+    override fun onAddBiometricsCompleted() {
+        Log.d(TAG, "onAddBiometricsCompleted")
+        updateAddBiometricsFlow(flow as UbqAddBiometrics)
+    }
+
+    override fun onAddBiometricsFinishFailure(error: UbqSdkException) {
+        Log.w(TAG, "onAddBiometricsFinishFailure: $error")
+        finishPinPadFlowFailure(context, error)
+    }
+
+    override fun onAddBiometricsIncorrectPinEntered(pinAttemptsLeft: Int) {
+        Log.d(TAG, "onAddBiometricsIncorrectPinEntered (attempts left: $pinAttemptsLeft)")
+        incorrectPin(context, pinAttemptsLeft)
+        if (pinAttemptsLeft == 0) {
+            finishPinPadFlowFailure(
+                context,
+                NativeKeyStorageException.Unknown("Exceeded PIN input attempts")
+            )
+        } else {
+            pinPad.clear(true)
+            pinStage(context, PinPadRunner.RNEventStage.CHECK_CURRENT_PIN)
+        }
+    }
+
+    // ========== ChangePinUiInterface
+    override fun onChangePinPinEntered() {
+        Log.d(TAG, "onChangePinPinEntered")
+        updateChangePinFlow(flow as UbqChangePin)
+    }
+
+    override fun onChangePinNewPinEntered() {
+        Log.d(TAG, "onChangePinNewPinEntered")
+        updateChangePinFlow(flow as UbqChangePin)
+    }
+
+    override fun onChangePinPinConfirmed() {
+        Log.d(TAG, "onChangePinPinConfirmed")
+        updateChangePinFlow(flow as UbqChangePin)
+    }
+
+    override fun onChangePinPinNotConfirmed() {
+        Log.d(TAG, "onChangePinPinNotConfirmed")
+        updateChangePinFlow(flow as UbqChangePin)
+    }
+
+    override fun onChangePinUiError(error: UbqSdkException) {
+        Log.w(TAG, "onChangePinUiError: $error")
+        finishPinPadFlowFailure(context, error)
+    }
+
+    override fun onChangePinUnallowedPinEntered() {
+        Log.d(TAG, "onChangePinUnallowedPinEntered")
+        updateChangePinFlow(flow as UbqChangePin)
+    }
+
+    // ========== ChangePinFinishInterface
+    override fun onChangePinCompleted() {
+        Log.d(TAG, "onChangePinCompleted")
+        updateChangePinFlow(flow as UbqChangePin)
+    }
+
+    override fun onChangePinFinishFailure(error: UbqSdkException) {
+        Log.w(TAG, "onChangePinFinishFailure: $error")
+        finishPinPadFlowFailure(context, error)
+    }
+
+    override fun onChangePinIncorrectPinEntered(pinAttemptsLeft: Int) {
+        Log.d(TAG, "onChangePinIncorrectPinEntered (attempts left: $pinAttemptsLeft)")
+        incorrectPin(context, pinAttemptsLeft)
+        if (pinAttemptsLeft == 0) {
+            finishPinPadFlowFailure(
+                context,
+                NativeKeyStorageException.Unknown("Exceeded PIN input attempts")
+            )
+        } else {
+            pinStage(context, PinPadRunner.RNEventStage.CHECK_CURRENT_PIN)
+            finishPinPadFlowFailure(
+                context,
+                NativeKeyStorageException.Unknown("Incorrect PIN entered")
+            )
+        }
+    }
+
+    // ========== UbqPinPadReporting
+    override fun onDigitsChanged(newAmount: Int) {
+        Log.d(TAG, "onDigitsChanged: $newAmount")
+        digitsEntered(context, newAmount)
+    }
+
+    // private
+    private fun updateChangePinFlow(flow: UbqChangePin) {
+        when (flow.state) {
+            ChangePinState.AWAITING_PIN -> {
+                pinPad.clear(true)
+                pinStage(context, PinPadRunner.RNEventStage.CHECK_CURRENT_PIN)
+            }
+
+            ChangePinState.AWAITING_NEW_PIN -> {
+                pinPad.clear(true)
+                pinStage(context, PinPadRunner.RNEventStage.NEW_FIRST_PIN)
+            }
+
+            ChangePinState.AWAITING_CONFIRMATION_PIN -> {
+                pinPad.clear(true)
+                pinStage(context, PinPadRunner.RNEventStage.NEW_SECOND_PIN)
+            }
+
+            ChangePinState.AWAITING_FINISH -> {
+                flow.finish(this)
+            }
+
+            ChangePinState.SUCCESS -> {
+                finishPinPadFlowSuccess(context, null)
+            }
+
+            ChangePinState.FAILURE -> {
+                finishPinPadFlowFailure(
+                    context,
+                    NativeKeyStorageException.Unknown("Change PIN flow failure")
+                )
+            }
+
+            null -> {
+                throw NativeKeyStorageException.Unknown("Missing change PIN flow state")
+            }
+        }
+    }
+
+    private fun updateAddBiometricsFlow(flow: UbqAddBiometrics) {
+        when (flow.state) {
+            AddBiometricsState.AWAITING_PIN -> {
+                pinPad.clear(true)
+                pinStage(context, PinPadRunner.RNEventStage.CHECK_CURRENT_PIN)
+            }
+
+            AddBiometricsState.AWAITING_FINISH -> {
+                flow.finish(this)
+            }
+
+            AddBiometricsState.SUCCESS -> {
+                finishPinPadFlowSuccess(context, null)
+            }
+
+            AddBiometricsState.FAILURE -> {
+                finishPinPadFlowFailure(
+                    context,
+                    NativeKeyStorageException.Unknown("Add biometrics flow failure")
+                )
+            }
+
+            null -> {
+                throw NativeKeyStorageException.Unknown("Missing add biometrics flow state")
+            }
+        }
+    }
+
+    private fun updateTransactionFlow(flow: UbqTransaction) {
+        when (flow.state) {
+            TransactionState.AWAITING_PIN -> {
+                pinPad.clear(true)
+                pinStage(context, PinPadRunner.RNEventStage.CHECK_CURRENT_PIN)
+            }
+
+            TransactionState.AWAITING_FINISH -> {
+                flow.finish(this)
+            }
+
+            TransactionState.FAILURE -> {
+                finishPinPadFlowFailure(
+                    context,
+                    NativeKeyStorageException.Unknown("Transaction flow failure")
+                )
+            }
+
+            else -> {
+                throw NativeKeyStorageException.Unknown("Invalid transaction flow state ${flow.state}")
+            }
+        }
+    }
+
+    private fun updateSubscribeFlow(flow: UbqSubscribe) {
+        when (flow.state) {
+            SubscribeState.AWAITING_FIRST_PIN -> {
+                pinPad.clear(true)
+                pinStage(context, PinPadRunner.RNEventStage.NEW_FIRST_PIN)
+            }
+
+            SubscribeState.AWAITING_CONFIRMATION_PIN -> {
+                pinPad.clear(true)
+                pinStage(context, PinPadRunner.RNEventStage.NEW_SECOND_PIN)
+            }
+
+            SubscribeState.AWAITING_FINISH -> {
+                flow.finish(this)
+            }
+
+            SubscribeState.SUCCESS -> {
+                finishPinPadFlowSuccess(context, null)
+            }
+
+            SubscribeState.FAILURE -> {
+                finishPinPadFlowFailure(
+                    context,
+                    NativeKeyStorageException.Unknown("Subscribe flow failure")
+                )
+            }
+
+            else -> {
+                throw NativeKeyStorageException.Unknown("Invalid subscribe flow state ${flow.state}")
+            }
+        }
+    }
+}