@procivis/react-native-one-core 1.77931.0 → 1.81885.0

package/README.md

@@ -34,10 +34,10 @@ See the [key features][key] and complete solution [architecture][archi].
 
 ### Trial
 
-The fastest way to get started with the *Procivis One Wallet* is to download the app
+The fastest way to get started with the _Procivis One Wallet_ is to download the app
 from the iOS or Android app stores and [join our Trial Environment][trial].
 In the trial environment, you are given control of an organization on our server
-solution, the *Procivis One Desk*, and can quickly begin issuing and verifying credentials.
+solution, the _Procivis One Desk_, and can quickly begin issuing and verifying credentials.
 
 ### Documentation
 
@@ -65,9 +65,10 @@ allprojects {
 
 ## Usage
 
-```javascript
-import ONE from "react-native-one-core";
+```typescript
+import { initializeCore } from "react-native-one-core";
 ...
+const ONE = await initializeCore();
 await ONE.getVersion();
 ```
 
@@ -83,7 +84,7 @@ often referred to as Self-Sovereign Identity, or SSI.
 
 ## eIDAS 2.0
 
-If you want to provide an **EUDI Wallet**, *Procivis One* provides production grade open
+If you want to provide an **EUDI Wallet**, _Procivis One_ provides production grade open
 source components to get certified and connect your organization to the eIDAS 2.0 ecosystem.
 
 ![Procivis One in the eIDAS ARF](https://assets.procivis-one.com/static/diff/eIDAS_Architecture.png)
@@ -97,17 +98,17 @@ use the [Procivis One Core][core].
 
 ## Interoperability and conformance
 
-*Procivis One* is built using [open standards](#supported-standards) and tested to ensure
+_Procivis One_ is built using [open standards](#supported-standards) and tested to ensure
 interoperability with different software vendors and across different international
 regulatory ecosystems.
 
 - W3C standards
   - The W3C offers several test suites for standards conformance. See
-    the latest test results for *Procivis One* at [canivc.com][canivc].
+    the latest test results for _Procivis One_ at [canivc.com][canivc].
 - ISO/IEC 18013-5 mDL
-  - *Procivis One*'s implementation of the ISO mDL standard is compatible with the
-    OpenWallet Foundation's verifier: *Procivis One* can successfully issue mDL
-    credentials to a *Procivis One Wallet*, and these credentials can successfully
+  - _Procivis One_'s implementation of the ISO mDL standard is compatible with the
+    OpenWallet Foundation's verifier: _Procivis One_ can successfully issue mDL
+    credentials to a _Procivis One Wallet_, and these credentials can successfully
     be verified by the OpenWallet Foundation's verifier. See the [OpenWallet Foundation libraries][owf].
 - eIDAS 2.0; EUDI Wallet
   - The EU Digital Wallet is developing [issuer][eudiwi] and [verifier][eudiwv] testing for
@@ -125,10 +126,10 @@ and regulations mature and harden.
 
 - [W3C Verifiable Credentials Data Model 2.0][vcdm] in the following variations:
 
-| Securing mechanism                           | Supported representations                           | Supported proof/signature types                                                          |
-| -------------------------------------------- | ----------------------------------------- | ------------------------------------------------------------------------------ |
-| [W3C Data Integrity Proofs][vcdi] (embedded) | [JSON-LD][jld] in Compacted Document Form | <ul><li>[W3C Data Integrity ECDSA Cryptosuites v1.0][ecd] / [ecdsa-rdfc-2019][ecd2019]</li><li>[W3C Data Integrity EdDSA Cryptosuites v1.0][edd] / [eddsa-rdfc-2022][edd2022]</li><li>[W3C Data Integrity BBS Cryptosuites v1.0][bbs] / [bbs-2023][bbs2023]</li></ul> |
-| [W3C VC-JOSE-COSE][jose] (enveloping)        | <ul><li>[SD-JWT][sdjwt]</li><li>[JWT][jw]</li></ul> | <ul><li>JOSE / ECDSA [ES256][es2]</li><li>JOSE / EdDSA [Ed25519][ed255]</li><li>JOSE / CRYSTALS-DILITHIUM 3 [CRYDI3][crydi3]* |
+| Securing mechanism                           | Supported representations                           | Supported proof/signature types                                                                                                                                                                                                                                       |
+| -------------------------------------------- | --------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| [W3C Data Integrity Proofs][vcdi] (embedded) | [JSON-LD][jld] in Compacted Document Form           | <ul><li>[W3C Data Integrity ECDSA Cryptosuites v1.0][ecd] / [ecdsa-rdfc-2019][ecd2019]</li><li>[W3C Data Integrity EdDSA Cryptosuites v1.0][edd] / [eddsa-rdfc-2022][edd2022]</li><li>[W3C Data Integrity BBS Cryptosuites v1.0][bbs] / [bbs-2023][bbs2023]</li></ul> |
+| [W3C VC-JOSE-COSE][jose] (enveloping)        | <ul><li>[SD-JWT][sdjwt]</li><li>[JWT][jw]</li></ul> | <ul><li>JOSE / ECDSA [ES256][es2]</li><li>JOSE / EdDSA [Ed25519][ed255]</li><li>JOSE / CRYSTALS-DILITHIUM 3 [CRYDI3][crydi3]\*                                                                                                                                        |
 
 \* CRYSTALS-DILITHIUM is a post-quantum resistant signature scheme, selected by NIST for [Post-Quantum Cryptography Standardization][pqc].
 Support for the recently published [FIPS-204][fips] is planned for the near future.

package/android/build.gradle

@@ -75,17 +75,6 @@ dependencies {
     implementation 'net.java.dev.jna:jna:5.17.0@aar'
     implementation 'org.greenrobot:eventbus:3.3.1'
     implementation("org.jetbrains.kotlin:kotlin-reflect:${safeExtGet('kotlinVersion', '1.9.0')}")
-
-    implementation(name: 'core-reactnative-compatible-2025.0305.1', ext: 'aar')
-    implementation("com.google.android.material:material:1.9.0")
-    implementation("com.squareup.retrofit2:retrofit:2.11.0")
-    implementation("com.squareup.retrofit2:converter-scalars:2.11.0")
-    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.0")
-    implementation("com.jakewharton.retrofit:retrofit2-kotlinx-serialization-converter:1.0.0")
-    implementation("com.jakewharton.timber:timber:5.0.1")
-    implementation("org.apache.commons:commons-math3:3.6.1")
-    implementation 'androidx.appcompat:appcompat:1.6.1'
-    implementation 'androidx.biometric:biometric:1.1.0'
 }
 
 def downloadFile = { url, file ->

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

@@ -161,7 +161,7 @@ class ProcivisOneCoreModule(reactContext: ReactApplicationContext) :
     }
 
     @ReactMethod
-    fun getIdentifiers(query: ReadableMap, promise: Promise) {
+    fun listIdentifiers(query: ReadableMap, promise: Promise) {
         asyncCall(promise, scope) {
             val identifiers = getCore().listIdentifiers(construct(query))
             return@asyncCall convertToRN(identifiers)
@@ -482,7 +482,7 @@ class ProcivisOneCoreModule(reactContext: ReactApplicationContext) :
     }
 
     @ReactMethod
-    fun getHistory(query: ReadableMap, promise: Promise) {
+    fun getHistoryList(query: ReadableMap, promise: Promise) {
         asyncCall(promise, scope) {
             val history = getCore().getHistoryList(construct(query))
             return@asyncCall convertToRN(history)
@@ -520,7 +520,7 @@ class ProcivisOneCoreModule(reactContext: ReactApplicationContext) :
     }
 
     @ReactMethod
-    fun getTrustAnchors(query: ReadableMap, promise: Promise) {
+    fun listTrustAnchors(query: ReadableMap, promise: Promise) {
         asyncCall(promise, scope) {
             val trustAnchors = getCore().listTrustAnchors(construct(query))
             return@asyncCall convertToRN(trustAnchors)
@@ -543,7 +543,7 @@ class ProcivisOneCoreModule(reactContext: ReactApplicationContext) :
     }
 
     @ReactMethod
-    fun getTrustEntities(query: ReadableMap, promise: Promise) {
+    fun listTrustEntities(query: ReadableMap, promise: Promise) {
         asyncCall(promise, scope) {
             val trustEntity = getCore().listTrustEntities(construct(query))
             return@asyncCall convertToRN(trustEntity)

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

@@ -10,10 +10,11 @@ object SerializeSpecific {
         private val CustomConversionTypes =
             arrayOf(
                 HistoryMetadataBinding::class.java,
-                ClaimBindingDto::class.java,
-                ProofRequestClaimBindingDto::class.java,
-                CredentialQueryResponseBindingDto::class.java,
-                PresentationDefinitionV2ClaimBindingDto::class.java
+                ClaimValueBindingDto::class.java,
+                ProofRequestClaimValueBindingDto::class.java,
+                ApplicableCredentialOrFailureHintBindingEnum::class.java,
+                PresentationDefinitionV2ClaimValueBindingDto::class.java,
+                HandleInvitationResponseBindingEnum::class.java,
             )
 
         fun isCustomConversionType(input: Any?): Boolean {
@@ -29,63 +30,87 @@ object SerializeSpecific {
             if (input is HistoryMetadataBinding) {
                 return historyMetadata(input)
             }
-            if (input is ClaimBindingDto) {
-                return claim(input)
+            if (input is ClaimValueBindingDto) {
+                return claimValue(input)
             }
-            if (input is ProofRequestClaimBindingDto) {
-                return proofClaim(input)
+            if (input is ProofRequestClaimValueBindingDto) {
+                return proofClaimValue(input)
             }
-            if (input is CredentialQueryResponseBindingDto) {
+            if (input is ApplicableCredentialOrFailureHintBindingEnum) {
                 return credentialQuery(input)
             }
-            if (input is PresentationDefinitionV2ClaimBindingDto) {
-                return presentationDefinitionV2Claim(input)
+            if (input is PresentationDefinitionV2ClaimValueBindingDto) {
+                return presentationDefinitionV2ClaimValue(input)
+            }
+            if (input is HandleInvitationResponseBindingEnum) {
+                return invitationResponse(input)
             }
             throw IllegalArgumentException("Invalid map conversion: $input")
         }
 
         private fun historyMetadata(metadata: HistoryMetadataBinding): ReadableMap {
+            val result = Arguments.createMap()
             when (metadata) {
-                is HistoryMetadataBinding.UnexportableEntities ->
-                    return convertToRN(metadata.value) as ReadableMap
+                is HistoryMetadataBinding.UnexportableEntities -> {
+                    result.putString("type_", "UNEXPORTABLE_ENTITIES")
+                    result.putMap(
+                        "value",
+                        convertToRN(metadata.value) as ReadableMap
+                    )
+                }
 
-                is HistoryMetadataBinding.ErrorMetadata ->
-                    return convertToRN(metadata.value) as ReadableMap
+                is HistoryMetadataBinding.ErrorMetadata -> {
+                    result.putString("type_", "ERROR_METADATA")
+                    result.putMap(
+                        "value",
+                        convertToRN(metadata.value) as ReadableMap
+                    )
+                }
 
                 is HistoryMetadataBinding.WalletUnitJwt -> {
-                    val result = Arguments.createMap()
-                    result.putString("jwt", metadata.v1)
-                    return result
+                    result.putString("type_", "WALLET_UNIT_JWT")
+                    val values = Arguments.createArray()
+                    values.pushString(metadata.v1)
+                    result.putArray("value", values)
                 }
-
             }
+            return result
         }
 
-        private fun credentialQuery(dto: CredentialQueryResponseBindingDto): ReadableMap {
+        private fun credentialQuery(query: ApplicableCredentialOrFailureHintBindingEnum): ReadableMap {
             val result = Arguments.createMap()
-            result.putBoolean("multiple", dto.multiple)
-            when (val value = dto.credentialOrFailureHint) {
-                is ApplicableCredentialOrFailureHintBindingEnum.ApplicableCredentials -> result.putArray(
-                    "applicableCredentials",
-                    convertToRN(value.applicableCredentials) as ReadableArray
-                )
+            when (query) {
+                is ApplicableCredentialOrFailureHintBindingEnum.ApplicableCredentials -> {
+                    result.putString("type_", "APPLICABLE_CREDENTIALS")
+                    result.putArray(
+                        "applicableCredentials",
+                        convertToRN(query.applicableCredentials) as ReadableArray
+                    )
+                }
 
                 is ApplicableCredentialOrFailureHintBindingEnum.FailureHint -> {
-                    result.putMap("failureHint", convertToRN(value.failureHint) as ReadableMap)
+                    result.putString("type_", "FAILURE_HINT")
+                    result.putMap("failureHint", convertToRN(query.failureHint) as ReadableMap)
                 }
             }
             return result
         }
 
-        private fun claim(c: ClaimBindingDto): ReadableMap {
+        private fun claimValue(value: ClaimValueBindingDto): ReadableMap {
             val result = Arguments.createMap()
-            result.putString("path", c.path)
-            result.putMap("schema", convertToRN(c.schema) as ReadableMap)
+            when (value) {
+                is ClaimValueBindingDto.Boolean -> {
+                    result.putString("type_", "BOOLEAN")
+                    result.putBoolean("value", value.value)
+                }
+
+                is ClaimValueBindingDto.Float -> {
+                    result.putString("type_", "FLOAT")
+                    result.putDouble("value", value.value)
+                }
 
-            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.putString("type_", "INTEGER")
                     if (value.value < Int.MIN_VALUE || value.value > Int.MAX_VALUE) {
                         result.putDouble("value", value.value.toDouble())
                     } else {
@@ -93,50 +118,50 @@ object SerializeSpecific {
                     }
                 }
 
-                is ClaimValueBindingDto.String -> result.putString("value", value.value)
-                is ClaimValueBindingDto.Nested ->
+                is ClaimValueBindingDto.String -> {
+                    result.putString("type_", "STRING")
+                    result.putString("value", value.value)
+                }
+
+                is ClaimValueBindingDto.Nested -> {
+                    result.putString("type_", "NESTED")
                     result.putArray("value", convertToRN(value.value) as ReadableArray)
+                }
             }
-
             return result
         }
 
-        private fun proofClaim(c: ProofRequestClaimBindingDto): ReadableMap {
+        private fun proofClaimValue(value: ProofRequestClaimValueBindingDto): ReadableMap {
             val result = Arguments.createMap()
-            result.putMap("schema", convertToRN(c.schema) as ReadableMap)
-
-            c.value?.let {
-                when (val value = it) {
-                    is ProofRequestClaimValueBindingDto.Value ->
-                        result.putString("value", value.value)
+            when (value) {
+                is ProofRequestClaimValueBindingDto.Value -> {
+                    result.putString("type_", "VALUE")
+                    result.putString("value", value.value)
+                }
 
-                    is ProofRequestClaimValueBindingDto.Claims ->
-                        result.putArray("value", convertToRN(value.value) as ReadableArray)
+                is ProofRequestClaimValueBindingDto.Claims -> {
+                    result.putString("type_", "CLAIMS")
+                    result.putArray("value", convertToRN(value.value) as ReadableArray)
                 }
             }
-
             return result
         }
 
-        private fun presentationDefinitionV2Claim(c: PresentationDefinitionV2ClaimBindingDto): ReadableMap {
+        private fun presentationDefinitionV2ClaimValue(value: PresentationDefinitionV2ClaimValueBindingDto): ReadableMap {
             val result = Arguments.createMap()
-            result.putString("path", c.path)
-            result.putMap("schema", convertToRN(c.schema) as ReadableMap)
-            result.putBoolean("userSelection", c.userSelection)
-            result.putBoolean("required", c.required)
-
-            when (val value = c.value) {
-                is PresentationDefinitionV2ClaimValueBindingDto.Boolean -> result.putBoolean(
-                    "value",
-                    value.value
-                )
-
-                is PresentationDefinitionV2ClaimValueBindingDto.Float -> result.putDouble(
-                    "value",
-                    value.value
-                )
+            when (value) {
+                is PresentationDefinitionV2ClaimValueBindingDto.Boolean -> {
+                    result.putString("type_", "BOOLEAN")
+                    result.putBoolean("value", value.value)
+                }
+
+                is PresentationDefinitionV2ClaimValueBindingDto.Float -> {
+                    result.putString("type_", "FLOAT")
+                    result.putDouble("value", value.value)
+                }
 
                 is PresentationDefinitionV2ClaimValueBindingDto.Integer -> {
+                    result.putString("type_", "INTEGER")
                     if (value.value < Int.MIN_VALUE || value.value > Int.MAX_VALUE) {
                         result.putDouble("value", value.value.toDouble())
                     } else {
@@ -144,15 +169,51 @@ object SerializeSpecific {
                     }
                 }
 
-                is PresentationDefinitionV2ClaimValueBindingDto.String -> result.putString(
-                    "value",
-                    value.value
-                )
+                is PresentationDefinitionV2ClaimValueBindingDto.String -> {
+                    result.putString("type_", "STRING")
+                    result.putString("value", value.value)
+                }
 
-                is PresentationDefinitionV2ClaimValueBindingDto.Nested ->
+                is PresentationDefinitionV2ClaimValueBindingDto.Nested -> {
+                    result.putString("type_", "NESTED")
                     result.putArray("value", convertToRN(value.value) as ReadableArray)
+                }
             }
+            return result
+        }
 
+        private fun invitationResponse(value: HandleInvitationResponseBindingEnum): ReadableMap {
+            val result = Arguments.createMap()
+            when (value) {
+                is HandleInvitationResponseBindingEnum.CredentialIssuance -> {
+                    result.putString("type_", "CREDENTIAL_ISSUANCE")
+                    result.putString("interactionId", value.interactionId)
+                    value.keyStorageSecurityLevels?.let {
+                        result.putArray(
+                            "keyStorageSecurityLevels",
+                            convertToRN(it) as ReadableArray
+                        )
+                    }
+                    value.keyAlgorithms?.let {
+                        result.putArray("keyAlgorithms", convertToRN(it) as ReadableArray)
+                    }
+                    value.txCode?.let {
+                        result.putMap("txCode", convertToRN(it) as ReadableMap)
+                    }
+                }
+
+                is HandleInvitationResponseBindingEnum.AuthorizationCodeFlow -> {
+                    result.putString("type_", "AUTHORIZATION_CODE_FLOW")
+                    result.putString("interactionId", value.interactionId)
+                    result.putString("authorizationCodeFlowUrl", value.authorizationCodeFlowUrl)
+                }
+
+                is HandleInvitationResponseBindingEnum.ProofRequest -> {
+                    result.putString("type_", "PROOF_REQUEST")
+                    result.putString("interactionId", value.interactionId)
+                    result.putString("proofId", value.proofId)
+                }
+            }
             return result
         }
     }

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

@@ -1,23 +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
-import com.ubiqu.eid.sdk.components.UbqInternalPad
-import com.ubiqu.eid.sdk.components.UbqPinPad
 
 class PinPadViewManager(private val callerContext: ReactApplicationContext) :
-    SimpleViewManager<UbqPinPad>() {
+    SimpleViewManager<View>() {
     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
+    override fun createViewInstance(context: ThemedReactContext): View {
+        throw NativeKeyStorageException.Unsupported()
     }
 }