feat!: move to swift based framework for didcomm, jose and peer did

BREAKING CHANGE: Updated Pluto and Message public interface

This changes are required to provide the following.
- the old didcomm library didnt allow for extra headers that was essencial to prism mediator
- this peer did library is updated with last specifications specs required by the agent and prism mediator
- this jose library provides a full implementation of the jose capabilities we require

The amount of changes is big because the peer did changes required a few changes on how we process keys and resolve secrets

Besides that since the previous libraries were not build in swift, we are actually getting rid of 37MB of framework size

Author: goncalo-frade-iohk

AtalaPrismSDK/Apollo/Sources/ApolloImpl+KeyRestoration.swift

@@ -20,11 +20,22 @@ extension ApolloImpl: KeyRestoration {
             guard let index = key.index else {
                 throw ApolloError.restoratonFailedNoIdentifierOrInvalid
             }
-            return Secp256k1PrivateKey(internalKey: .init(raw: key.storableData.toKotlinByteArray()), derivationPath: DerivationPath(index: index))
+            return Secp256k1PrivateKey(
+                identifier: key.identifier,
+                internalKey: .init(raw: key.storableData.toKotlinByteArray()), derivationPath: DerivationPath(index: index)
+            )
         case "x25519+priv":
-            return try CreateX25519KeyPairOperation(logger: Self.logger).compute(fromPrivateKey: key.storableData)
+            return try CreateX25519KeyPairOperation(logger: Self.logger)
+                .compute(
+                    identifier: key.identifier,
+                    fromPrivateKey: key.storableData
+                )
         case "ed25519+priv":
-            return try CreateEd25519KeyPairOperation(logger: Self.logger).compute(fromPrivateKey: key.storableData)
+            return try CreateEd25519KeyPairOperation(logger: Self.logger)
+                .compute(
+                    identifier: key.identifier,
+                    fromPrivateKey: key.storableData
+                )
         default:
             throw ApolloError.restoratonFailedNoIdentifierOrInvalid
         }
