@procivis/react-native-one-core 1.33398.0 → 1.43299.1

package/ios/RSEKeyStorage.swift

@@ -0,0 +1,587 @@
+import Foundation
+import UBQKit
+import ProcivisOneCore
+
+class RSEKeyStorage: NativeKeyStorage {
+    
+    struct TokenResponse: Decodable {
+        
+        let accessToken: String
+        
+        enum CodingKeys: String, CodingKey {
+            case accessToken = "access_token"
+        }
+    }
+    
+    struct CreateIdentityPayload: Encodable {
+        let sub: String
+    }
+    
+    struct CreateIdentityResponse: Decodable {
+        let sub: String
+    }
+    
+    struct RegisterRseResponse: Decodable {
+        let nonce: String
+        let puk: String
+    }
+    
+    private let identity_service_url = "https://api.identity.strongpin.ubiqu-sandbox.com"
+    private let organisation_id = "88e5fe80-106e-465c-a29d-1822d3790feb"
+    private let api_key = "eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9.eyJpc3MiOiJodHRwczovL2FwaS5pZGVudGl0eS5zdHJvbmdwaW4udWJpcXUtc2FuZGJveC5jb20iLCJpYXQiOjE3MzgzMzY2NTksImp0aSI6Ijc2NTY0M2FhLTI2NzgtNDFjZC04N2RiLThhODhmMzdjZDVhNSIsInNjb3BlIjoic2VydmljZV9hY2NvdW50Iiwic3ViIjoicHJvY2l2aXMtdGVzdCIsImF1ZCI6Imh0dHBzOi8vYXBpLnRva2VuLWdlbmVyYXRvci5zdHJvbmdwaW4udWJpcXUtc2FuZGJveC5jb20vdWJpcXUvIiwidG9rZW5fdHlwZSI6ImFwaV9rZXkifQ.RZtik0TlyoCd8M5BIKCsa0vQVols9eqB3QsvxPK-t5BvQO-v39VZoEQWahQCVQ2OKScEKX_EUeFiK0v1kzTLvKVGIIYuLYIBYJf6QQkc2MWroco54iDPMnK6_8J7EdRXdDhDH3-ukpzRrHwvOfAH50WGNco1U5QSqwvuwoWYWVANBZSBCSOMI4zYrNomEUbo04b-V10VjdHYMcpac14XxSNaxATSEliDVGv_JrAEOXSTs49ebGLT4OOdLHLoAfwu1NylpbvJQnhJYlpudzWf-46FM58uxCYs0DphYMtC6sC0XM1nhvcgli1ngzn-llSyaCQ1TY3PStU8RKxCtfa95A"
+    private let token_generator_url = "https://api.token-generator.strongpin.ubiqu-sandbox.com"
+    private let license = """
+        {"id": "26c46847-152e-44e8-b73a-b7d4c51c7074", "version": "0", "content": "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", "signature": "ijEe2xRd36VNR7WwAgDqBbt1jpvuqS/NJL6RG+w3x9gWImR/wm/7W3mCHTlEEJ6AS0md2hVZG1pKvZqApAG788xIeVSSDfuMYn57yCu8XPBVloQazGQu4xU9WjbocbKc5VNtu0Sb1us5tBsW1wJt8eQLaPErihEcQ9HW/EaXz1h5s4pKwed/bsuLtH1HdCulLMs1IKhJKuSWzjuaf2l9Tmg2Z354C2mPm8UnXX2TE77PVxCXegIic9U6tDOgelDgGLjKFLbZwkxpuK8kSRPnvSS/K8vkyl+5KxQEwNL6DC+glFWDwB3PpWi/reniqc5QzrBMUgsdMMoPTaWaXi9F8A=="}
+    """.data(using: .utf8)!
+    private let EDDSA_PREFIX_ASN1 = Data([0x30, 0x2a, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x70, 0x03, 0x21, 0x00])
+    
+    public static var available: Bool {
+        return true
+    }
+    
+    private var subscriber: RSESubscriber?
+    private var signTransaction: UbqTransaction?
+    private var changePinTransaction: UbqChangePin?
+    
+    init() {
+        try? UbqSdk.setup(with: license, loggingEnabled: true)
+    }
+    
+    func generateKey(keyAlias: String) async throws -> GeneratedKeyBindingDto {
+        if let asset = UbqSdk.assets.first {
+            if (asset.state == .normal) {
+                throw NativeKeyStorageError.KeyGenerationFailure(reason: "Already created")
+            } else {
+                // an asset can be left locked after an unfinished generation earlier (e.g. app forcefully closed during PIN setup)
+                try await delete()
+            }
+        }
+        
+        do {
+            let tokenUrl = URL(string: "\(token_generator_url)/ubiqu/")!
+            var tokenRequest = URLRequest(url: tokenUrl)
+            tokenRequest.httpMethod = "GET"
+            tokenRequest.setValue("bearer \(api_key)", forHTTPHeaderField: "Authorization")
+            let (tokenData, _) = try await URLSession.shared.data(for: tokenRequest)
+            
+            let tokenResponse = try JSONDecoder().decode(TokenResponse.self, from: tokenData)
+            let accessToken = tokenResponse.accessToken
+            
+            let identityUrl = URL(string: "\(identity_service_url)/organisation/\(organisation_id)/identity/")!
+            var identityRequest = URLRequest(url: identityUrl)
+            identityRequest.httpMethod = "POST"
+            identityRequest.setValue("application/json", forHTTPHeaderField: "Content-Type")
+            identityRequest.setValue("bearer \(accessToken)", forHTTPHeaderField: "Authorization")
+            identityRequest.httpBody = try JSONEncoder().encode(CreateIdentityPayload(sub: "ios-rse-example-\(generateRandomString(length: 16))"))
+            let (identityData, _) = try await URLSession.shared.data(for: identityRequest)
+            
+            let identityResponse = try JSONDecoder().decode(CreateIdentityResponse.self, from: identityData)
+            let subject = identityResponse.sub
+            
+            let rseUrl = URL(string: "\(identity_service_url)/organisation/\(organisation_id)/identity/\(subject)/register_rse/")!
+            var rseRequest = URLRequest(url: rseUrl)
+            rseRequest.httpMethod = "POST"
+            identityRequest.setValue("application/json", forHTTPHeaderField: "Content-Type")
+            rseRequest.setValue("bearer \(accessToken)", forHTTPHeaderField: "Authorization")
+            rseRequest.httpBody = try JSONEncoder().encode(CreateIdentityPayload(sub: "ios-rse-example- \(generateRandomString(length: 16))"))
+            let (rseData, _) = try await URLSession.shared.data(for: rseRequest)
+            
+            let rseResponse = try JSONDecoder().decode(RegisterRseResponse.self, from: rseData)
+            
+            let subscribeTransaction = try await withCheckedThrowingContinuation { continuation in
+                UbqSdk.subscribe(rseResponse.nonce, rseResponse.puk) { flow in
+                    continuation.resume(returning: flow)
+                } onStartFailure: { error in
+                    continuation.resume(throwing: error)
+                }
+            }
+            self.subscriber = await RSESubscriber(pinPad: RSEPinPad.self.sharedPinPad, transaction: subscribeTransaction)
+            let asset = try await self.subscriber!.perform()
+            self.subscriber = nil
+            
+            let derivedAsset = try await withCheckedThrowingContinuation { continuation in
+                asset.createDa(cryptoTypes: .EdDSA_25519) { derivedAsset in
+                    continuation.resume(returning: derivedAsset)
+                } failure: { error in
+                    continuation.resume(throwing: error)
+                }
+            }
+            
+            guard let keyReference = derivedAsset.uuid.uuidString.data(using: .utf8),
+                  let pemString = derivedAsset.publicKey,
+                  let publicKeyPrefixed = parsePEMPublicKeyContent(pemString) else {
+                throw NativeKeyStorageError.KeyGenerationFailure(reason: "Error getting keyReference or publicKey")
+            }
+            guard publicKeyPrefixed.subdata(in: 0..<12) == EDDSA_PREFIX_ASN1 else {
+                throw NativeKeyStorageError.KeyGenerationFailure(reason: "Invalid key prefix")
+            }
+            let publicKey = publicKeyPrefixed.subdata(in: 12..<44)
+            return GeneratedKeyBindingDto(keyReference: keyReference, publicKey: publicKey)
+        } catch {
+            self.subscriber = nil
+            ProcivisOneCoreEventEmitter.shared.sendHidePinEvent()
+            // delete paritally generated asset
+            try await delete()
+            throw NativeKeyStorageError.KeyGenerationFailure(reason: error.localizedDescription)
+        }
+    }
+    
+    func sign(keyReference: Data, message: Data) async throws -> Data {
+        guard let asset = UbqSdk.assets.first else {
+            throw NativeKeyStorageError.SignatureFailure(reason: "Key does not exist")
+        }
+        try await withCheckedThrowingContinuation { continuation in
+            asset.refreshDerivedAssets {
+                continuation.resume()
+            } failure: { error in
+                continuation.resume(throwing: error)
+            }
+        }
+        guard let derivedAsset = asset.derivedAssets.first,
+              let keyReferenceUUIDString = String(data: keyReference, encoding: .utf8),
+              derivedAsset.uuid == UUID(uuidString: keyReferenceUUIDString) else {
+            throw NativeKeyStorageError.SignatureFailure(reason: "Key does not exist")
+        }
+        
+        let signature: String?
+        
+        DispatchQueue.main.async {
+            RSEPinPad.sharedPinPad.isHidden = false
+            RSEPinPad.sharedPinPad.clear(makeVisible: true)
+            RSEPinPad.fixSubviews(view: RSEPinPad.sharedPinPad)
+        }
+        
+        do {
+            self.signTransaction = try await withCheckedThrowingContinuation { continuation in
+                derivedAsset.use(toBeSignedData: message.compactMap { String(format: "%02x", $0) }.joined()) { flow in
+                    continuation.resume(returning: flow)
+                } failure: { error in
+                    continuation.resume(throwing: error)
+                }
+            }
+            
+            signature = try await RSESigner(pinPad: RSEPinPad.self.sharedPinPad).perform(transaction: self.signTransaction!)
+            self.signTransaction = nil
+        } catch {
+            self.signTransaction = nil
+            ProcivisOneCoreEventEmitter.shared.sendHidePinEvent()
+            throw NativeKeyStorageError.SignatureFailure(reason: error.localizedDescription)
+        }
+        
+        guard let signature else {
+            throw NativeKeyStorageError.SignatureFailure(reason: "No signature returned")
+        }
+        guard let base64SignatureData = signature.data(using: .utf8),
+              let signatureData = Data(base64Encoded: base64SignatureData) else {
+            throw NativeKeyStorageError.SignatureFailure(reason: "Can't convert signature data")
+        }
+        
+        return signatureData
+    }
+    
+    func changePin() async throws {
+        guard let asset = UbqSdk.assets.first else {
+            throw NativeKeyStorageError.SignatureFailure(reason: "Key does not exist")
+        }
+        do {
+            self.changePinTransaction = try await withCheckedThrowingContinuation { continuation in
+                asset.changePin { flow in
+                    continuation.resume(returning: flow)
+                } failure: { error in
+                    continuation.resume(throwing: error)
+                }
+            }
+            
+            try await RSEPinChanger(pinPad: RSEPinPad.sharedPinPad).perform(transaction: self.changePinTransaction!)
+            self.changePinTransaction = nil
+        } catch {
+            self.changePinTransaction = nil
+            ProcivisOneCoreEventEmitter.shared.sendHidePinEvent()
+            throw NativeKeyStorageError.Unknown(reason: error.localizedDescription)
+        }
+    }
+    
+    var areBiometricsSupported: Bool {
+        return false
+    }
+    
+    var areBiometricsEnabled: Bool {
+        guard let asset = UbqSdk.assets.first else {
+            return false
+        }
+        return asset.biometricAuthenticationEnabled
+    }
+    
+    func enableBiometrics() async throws {
+        guard let asset = UbqSdk.assets.first else {
+            throw NativeKeyStorageError.SignatureFailure(reason: "Key does not exist")
+        }
+        do {
+            try await withCheckedThrowingContinuation { continuation in
+                asset.addBiometrics {
+                    continuation.resume(returning: Void())
+                } failure: { error in
+                    continuation.resume(throwing: error)
+                }
+            }
+        } catch {
+            ProcivisOneCoreEventEmitter.shared.sendHidePinEvent()
+            throw NativeKeyStorageError.Unknown(reason: error.localizedDescription)
+        }
+    }
+    
+    func disableBiometrics() throws {
+        guard let asset = UbqSdk.assets.first else {
+            throw NativeKeyStorageError.SignatureFailure(reason: "Key does not exist")
+        }
+        asset.removeBiometrics()
+    }
+    
+    func delete() async throws {
+        guard UbqSdk.assets.count > 0 else {
+            return
+        }
+        try await withCheckedThrowingContinuation { continuation in
+            UbqSdk.assets.forEach { asset in
+                asset.revoke() {
+                    asset.delete() {
+                        continuation.resume(returning: Void())
+                    } failure: { error in
+                        debugPrint("Error deleting RSE: \(error)")
+                        continuation.resume(throwing: error)
+                    }
+                } failure: { error in
+                    debugPrint("Error revoking RSE: \(error)")
+                    continuation.resume(throwing: error)
+                }
+            }
+        }
+    }
+    
+    func resetPinFlow() async throws {
+        if let subscriber {
+            subscriber.cancel(error: NativeKeyStorageError.KeyGenerationFailure(reason: "User canceled"))
+            self.subscriber = nil
+        }
+        
+        if let signTransaction {
+            signTransaction.cancel()
+            self.signTransaction = nil
+        }
+        if self.changePinTransaction != nil {
+            self.changePinTransaction = nil
+        }
+    }
+}
+
+private extension RSEKeyStorage {
+    
+    func generateRandomString(length: Int) -> String {
+        let letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
+        return String((0..<length).map { _ in letters.randomElement()! })
+    }
+    
+    func parsePEMPublicKeyContent(_ content: String) -> Data? {
+        let base64String = content
+            .replacingOccurrences(of: "-----BEGIN PUBLIC KEY-----\n", with: "")
+            .replacingOccurrences(of: "-----END PUBLIC KEY-----\n", with: "")
+            .split(separator: "\n")
+            .joined()
+        return Data(base64Encoded: base64String)
+    }
+}
+
+private class RSESubscriber: SubscribeUiProtocol, SubscribeFinishProtocol {
+    
+    enum SubscribeTransactionError: Error {
+        
+        case rejected
+        case exceededPinInputAttempts
+    }
+    
+    private var continuation: CheckedContinuation<UbqAsset, any Error>?
+    private var transaction: UbqSubscribe?
+    private weak var pinPad: UBQPinPad!
+    
+    init(pinPad: UBQPinPad, transaction: UbqSubscribe) {
+        self.pinPad = pinPad
+        self.transaction = transaction
+    }
+    
+    func perform() async throws -> UbqAsset {
+        DispatchQueue.main.async { [self] in
+            self.pinPad.clear(makeVisible: true)
+            RSEPinPad.fixSubviews(view: self.pinPad)
+        }
+        return try await withCheckedThrowingContinuation { continuation in
+            guard let transaction = self.transaction else {
+                continuation.resume(throwing: NativeKeyStorageError.KeyGenerationFailure(reason: "User canceled"))
+                return
+            }
+            transaction.setUiProtocol(i: self)
+            
+            do {
+                try ProcivisOneCoreEventEmitter.shared.sendShowPinEvent(flowType: .subscribe, stage: .newFirstPin)
+            } catch {
+                continuation.resume(throwing: error)
+                return
+            }
+            self.continuation = continuation
+        }
+    }
+    
+    func cancel(error: Error) {
+        self.transaction = nil
+        self.continuation?.resume(throwing: error)
+    }
+    
+    // MARK: SubscribeUiProtocol
+    
+    func onSubscribePukEntered() {
+        debugPrint("UBQ Subscribe Transaction puk entered")
+    }
+    
+    func onSubscribeFirstPinEntered() {
+        debugPrint("UBQ Subscribe Transaction first PIN entered")
+        self.pinPad.clear(makeVisible: true)
+        RSEPinPad.fixSubviews(view: pinPad)
+        ProcivisOneCoreEventEmitter.shared.sendPinStageChangeEvent(stage: .newSecondPin)
+    }
+    
+    func onSubscribeUnallowedPinEntered() {
+        debugPrint("UBQ Subscribe Transaction unallowed PIN entered")
+        self.pinPad.clear(makeVisible: true)
+        RSEPinPad.fixSubviews(view: pinPad)
+        ProcivisOneCoreEventEmitter.shared.sendPinStageChangeEvent(stage: .newFirstPin)
+    }
+    
+    func onSubscribePinNotConfirmed() {
+        debugPrint("UBQ Subscribe Transaction PIN not confirmed")
+        self.pinPad?.clear(makeVisible: true)
+        RSEPinPad.fixSubviews(view: pinPad)
+        ProcivisOneCoreEventEmitter.shared.sendPinStageChangeEvent(stage: .newFirstPin)
+    }
+    
+    func onSubscribePinConfirmed() {
+        debugPrint("UBQ Subscribe Transaction PIN confirmed")
+        ProcivisOneCoreEventEmitter.shared.sendHidePinEvent()
+        self.transaction?.finish(subscribeFinishProtocol: self)
+    }
+    
+    func onSubscribeUiError(error: UBQKit.UbqKitError) {
+        debugPrint("UBQ Subscribe Transaction UI error \(error)")
+        ProcivisOneCoreEventEmitter.shared.sendHidePinEvent()
+        self.continuation?.resume(throwing: error)
+    }
+    
+    // MARK: SubscribeFinishProtocol
+    
+    func onSubscribeCompleted(ubqAsset: UBQKit.UbqAsset) {
+        debugPrint("UBQ Subscribe Transaction completed with asset: \(ubqAsset)")
+        self.continuation?.resume(returning: ubqAsset)
+    }
+    
+    func onSubscribeFinishFailure(error: UBQKit.UbqKitError) {
+        debugPrint("UBQ Subscribe Transaction finish failure \(error)")
+        self.continuation?.resume(throwing: error)
+    }
+    
+    func onSubscribeIncorrectPukEntered(ubqAsset: UBQKit.UbqAsset) {
+        debugPrint("UBQ Subscribe Transaction incorrect puk entered \(ubqAsset)")
+    }
+}
+
+private class RSESigner: TransactionUiProtocol, TransactionFinishProtocol, TransactionRejectProtocol {
+    
+    enum SignTransactionError: Error {
+        
+        case rejected
+        case exceededPinInputAttempts
+    }
+    
+    private var continuation: CheckedContinuation<String?, any Error>?
+    private weak var transaction: UbqTransaction?
+    private weak var pinPad: UBQPinPad!
+    
+    init(pinPad: UBQPinPad) {
+        self.pinPad = pinPad
+    }
+    
+    func perform(transaction: UbqTransaction) async throws -> String? {
+        if self.transaction != nil {
+            self.transaction!.cancel()
+        }
+        self.transaction = transaction
+        DispatchQueue.main.async {
+            self.pinPad.clear(makeVisible: true)
+            RSEPinPad.fixSubviews(view: self.pinPad)
+        }
+        transaction.setUiProtocol(i: self)
+        transaction.setRejectProtocol(i: self)
+        try ProcivisOneCoreEventEmitter.shared.sendShowPinEvent(flowType: .transaction, stage: .checkCurrentPin)
+        return try await withCheckedThrowingContinuation { continuation in
+            self.continuation = continuation
+            transaction.start()
+        }
+    }
+    
+    // MARK: TransactionUiProtocol
+    
+    func onTransactionPinEntered() {
+        debugPrint("UBQ Sign Transaction PIN entered")
+        self.transaction?.finish(transactionFinishProtocol: self)
+    }
+    
+    func onTransactionBiometricsEntered() {
+        debugPrint("UBQ Sign Transaction biometrics entered")
+        self.transaction?.finish(transactionFinishProtocol: self)
+    }
+    
+    func onTransactionUiError(error: UBQKit.UbqKitError) {
+        debugPrint("UBQ Sign Transaction UI Error \(error)")
+        ProcivisOneCoreEventEmitter.shared.sendHidePinEvent()
+        self.continuation?.resume(throwing: error)
+    }
+    
+    // MARK: TransactionFinishProtocol
+    
+    func onTransactionCompleted(result: String?) {
+        debugPrint("UBQ Sign Transaction completed with result: \(result ?? "")")
+        ProcivisOneCoreEventEmitter.shared.sendHidePinEvent()
+        self.continuation?.resume(returning: result)
+    }
+    
+    func onTransactionFinishFailure(error: UBQKit.UbqKitError) {
+        debugPrint("UBQ Sign Transaction finish failure \(error)")
+        ProcivisOneCoreEventEmitter.shared.sendHidePinEvent()
+        self.continuation?.resume(throwing: error)
+    }
+    
+    func onTransactionIncorrectPinEntered(pinAttemptsLeft: Int8) {
+        debugPrint("UBQ Sign Transaction incorrect PIN, \(pinAttemptsLeft) attempts left")
+        ProcivisOneCoreEventEmitter.shared.sendIncorrectPinEvent(attemptsLeft: Int(pinAttemptsLeft))
+        if pinAttemptsLeft == 0 {
+            ProcivisOneCoreEventEmitter.shared.sendHidePinEvent()
+            self.transaction?.cancel()
+            self.continuation?.resume(throwing: SignTransactionError.exceededPinInputAttempts)
+        } else {
+            self.pinPad!.clear(makeVisible: true)
+            RSEPinPad.fixSubviews(view: pinPad)
+            ProcivisOneCoreEventEmitter.shared.sendPinStageChangeEvent(stage: .checkCurrentPin)
+        }
+    }
+    
+    // MARK: TransactionRejectProtocol
+    
+    func onTransactionRejected() {
+        debugPrint("UBQ Sign Transaction rejected")
+        ProcivisOneCoreEventEmitter.shared.sendHidePinEvent()
+        self.continuation?.resume(throwing: SignTransactionError.rejected)
+    }
+    
+    func onTransactionRejectFailure(error: UBQKit.UbqKitError) {
+        debugPrint("UBQ Sign Transaction reject failure \(error)")
+        ProcivisOneCoreEventEmitter.shared.sendHidePinEvent()
+        self.continuation?.resume(throwing: error)
+    }
+}
+
+private class RSEPinChanger: ChangePinUiProtocol, ChangePinFinishProtocol {
+    
+    enum PinChangeError: Error {
+        
+        case incorrectPinEntered
+        case unallowedPinEntered
+        case pinNotConfirmed
+        case exceededPinInputAttempts
+    }
+    
+    private var continuation: CheckedContinuation<Void, any Error>?
+    private weak var transaction: UbqChangePin?
+    private weak var pinPad: UBQPinPad!
+    
+    init(pinPad: UBQPinPad) {
+        self.pinPad = pinPad
+    }
+    
+    func perform(transaction: UbqChangePin) async throws {
+        self.transaction = transaction
+        DispatchQueue.main.async {
+            self.pinPad.clear(makeVisible: true)
+            RSEPinPad.fixSubviews(view: self.pinPad)
+        }
+        transaction.setUiProtocol(i: self)
+        try ProcivisOneCoreEventEmitter.shared.sendShowPinEvent(flowType: .changePin, stage: .checkCurrentPin)
+        return try await withCheckedThrowingContinuation { continuation in
+            self.continuation = continuation
+        }
+    }
+    
+    // MARK: ChangePinUiProtocol
+    
+    func onChangePinPinEntered() {
+        debugPrint("UBQ Change PIN Transaction PIN entered")
+        self.pinPad.clear(makeVisible: true)
+        RSEPinPad.fixSubviews(view: pinPad)
+        ProcivisOneCoreEventEmitter.shared.sendPinStageChangeEvent(stage: .newFirstPin)
+    }
+    
+    func onChangePinNewPinEntered() {
+        debugPrint("UBQ Change PIN Transaction new PIN entered")
+        self.pinPad.clear(makeVisible: true)
+        RSEPinPad.fixSubviews(view: pinPad)
+        ProcivisOneCoreEventEmitter.shared.sendPinStageChangeEvent(stage: .newSecondPin)
+    }
+    
+    func onChangePinUnallowedPinEntered() {
+        debugPrint("UBQ Change PIN Transaction unallowed PIN entered")
+        self.pinPad.clear(makeVisible: true)
+        RSEPinPad.fixSubviews(view: pinPad)
+        ProcivisOneCoreEventEmitter.shared.sendPinStageChangeEvent(stage: .checkCurrentPin)
+        continuation?.resume(throwing: PinChangeError.unallowedPinEntered)
+    }
+    
+    func onChangePinPinNotConfirmed() {
+        debugPrint("UBQ Change PIN Transaction PIN not confirmed")
+        self.pinPad.clear(makeVisible: true)
+        RSEPinPad.fixSubviews(view: pinPad)
+        ProcivisOneCoreEventEmitter.shared.sendPinStageChangeEvent(stage: .newFirstPin)
+    }
+    
+    func onChangePinPinConfirmed() {
+        debugPrint("UBQ Change PIN Transaction PIN confirmed")
+        transaction?.finish(changePinFinishProtocol: self)
+    }
+    
+    func onChangePinUiError(error: UBQKit.UbqKitError) {
+        debugPrint("UBQ Change PIN Transaction UI error \(error)")
+        ProcivisOneCoreEventEmitter.shared.sendHidePinEvent()
+        continuation?.resume(throwing: error)
+    }
+    
+    // MARK: ChangePinFinishProtocol
+    
+    func onChangePinCompleted() {
+        debugPrint("UBQ Change PIN Transaction completed")
+        ProcivisOneCoreEventEmitter.shared.sendHidePinEvent()
+        continuation?.resume(returning: Void())
+    }
+    
+    func onChangePinFinishFailure(error: UBQKit.UbqKitError) {
+        debugPrint("UBQ Change PIN Transaction finish failure \(error)")
+        ProcivisOneCoreEventEmitter.shared.sendHidePinEvent()
+        continuation?.resume(throwing: error)
+    }
+    
+    func onChangePinIncorrectPinEntered(pinAttemptsLeft: Int8) {
+        debugPrint("UBQ Change PIN Transaction incorrect PIN, \(pinAttemptsLeft) attempts left")
+        ProcivisOneCoreEventEmitter.shared.sendIncorrectPinEvent(attemptsLeft: Int(pinAttemptsLeft))
+        if pinAttemptsLeft == 0 {
+            ProcivisOneCoreEventEmitter.shared.sendHidePinEvent()
+            self.continuation?.resume(throwing: PinChangeError.exceededPinInputAttempts)
+        } else {
+            ProcivisOneCoreEventEmitter.shared.sendPinStageChangeEvent(stage: .checkCurrentPin)
+            self.continuation?.resume(throwing: PinChangeError.incorrectPinEntered)
+        }
+    }
+}

