[BREAK API] ECDSA.Recoverable to ECDSAWithKeyRecovery & ECDSA.NonRecoverable to ECDSA (#34)

Author: Sajjon

README.md

@@ -14,8 +14,8 @@ The API of K1 maps almost 1:1 with Apple's [CryptoKit][ck], vendoring a set of k
 Just like that K1 vendors these key pairs:
 - `K1.KeyAgreement.PrivateKey` / `K1.KeyAgreement.PublicKey` for key agreement (ECDH)
 - `K1.Schnorr.PrivateKey` / `K1.Schnorr.PublicKey` for sign / verify methods using Schnorr signature scheme
-- `K1.ECDSA.Recoverable.PrivateKey` / `K1.ECDSA.Recoverable.PublicKey` for sign / verify methods using ECDSA (producing/validating signature where public key is recoverable)
-- `K1.ECDSA.NonRecoverable.PrivateKey` / `K1.ECDSA.NonRecoverable.PublicKey` for sign / verify methods using ECDSA (producing/validating signature where public key is **not** recoverable)
+- `K1.ECDSAWithKeyRecovery.PrivateKey` / `K1.ECDSAWithKeyRecovery.PublicKey` for sign / verify methods using ECDSA (producing/validating signature where public key is recoverable)
+- `K1.ECDSA.PrivateKey` / `K1.ECDSA.PublicKey` for sign / verify methods using ECDSA (producing/validating signature where public key is **not** recoverable)
 
 Just like you can convert between e.g. `Curve25519.KeyAgreement.PrivateKey` and  `Curve25519.Signing.PrivateKey` back and forth using any of the initializers and serializer, you can convert between all PrivateKeys and all PublicKeys of all features in K1.
 
@@ -64,8 +64,8 @@ Furthermore, all PublicKeys's have these additional APIs:
 ## ECDSA (Elliptic Curve Digital Signature Algorithm)
 
 There exists two set of ECDSA key pairs:
-- A key pair for signatures from which you can recover the public key, specifically: `K1.ECDSA.Recoverable.PrivateKey` and `K1.ECDSA.Recoverable.PublicKey`
-- A key pair for signatures from which you can **not** recover the public key, specifically: `K1.ECDSA.NonRecoverable.PrivateKey` and `K1.ECDSA.NonRecoverable.PublicKey`
+- A key pair for signatures from which you can recover the public key, specifically: `K1.ECDSAWithKeyRecovery.PrivateKey` and `K1.ECDSAWithKeyRecovery.PublicKey`
+- A key pair for signatures from which you can **not** recover the public key, specifically: `K1.ECDSA.PrivateKey` and `K1.ECDSA.PublicKey`
 
 For each private key there exists two different `signature:for:options` (one taking hashed data and taking `Digest` as argument) methods and one `signature:forUnhashed:options`.
 
@@ -76,7 +76,7 @@ The `option` is a `K1.ECDSA.SigningOptions` struct, which by default specifies [
 #### Sign
 
 ```swift
-let alice = K1.ECDA.NonRecovarable.PrivateKey()
+let alice = K1.ECDSA.PrivateKey()
 ```
 
 ##### Hashed (Data)
@@ -109,8 +109,8 @@ let signature = try alice.signature(forUnhashed: message)
 
 ```swift
 let hashedMessage: Data = // from somewhere
-let publicKey: K1.ECDSA.NonRecoverable.PublicKey = alice.publcKey
-let signature: K1.ECDSA.NonRecoverable.Signature // from above
+let publicKey: K1.ECDSA.PublicKey = alice.publcKey
+let signature: K1.ECDSA.Signature // from above
 
 assert(
     publicKey.isValidSignature(signature, hashed: hashedMessage)
@@ -122,7 +122,7 @@ assert(
 ```swift
 let message: Data = // from somewhere
 let digest = SHA256.hash(data: message)
-let signature: K1.ECDSA.NonRecoverable.Signature // from above
+let signature: K1.ECDSA.Signature // from above
 
 assert(
     publicKey.isValidSignature(signature, digest: digest)
@@ -133,7 +133,7 @@ assert(
 
 ```swift
 let message: Data = // from somewhere
-let signature: K1.ECDSA.NonRecoverable.Signature // from above
+let signature: K1.ECDSA.Signature // from above
 
 assert(
     publicKey.isValidSignature(signature, unhashed: message)
@@ -146,11 +146,11 @@ assert(
 All signing and validation APIs are identical to the `NonRecoverable` namespace.
 
 ```swift
-let alice = K1.ECDA.Recovarable.PrivateKey()
+let alice = K1.ECDSA.PrivateKey()
 let message: Data = // from somewhere
 let digest = SHA256.hash(data: message)
-let signature: K1.ECDSA.Recoverable.Signature = try alice.signature(for: digest)
-let publicKey: K1.ECDSA.Recoverable.PublicKey = alice.publicKey
+let signature: K1.ECDSAWithKeyRecovery.Signature = try alice.signature(for: digest)
+let publicKey: K1.ECDSAWithKeyRecovery.PublicKey = alice.publicKey
 assert(
     publicKey.isValidSignature(signature, digest: digest)
 ) // PASS

Sources/K1/K1/ECDSA/ECDSA.swift

@@ -1,6 +1,6 @@
 // MARK: - K1.ECDSA
 extension K1 {
-	/// A mechanism used to create or verify a cryptographic signature using the `secp256k1` elliptic curve digital signature algorithm (ECDSA).
+	/// A mechanism used to create or verify a cryptographic signature using the `secp256k1` elliptic curve digital signature algorithm (ECDSA), signatures that do not offer recovery of the public key.
 	public enum ECDSA {}
 }
 

Sources/K1/K1/ECDSA/ECDSASignatureNonRecoverable.swift

@@ -2,20 +2,12 @@ import protocol CryptoKit.Digest
 import struct CryptoKit.SHA256
 import Foundation
 
-// MARK: - K1.ECDSA.NonRecoverable
+// MARK: - K1.ECDSA.Signature
 extension K1.ECDSA {
-	/// A mechanism used to create or verify a cryptographic signature using the `secp256k1` elliptic curve digital signature algorithm (ECDSA), signatures that do not offer recovery of the public key.
-	public enum NonRecoverable {
-		// Just a namespace
-	}
-}
-
-// MARK: - K1.ECDSA.NonRecoverable.Signature
-extension K1.ECDSA.NonRecoverable {
 	/// A `secp256k1` elliptic curve digital signature algorithm (ECDSA) signature,
 	/// from which users can recover a public key with the message that was signed.
 	public struct Signature: Sendable, Hashable, ContiguousBytes {
-		typealias Wrapped = FFI.ECDSA.NonRecoverable.Wrapped
+		typealias Wrapped = FFI.ECDSA.Wrapped
 		internal let wrapped: Wrapped
 
 		init(wrapped: Wrapped) {
@@ -25,12 +17,12 @@ extension K1.ECDSA.NonRecoverable {
 }
 
 // MARK: Inits
-extension K1.ECDSA.NonRecoverable.Signature {
+extension K1.ECDSA.Signature {
 	/// Creates a `secp256k1` ECDSA signature from a Distinguished Encoding Rules (DER) encoded representation.
 	/// - Parameter derRepresentation: A DER-encoded representation of the signature.
 	public init(derRepresentation: some DataProtocol) throws {
 		try self.init(
-			wrapped: FFI.ECDSA.NonRecoverable.from(derRepresentation: [UInt8](derRepresentation))
+			wrapped: FFI.ECDSA.from(derRepresentation: [UInt8](derRepresentation))
 		)
 	}
 
@@ -44,20 +36,20 @@ extension K1.ECDSA.NonRecoverable.Signature {
 	/// [rfc]: https://tools.ietf.org/html/rfc4754
 	public init(rawRepresentation: some DataProtocol) throws {
 		try self.init(
-			wrapped: FFI.ECDSA.NonRecoverable.from(compactBytes: [UInt8](rawRepresentation))
+			wrapped: FFI.ECDSA.from(compactBytes: [UInt8](rawRepresentation))
 		)
 	}
 }
 
 // MARK: ContiguousBytes
-extension K1.ECDSA.NonRecoverable.Signature {
+extension K1.ECDSA.Signature {
 	public func withUnsafeBytes<R>(_ body: (UnsafeRawBufferPointer) throws -> R) rethrows -> R {
 		try wrapped.withUnsafeBytes(body)
 	}
 }
 
 // MARK: Serialize
-extension K1.ECDSA.NonRecoverable.Signature {
+extension K1.ECDSA.Signature {
 	var internalRepresentation: Data {
 		Data(wrapped.bytes)
 	}
@@ -68,7 +60,7 @@ extension K1.ECDSA.NonRecoverable.Signature {
 	/// `libsecp256k1` this representation is called "compact".
 	public var rawRepresentation: Data {
 		do {
-			return try FFI.ECDSA.NonRecoverable.compact(wrapped)
+			return try FFI.ECDSA.compact(wrapped)
 		} catch {
 			fatalError("Should never fail to convert ECDSA signatures to rawRepresentation.")
 		}
@@ -78,19 +70,19 @@ extension K1.ECDSA.NonRecoverable.Signature {
 	/// `secp256k1` ECDSA non recoverable signature.
 	public var derRepresentation: Data {
 		do {
-			return try FFI.ECDSA.NonRecoverable.der(wrapped)
+			return try FFI.ECDSA.der(wrapped)
 		} catch {
 			fatalError("Should never fail to convert ECDSA signatures to DER representation.")
 		}
 	}
 }
 
-extension K1.ECDSA.NonRecoverable.Signature {
-	internal static let byteCount = FFI.ECDSA.Recoverable.byteCount
+extension K1.ECDSA.Signature {
+	internal static let byteCount = FFI.ECDSAWithKeyRecovery.byteCount
 }
 
 // MARK: Equatable
-extension K1.ECDSA.NonRecoverable.Signature {
+extension K1.ECDSA.Signature {
 	/// Compares two ECDSA signatures.
 	public static func == (lhs: Self, rhs: Self) -> Bool {
 		lhs.wrapped.withUnsafeBytes { lhsBytes in
@@ -102,7 +94,7 @@ extension K1.ECDSA.NonRecoverable.Signature {
 }
 
 // MARK: Hashable
-extension K1.ECDSA.NonRecoverable.Signature {
+extension K1.ECDSA.Signature {
 	public func hash(into hasher: inout Hasher) {
 		wrapped.withUnsafeBytes {
 			hasher.combine(bytes: $0)

Sources/K1/K1/ECDSA/ECDSASignatureRecoverable.swift

@@ -2,20 +2,20 @@ import protocol CryptoKit.Digest
 import struct CryptoKit.SHA256
 import Foundation
 
-// MARK: - K1.ECDSA.Recoverable
-extension K1.ECDSA {
+// MARK: - K1.ECDSAWithKeyRecovery
+extension K1 {
 	/// A mechanism used to create or verify a cryptographic signature using the `secp256k1` elliptic curve digital signature algorithm (ECDSA), signatures that do offers recovery of the public key.
-	public enum Recoverable {
+	public enum ECDSAWithKeyRecovery {
 		// Just a namespace
 	}
 }
 
-// MARK: - K1.ECDSA.Recoverable.Signature
-extension K1.ECDSA.Recoverable {
+// MARK: - K1.ECDSAWithKeyRecovery.Signature
+extension K1.ECDSAWithKeyRecovery {
 	/// A `secp256k1` elliptic curve digital signature algorithm (ECDSA) signature,
 	/// from which users **cannot** recover the public key, not without the `RecoveryID`.
 	public struct Signature: Sendable, Hashable, ContiguousBytes {
-		typealias Wrapped = FFI.ECDSA.Recoverable.Wrapped
+		typealias Wrapped = FFI.ECDSAWithKeyRecovery.Wrapped
 		internal let wrapped: Wrapped
 
 		internal init(wrapped: Wrapped) {
@@ -25,11 +25,11 @@ extension K1.ECDSA.Recoverable {
 }
 
 // MARK: Init
-extension K1.ECDSA.Recoverable.Signature {
+extension K1.ECDSAWithKeyRecovery.Signature {
 	/// Compact aka `IEEE P1363` aka `R||S`.
 	public init(compact: Compact) throws {
 		try self.init(
-			wrapped: FFI.ECDSA.Recoverable.deserialize(
+			wrapped: FFI.ECDSAWithKeyRecovery.deserialize(
 				compact: [UInt8](compact.compact),
 				recoveryID: compact.recoveryID.recid
 			)
@@ -40,27 +40,27 @@ extension K1.ECDSA.Recoverable.Signature {
 		internalRepresentation: some DataProtocol
 	) throws {
 		try self.init(
-			wrapped: FFI.ECDSA.Recoverable.deserialize(rawRepresentation: internalRepresentation)
+			wrapped: FFI.ECDSAWithKeyRecovery.deserialize(rawRepresentation: internalRepresentation)
 		)
 	}
 }
 
 // MARK: ContiguousBytes
-extension K1.ECDSA.Recoverable.Signature {
+extension K1.ECDSAWithKeyRecovery.Signature {
 	public func withUnsafeBytes<R>(_ body: (UnsafeRawBufferPointer) throws -> R) rethrows -> R {
 		try wrapped.withUnsafeBytes(body)
 	}
 }
 
 // MARK: Serialize
-extension K1.ECDSA.Recoverable.Signature {
+extension K1.ECDSAWithKeyRecovery.Signature {
 	internal var internalRepresentation: Data {
 		Data(wrapped.bytes)
 	}
 
 	/// Compact aka `IEEE P1363` aka `R||S` and `V` (`RecoveryID`).
 	public func compact() throws -> Compact {
-		let (rs, recid) = try FFI.ECDSA.Recoverable.serializeCompact(
+		let (rs, recid) = try FFI.ECDSAWithKeyRecovery.serializeCompact(
 			wrapped
 		)
 		return try .init(
@@ -92,7 +92,7 @@ extension K1.ECDSA.Recoverable.Signature {
 	}
 }
 
-extension K1.ECDSA.Recoverable.Signature.Compact {
+extension K1.ECDSAWithKeyRecovery.Signature.Compact {
 	public static let byteCountRS = 2 * Curve.Field.byteCount
 	public static let byteCount = Self.byteCountRS + 1
 
@@ -162,7 +162,7 @@ extension K1.ECDSA.Recoverable.Signature.Compact {
 	}
 }
 
-extension K1.ECDSA.Recoverable.Signature.RecoveryID {
+extension K1.ECDSAWithKeyRecovery.Signature.RecoveryID {
 	var vData: Data {
 		Data(
 			[UInt8(rawValue)]
@@ -171,7 +171,7 @@ extension K1.ECDSA.Recoverable.Signature.RecoveryID {
 }
 
 // MARK: Recovery
-extension K1.ECDSA.Recoverable.Signature {
+extension K1.ECDSAWithKeyRecovery.Signature {
 	/// Recovers a public key from a `secp256k1` this ECDSA signature and the message signed.
 	///
 	/// - Parameters:
@@ -180,27 +180,27 @@ extension K1.ECDSA.Recoverable.Signature {
 	/// signature by signing the `message`.
 	public func recoverPublicKey(
 		message: some DataProtocol
-	) throws -> K1.ECDSA.Recoverable.PublicKey {
-		let wrapped = try FFI.ECDSA.Recoverable.recover(wrapped, message: [UInt8](message))
+	) throws -> K1.ECDSAWithKeyRecovery.PublicKey {
+		let wrapped = try FFI.ECDSAWithKeyRecovery.recover(wrapped, message: [UInt8](message))
 		let impl = K1._PublicKeyImplementation(wrapped: wrapped)
-		return K1.ECDSA.Recoverable.PublicKey(
+		return K1.ECDSAWithKeyRecovery.PublicKey(
 			impl: impl
 		)
 	}
 }
 
 // MARK: Conversion
-extension K1.ECDSA.Recoverable.Signature {
+extension K1.ECDSAWithKeyRecovery.Signature {
 	/// Converts this recoverable ECDSA signature to a non-recoverable version.
-	public func nonRecoverable() throws -> K1.ECDSA.NonRecoverable.Signature {
-		try K1.ECDSA.NonRecoverable.Signature(
-			wrapped: FFI.ECDSA.Recoverable.nonRecoverable(self.wrapped)
+	public func nonRecoverable() throws -> K1.ECDSA.Signature {
+		try K1.ECDSA.Signature(
+			wrapped: FFI.ECDSAWithKeyRecovery.nonRecoverable(self.wrapped)
 		)
 	}
 }
 
 // MARK: Equatable
-extension K1.ECDSA.Recoverable.Signature {
+extension K1.ECDSAWithKeyRecovery.Signature {
 	/// Compares two ECDSA signatures.
 	public static func == (lhs: Self, rhs: Self) -> Bool {
 		lhs.wrapped.withUnsafeBytes { lhsBytes in
@@ -212,7 +212,7 @@ extension K1.ECDSA.Recoverable.Signature {
 }
 
 // MARK: Hashable
-extension K1.ECDSA.Recoverable.Signature {
+extension K1.ECDSAWithKeyRecovery.Signature {
 	public func hash(into hasher: inout Hasher) {
 		wrapped.withUnsafeBytes {
 			hasher.combine(bytes: $0)

Sources/K1/K1/ECDSA/RecoveryID.swift

@@ -1,7 +1,7 @@
 import Foundation
 
-// MARK: - K1.ECDSA.Recoverable.Signature.RecoveryID
-extension K1.ECDSA.Recoverable.Signature {
+// MARK: - K1.ECDSAWithKeyRecovery.Signature.RecoveryID
+extension K1.ECDSAWithKeyRecovery.Signature {
 	public enum RecoveryID: UInt8, Sendable, Hashable, Codable {
 		case _0 = 0
 		case _1 = 1
@@ -14,7 +14,7 @@ extension K1.ECDSA.Recoverable.Signature {
 	}
 }
 
-extension K1.ECDSA.Recoverable.Signature.RecoveryID {
+extension K1.ECDSAWithKeyRecovery.Signature.RecoveryID {
 	public init(byte: UInt8) throws {
 		guard let self_ = Self(rawValue: byte) else {
 			throw K1.Error.invalidParameter