@@ -34,11 +45,20 @@ extension ApolloImpl: KeyRestoration {
     public func restorePublicKey(_ key: StorableKey) throws -> PublicKey {
         switch key.restorationIdentifier {
         case "secp256k1+pub":
-            return Secp256k1PublicKey(internalKey: .init(raw: key.storableData.toKotlinByteArray()))
+            return Secp256k1PublicKey(
+                identifier: key.identifier,
+                internalKey: .init(raw: key.storableData.toKotlinByteArray())
+            )
         case "x25519+pub":
-            return X25519PublicKey(internalKey: .init(raw: key.storableData.toKotlinByteArray()))
+            return X25519PublicKey(
+                identifier: key.identifier,
+                internalKey: .init(raw: key.storableData.toKotlinByteArray())
+            )
         case "ed25519+pub":
-            return Ed25519PublicKey(internalKey: .init(raw: key.storableData.toKotlinByteArray()))
+            return Ed25519PublicKey(
+                identifier: key.identifier,
+                internalKey: .init(raw: key.storableData.toKotlinByteArray())
+            )
         default:
             throw ApolloError.restoratonFailedNoIdentifierOrInvalid
         }

AtalaPrismSDK/Apollo/Sources/Model/Ed25519Key.swift

@@ -9,10 +9,15 @@ struct Ed25519PrivateKey: PrivateKey {
     let keySpecifications: [String : String] = [
         "curve" : "Ed25519"
     ]
+    var identifier: String
     var size: Int { raw.count }
     var raw: Data { internalKey.raw.toData() }
 
-    init(internalKey: ApolloLibrary.KMMEdPrivateKey) {
+    init(
+        identifier: String = UUID().uuidString,
+        internalKey: ApolloLibrary.KMMEdPrivateKey
+    ) {
+        self.identifier = identifier
         self.internalKey = internalKey
     }
 
@@ -53,10 +58,15 @@ struct Ed25519PublicKey: PublicKey {
     let keySpecifications: [String : String] = [
         "curve" : "Ed25519"
     ]
+    var identifier: String
     var size: Int { raw.count }
     var raw: Data { internalKey.raw.toData() }
 
-    init(internalKey: ApolloLibrary.KMMEdPublicKey) {
+    init(
+        identifier: String = UUID().uuidString,
+        internalKey: ApolloLibrary.KMMEdPublicKey
+    ) {
+        self.identifier = identifier
         self.internalKey = internalKey
     }
 

AtalaPrismSDK/Apollo/Sources/Model/LinkSecret.swift

@@ -6,6 +6,7 @@ struct LinkSecret: Key {
     let keyType = "LinkSecret"
     let keySpecifications = [String : String]()
     let raw: Data
+    var identifier = "linkSecret"
     var size: Int { raw.count }
 
     let anoncred: AnoncredsSwift.LinkSecret

AtalaPrismSDK/Apollo/Sources/Model/Secp256k1Key.swift

@@ -5,14 +5,19 @@ import Foundation
 
 struct Secp256k1PrivateKey: PrivateKey {
     private let internalKey: KMMECSecp256k1PrivateKey
-
     let keyType: String = "EC"
     let keySpecifications: [String : String]
     let size: Int
     let raw: Data
     let derivationPath: Domain.DerivationPath
-
-    init(internalKey: KMMECSecp256k1PrivateKey, derivationPath: Domain.DerivationPath) {
+    var identifier: String
+
+    init(
+        identifier: String = UUID().uuidString,
+        internalKey: KMMECSecp256k1PrivateKey,
+        derivationPath: Domain.DerivationPath
+    ) {
+        self.identifier = identifier
         self.internalKey = internalKey
         self.derivationPath = derivationPath
         self.keySpecifications = [
@@ -60,13 +65,17 @@ extension Secp256k1PrivateKey: KeychainStorableKey {
 
 struct Secp256k1PublicKey: PublicKey {
     private let internalKey: ApolloLibrary.KMMECSecp256k1PublicKey
-
     let keyType: String = "EC"
     let keySpecifications: [String : String]
     let size: Int
     let raw: Data
+    var identifier = UUID().uuidString
 
-    init(internalKey: ApolloLibrary.KMMECSecp256k1PublicKey) {
+    init(
+        identifier: String = UUID().uuidString,
+        internalKey: ApolloLibrary.KMMECSecp256k1PublicKey
+    ) {
+        self.identifier = identifier
         self.internalKey = internalKey
         var specs: [String: String] = [
             KeyProperties.curve.rawValue: "secp256k1",

AtalaPrismSDK/Apollo/Sources/Model/X25519Key.swift

@@ -8,10 +8,15 @@ struct X25519PrivateKey: PrivateKey {
     let keySpecifications: [String : String] = [
         "curve" : "x25519"
     ]
+    var identifier:String
     var size: Int { raw.count }
     var raw: Data { internalKey.raw.toData() }
 
-    init(internalKey: ApolloLibrary.KMMX25519PrivateKey) {
+    init(
+        identifier: String = UUID().uuidString,
+        internalKey: ApolloLibrary.KMMX25519PrivateKey
+    ) {
+        self.identifier = identifier
         self.internalKey = internalKey
     }
 
@@ -41,10 +46,15 @@ struct X25519PublicKey: PublicKey {
     let keySpecifications: [String : String] = [
         "curve" : "x25519"
     ]
+    var identifier: String
     var size: Int { raw.count }
     var raw: Data { internalKey.raw.toData() }
 
-    init(internalKey: ApolloLibrary.KMMX25519PublicKey) {
+    init(
+        identifier: String = UUID().uuidString,
+        internalKey: ApolloLibrary.KMMX25519PublicKey
+    ) {
+        self.identifier = identifier
         self.internalKey = internalKey
     }
 

AtalaPrismSDK/Apollo/Sources/Operations/CreateEd25519KeyPairOperation.swift

@@ -12,7 +12,10 @@ struct CreateEd25519KeyPairOperation {
 
     }
 
-    func compute(fromPrivateKey: Data) throws -> PrivateKey {
-        return Ed25519PrivateKey(internalKey: KMMEdPrivateKey(raw: fromPrivateKey.toKotlinByteArray()))
+    func compute(identifier: String = UUID().uuidString, fromPrivateKey: Data) throws -> PrivateKey {
+        return Ed25519PrivateKey(
+            identifier: identifier,
+            internalKey: KMMEdPrivateKey(raw: fromPrivateKey.toKotlinByteArray())
+        )
     }
 }

AtalaPrismSDK/Apollo/Sources/Operations/CreateX25519KeyPairOperation.swift

@@ -13,8 +13,11 @@ struct CreateX25519KeyPairOperation {
 
     }
 
-    func compute(fromPrivateKey: Data) throws -> PrivateKey {
+    func compute(identifier: String = UUID().uuidString, fromPrivateKey: Data) throws -> PrivateKey {
         let privateKey = KMMX25519PrivateKey(raw: fromPrivateKey.toKotlinByteArray())
-        return X25519PrivateKey(internalKey: privateKey)
+        return X25519PrivateKey(
+            identifier: identifier,
+            internalKey: privateKey
+        )
     }
 }

AtalaPrismSDK/Castor/Sources/CastorImpl+Public.swift

@@ -129,22 +129,4 @@ extension CastorImpl: Castor {
         }
         return try await resolver.resolve(did: did)
     }
-
-    /// getEcnumbasis generates a unique ECNUM basis string for a given DID and key pair. This function may throw an error if the DID or key pair are invalid.
-    ///
-    /// - Parameters:
-    ///   - did: The DID associated with the key pair
-    ///   - keyPair: The key pair to use for generating the ECNUM basis
-    /// - Returns: The ECNUM basis string
-    /// - Throws: An error if the DID or key pair are invalid
-    public func getEcnumbasis(did: DID, publicKey: PublicKey) throws -> String {
-        logger.debug(message: "Getting ecnumbasis", metadata: [
-            .maskedMetadataByLevel(key: "DID", value: did.string, level: .debug)
-        ])
-        return try CreatePeerDIDOperation(
-            autenticationPublicKey: publicKey,
-            agreementPublicKey: publicKey,
-            services: []
-        ).computeEcnumbasis(did: did, publicKey: publicKey)
-    }
 }