fix(castor): prism did was not being resolved correctly because of a change in the protos

Author: goncalo-frade-iohk

AtalaPrismSDK/Apollo/Sources/ApolloImpl+Public.swift

@@ -105,6 +105,18 @@ returns random mnemonics nerver returns invalid mnemonics
         )
     }
 
+    public func publicKeyFrom(x: Data, y: Data) -> PublicKey {
+        PublicKey(
+            curve: KeyCurve.secp256k1().name,
+            value: LockPublicKey(x: x, y: y).data
+        )
+    }
+
+    public func publicKeyPointCurve(publicKey: PublicKey) throws -> (x: Data, y: Data) {
+        let points = try LockPublicKey(bytes: publicKey.value).pointCurve()
+        return (points.x.data, points.y.data)
+    }
+
     /// signMessage signs a message using a given private key, returning the signature.
     ///
     /// - Parameters:
@@ -191,6 +203,26 @@ returns random mnemonics nerver returns invalid mnemonics
             return jwk
         }
     }
+
+    public func keyDataToPEMString(_ keyData: PrivateKey) -> String? {
+        let keyBase64 = keyData.value.base64EncodedString(options: .lineLength64Characters)
+        let pemString = """
+        -----BEGIN PRIVATE KEY-----
+        \(keyBase64)
+        -----END PRIVATE KEY-----
+        """
+        return pemString
+    }
+
+    public func keyDataToPEMString(_ keyData: PublicKey) -> String? {
+        let keyBase64 = keyData.value.base64EncodedString(options: .lineLength64Characters)
+        let pemString = """
+        -----BEGIN PUBLIC KEY-----
+        \(keyBase64)
+        -----END PUBLIC KEY-----
+        """
+        return pemString
+    }
 }
 
 struct MyClaims: Claims {

AtalaPrismSDK/Apollo/Sources/BIPs/BIP32_44/LockPublicKey.swift

@@ -41,13 +41,45 @@ struct LockPublicKey {
         self.isCompressed = (header == 0x02 || header == 0x03)
     }
 
+    /**
+     * Guarantees to init a public key uncompressed with 65 bytes in the following form:
+     *
+     * 0x04 ++ xBytes ++ yBytes
+     *
+     * Where `xBytes` and `yBytes` represent a 32-byte coordinates of a point
+     * on the secp256k1 elliptic curve, which follow the formula below:
+     *
+     * y^2 == x^3 + 7
+     *
+     * @return uncompressed public key
+     */
+    init(x: Data, y: Data) {
+        let header: UInt8 = 0x04
+        self.data = [header] + x + y
+        self.isCompressed = false
+    }
+
     func compressedPublicKey() -> LockPublicKey {
         LockPublicKey(bytes: KeyHelpers.compressPublicKey(fromPublicKey: data))
     }
 
     func uncompressedPublicKey() -> LockPublicKey {
         LockPublicKey(bytes: KeyHelpers.uncompressPublicKey(fromPublicKey: data))
     }
+
+    func pointCurve() throws -> PointOnCurve {
+        let selfUncompressed = uncompressedPublicKey()
+        var xAndY = selfUncompressed.data
+        xAndY.removeFirst() // Remove the header
+        let expectedLengthOfScalar = Scalar32Bytes.expectedByteCount
+        let expectedLengthOfKey = expectedLengthOfScalar * 2
+        guard xAndY.count == expectedLengthOfKey else {
+            fatalError("expected length of key is \(expectedLengthOfKey) bytes, but got: \(xAndY.count)")
+        }
+        let x = xAndY.prefix(expectedLengthOfScalar)
+        let y = xAndY.suffix(expectedLengthOfScalar)
+        return try PointOnCurve(x: x, y: y)
+    }
 }
 
 extension LockPublicKey: Equatable {

AtalaPrismSDK/Castor/Sources/DID/PrismDID/PrismDIDPublicKey.swift

@@ -76,19 +76,24 @@ struct PrismDIDPublicKey {
         id = proto.id
         usage = proto.usage.fromProto()
         switch proto.keyData {
+        case let .ecKeyData(value):
+            keyData = apollo.publicKeyFrom(x: value.x, y: value.y)
         case let .compressedEcKeyData(value):
             keyData = apollo.uncompressedPublicKey(compressedData: value.data)
         default:
             throw CastorError.invalidPublicKeyCoding(didMethod: "prism", curve: "secp256k1")
         }
     }
 
-    func toProto() -> Io_Iohk_Atala_Prism_Protos_PublicKey {
+    func toProto() throws -> Io_Iohk_Atala_Prism_Protos_PublicKey {
         var protoKey = Io_Iohk_Atala_Prism_Protos_PublicKey()
         protoKey.id = id
         protoKey.usage = usage.toProto()
-        let compressed = apollo.compressedPublicKey(publicKey: keyData)
-        protoKey.keyData = .compressedEcKeyData(compressed.toProto())
+        let points = try apollo.publicKeyPointCurve(publicKey: keyData)
+        var protoEC = Io_Iohk_Atala_Prism_Protos_ECKeyData()
+        protoEC.x = points.x
+        protoEC.y = points.y
+        protoKey.keyData = .ecKeyData(protoEC)
         return protoKey
     }
 }

AtalaPrismSDK/Castor/Sources/Operations/CreatePrismDIDOperation.swift

@@ -10,7 +10,7 @@ struct CreatePrismDIDOperation {
 
     func compute() throws -> DID {
         var operation = Io_Iohk_Atala_Prism_Protos_AtalaOperation()
-        operation.createDid = createDIDAtalaOperation(
+        operation.createDid = try createDIDAtalaOperation(
             publicKeys: [PrismDIDPublicKey(
                 apollo: apollo,
                 id: PrismDIDPublicKey.Usage.masterKey.defaultId,
@@ -25,9 +25,9 @@ struct CreatePrismDIDOperation {
     private func createDIDAtalaOperation(
         publicKeys: [PrismDIDPublicKey],
         services: [DIDDocument.Service]
-    ) -> Io_Iohk_Atala_Prism_Protos_CreateDIDOperation {
+    ) throws -> Io_Iohk_Atala_Prism_Protos_CreateDIDOperation {
         var didData = Io_Iohk_Atala_Prism_Protos_CreateDIDOperation.DIDCreationData()
-        didData.publicKeys = publicKeys.map { $0.toProto() }
+        didData.publicKeys = try publicKeys.map { try $0.toProto() }
         didData.services = services.map {
             var service = Io_Iohk_Atala_Prism_Protos_Service()
             service.id = $0.id

AtalaPrismSDK/Domain/Sources/BBs/Apollo.swift

@@ -98,4 +98,12 @@ public protocol Apollo {
     /// - Returns: The public key pair in JWK format, as a string
     /// - Throws: An error if the key pair is invalid
     func getPublicJWKJson(id: String, keyPair: KeyPair) throws -> String
+
+    func keyDataToPEMString(_ keyData: PrivateKey) -> String?
+
+    func keyDataToPEMString(_ keyData: PublicKey) -> String?
+
+    func publicKeyFrom(x: Data, y: Data) -> PublicKey
+
+    func publicKeyPointCurve(publicKey: PublicKey) throws -> (x: Data, y: Data)
 }

README.md

@@ -36,8 +36,6 @@ To get started with the Atala PRISM Swift SDK, you can set up the SDK and start
 - MacOS 12 or later
 - iOS 15 or later
 
-> ⚠️ **Currently you need to always open the XCode in ROSETTA mode**
-
 ### Integrating the SDK in an existing project
 
 To integrate the SDK into an existing project, you can use the Swift Package Manager, which is distributed with Xcode.