package/ios/RSEKeyStorage.swift_opensource

@@ -0,0 +1,49 @@
+import Foundation
+import ProcivisOneCore
+
+class RSEKeyStorage: NativeKeyStorage {
+    
+    public static var available: Bool {
+        return false
+    }
+    
+    init() {
+        fatalError("init() has not been implemented")
+    }
+    
+    func generateKey(keyAlias: String) async throws -> GeneratedKeyBindingDto {
+        fatalError("generateKey(keyAlias:) has not been implemented")
+    }
+    
+    func sign(keyReference: Data, message: Data) async throws -> Data {
+        fatalError("sign(keyReference:,message:) has not been implemented")
+    }
+    
+    func changePin() async throws {
+        fatalError("changePin() has not been implemented")
+    }
+    
+    var areBiometricsSupported: Bool {
+        fatalError("areBiometricsSupported has not been implemented")
+    }
+    
+    var areBiometricsEnabled: Bool {
+        fatalError("areBiometricsEnabled has not been implemented")
+    }
+    
+    func enableBiometrics() async throws {
+        fatalError("enableBiometrics() has not been implemented")
+    }
+    
+    func disableBiometrics() throws {
+        fatalError("disableBiometrics() has not been implemented")
+    }
+    
+    func delete() async throws {
+        fatalError("delete() has not been implemented")
+    }
+
+    func resetPinFlow() async throws {
+        fatalError("resetPinFlow() has not been implemented")
+    }
+}