Rename secp256k1 enum to P256K

Author: csjones

Projects/Sources/P256K/P256K.swift

@@ -0,0 +1 @@
+../../../Sources/ZKP/P256K.swift

Projects/Sources/P256K/secp256k1.swift

@@ -5,7 +5,7 @@ public struct ContentView: View {
     public init() {}
 
     public var body: some View {
-        let privateKey = try! secp256k1.Signing.PrivateKey()
+        let privateKey = try! P256K.Signing.PrivateKey()
         let stringKey = String(bytes: privateKey.dataRepresentation)
 
         Text("KEY: \(stringKey)")

Projects/Sources/XCFrameworkApp/ContentView.swift

@@ -8,7 +8,7 @@ Swift package for elliptic curve public key cryptography, ECDSA, and Schnorr Sig
 
 - Provide lightweight ECDSA & Schnorr Signatures functionality
 - Support simple and advanced usage, including BIP-327 and BIP-340
-- Expose C bindings for full control of the secp256k1 implementation
+- Expose libsecp256k1 bindings for full control of the implementation
 - Offer a familiar API design inspired by [Swift Crypto](https://github.com/apple/swift-crypto)
 - Maintain automatic updates for Swift and libsecp256k1
 - Ensure availability for Linux and Apple platform ecosystems
@@ -28,14 +28,14 @@ This package uses Swift Package Manager. To add it to your project:
 Add the following to your `Package.swift` file:
 
 ```swift
-.package(name: "swift-secp256k1", url: "https://github.com/21-DOT-DEV/swift-secp256k1", exact: "0.18.0"),
+.package(name: "swift-secp256k1", url: "https://github.com/21-DOT-DEV/swift-secp256k1", exact: "0.19.0"),
 ```
 
 Then, include `secp256k1` as a dependency in your target:
 
 ```swift
 .target(name: "<target>", dependencies: [
-    .product(name: "secp256k1", package: "swift-secp256k1")
+    .product(name: "P256K", package: "swift-secp256k1")
 ]),
 ```
 
@@ -54,11 +54,11 @@ arena 21-DOT-DEV/swift-secp256k1
 
 ### ECDSA
 ```swift
-import secp256k1
+import P256K
 
 // Private key
 let privateBytes = try! "14E4A74438858920D8A35FB2D88677580B6A2EE9BE4E711AE34EC6B396D87B5C".bytes
-let privateKey = try! secp256k1.Signing.PrivateKey(rawRepresentation: privateBytes)
+let privateKey = try! P256K.Signing.PrivateKey(rawRepresentation: privateBytes)
 
 // Public key
 print(String(bytes: privateKey.publicKey.rawRepresentation))
@@ -74,7 +74,7 @@ print(try! signature.derRepresentation.base64EncodedString())
 ### Schnorr
 ```swift
 // Strict BIP340 mode is disabled by default for Schnorr signatures with variable length messages
-let privateKey = try! secp256k1.Schnorr.PrivateKey()
+let privateKey = try! P256K.Schnorr.PrivateKey()
 
 // Extra params for custom signing
 var auxRand = try! "C87AA53824B4D7AE2EB035A2B5BBBCCC080E76CDC6D1692C4B0B62D798E6D906".bytes
@@ -87,7 +87,7 @@ let signature = try! privateKey.signature(message: &messageDigest, auxiliaryRand
 ## Tweak
 
 ```swift
-let privateKey = try! secp256k1.Signing.PrivateKey()
+let privateKey = try! P256K.Signing.PrivateKey()
 
 // Adding a tweak to the private key and public key
 let tweak = try! "5f0da318c6e02f653a789950e55756ade9f194e1ec228d7f368de1bd821322b6".bytes
@@ -98,8 +98,8 @@ let tweakedPublicKeyKey = try! privateKey.publicKey.add(tweak)
 ## Elliptic Curve Diffie Hellman
 
 ```swift
-let privateKey = try! secp256k1.KeyAgreement.PrivateKey()
-let publicKey = try! secp256k1.KeyAgreement.PrivateKey().publicKey
+let privateKey = try! P256K.KeyAgreement.PrivateKey()
+let publicKey = try! P256K.KeyAgreement.PrivateKey().publicKey
 
 // Create a compressed shared secret with a private key from only a public key
 let sharedSecret = try! privateKey.sharedSecretFromKeyAgreement(with: publicKey, format: .compressed)
@@ -111,17 +111,17 @@ let symmetricKey = SHA256.hash(data: sharedSecret.bytes)
 ## Silent Payments Scheme
 
 ```swift
-let privateSign1 = try! secp256k1.Signing.PrivateKey()
-let privateSign2 = try! secp256k1.Signing.PrivateKey()
+let privateSign1 = try! P256K.Signing.PrivateKey()
+let privateSign2 = try! P256K.Signing.PrivateKey()
 
-let privateKey1 = try! secp256k1.KeyAgreement.PrivateKey(rawRepresentation: privateSign1.rawRepresentation)
-let privateKey2 = try! secp256k1.KeyAgreement.PrivateKey(rawRepresentation: privateSign2.rawRepresentation)
+let privateKey1 = try! P256K.KeyAgreement.PrivateKey(rawRepresentation: privateSign1.rawRepresentation)
+let privateKey2 = try! P256K.KeyAgreement.PrivateKey(rawRepresentation: privateSign2.rawRepresentation)
 
 let sharedSecret1 = try! privateKey1.sharedSecretFromKeyAgreement(with: privateKey2.publicKey)
 let sharedSecret2 = try! privateKey2.sharedSecretFromKeyAgreement(with: privateKey1.publicKey)
 
-let sharedSecretSign1 = try! secp256k1.Signing.PrivateKey(rawRepresentation: sharedSecret1.bytes)
-let sharedSecretSign2 = try! secp256k1.Signing.PrivateKey(rawRepresentation: sharedSecret2.bytes)
+let sharedSecretSign1 = try! P256K.Signing.PrivateKey(rawRepresentation: sharedSecret1.bytes)
+let sharedSecretSign2 = try! P256K.Signing.PrivateKey(rawRepresentation: sharedSecret2.bytes)
 
 // Payable Silent Payment public key
 let xonlyTweak2 = try! sharedSecretSign2.publicKey.xonly.add(privateSign1.publicKey.xonly.bytes)
@@ -133,14 +133,14 @@ let privateTweak1 = try! sharedSecretSign1.add(xonly: privateSign1.publicKey.xon
 ## Recovery
 
 ```swift
-let privateKey = try! secp256k1.Recovery.PrivateKey()
+let privateKey = try! P256K.Recovery.PrivateKey()
 let messageData = "We're all Satoshi.".data(using: .utf8)!
 
 // Create a recoverable ECDSA signature
 let recoverySignature = try! privateKey.signature(for: messageData)
 
 // Recover an ECDSA public key from a signature
-let publicKey = try! secp256k1.Recovery.PublicKey(messageData, signature: recoverySignature)
+let publicKey = try! P256K.Recovery.PublicKey(messageData, signature: recoverySignature)
 
 // Convert a recoverable signature into a normal signature
 let signature = try! recoverySignature.normalize
@@ -149,8 +149,8 @@ let signature = try! recoverySignature.normalize
 ## Combine Public Keys
 
 ```swift
-let privateKey = try! secp256k1.Signing.PrivateKey()
-let publicKey = try! secp256k1.Signing.PrivateKey().public
+let privateKey = try! P256K.Signing.PrivateKey()
+let publicKey = try! P256K.Signing.PrivateKey().public
 
 // The Combine API arguments are an array of PublicKey objects and an optional format 
 publicKey.combine([privateKey.publicKey], format: .uncompressed)
@@ -168,38 +168,38 @@ oUQDQgAEt2uDn+2GqqYs/fmkBr5+rCQ3oiFSIJMAcjHIrTDS6HEELgguOatmFBOp
 """
 
 // Import keys generated from OpenSSL
-let privateKey = try! secp256k1.Signing.PrivateKey(pemRepresentation: privateKeyString)
+let privateKey = try! P256K.Signing.PrivateKey(pemRepresentation: privateKeyString)
 ```
 
 ## MuSig2
 
 ```swift
 // Initialize private keys for two signers
-let firstPrivateKey = try secp256k1.Schnorr.PrivateKey()
-let secondPrivateKey = try secp256k1.Schnorr.PrivateKey()
+let firstPrivateKey = try P256K.Schnorr.PrivateKey()
+let secondPrivateKey = try P256K.Schnorr.PrivateKey()
 
 // Aggregate the public keys using MuSig
-let aggregateKey = try secp256k1.MuSig.aggregate([firstPrivateKey.publicKey, secondPrivateKey.publicKey])
+let aggregateKey = try P256K.MuSig.aggregate([firstPrivateKey.publicKey, secondPrivateKey.publicKey])
 
 // Message to be signed
 let message = "Vires in Numeris.".data(using: .utf8)!
 let messageHash = SHA256.hash(data: message)
 
 // Generate nonces for each signer
-let firstNonce = try secp256k1.MuSig.Nonce.generate(
+let firstNonce = try P256K.MuSig.Nonce.generate(
     secretKey: firstPrivateKey,
     publicKey: firstPrivateKey.publicKey,
     msg32: Array(messageHash)
 )
 
-let secondNonce = try secp256k1.MuSig.Nonce.generate(
+let secondNonce = try P256K.MuSig.Nonce.generate(
     secretKey: secondPrivateKey,
     publicKey: secondPrivateKey.publicKey,
     msg32: Array(messageHash)
 )
 
 // Aggregate nonces
-let aggregateNonce = try secp256k1.MuSig.Nonce(aggregating: [firstNonce.pubnonce, secondNonce.pubnonce])
+let aggregateNonce = try P256K.MuSig.Nonce(aggregating: [firstNonce.pubnonce, secondNonce.pubnonce])
 
 // Create partial signatures
 let firstPartialSignature = try firstPrivateKey.partialSignature(
@@ -219,7 +219,7 @@ let secondPartialSignature = try secondPrivateKey.partialSignature(
 )
 
 // Aggregate partial signatures into a full signature
-let aggregateSignature = try secp256k1.MuSig.aggregateSignatures([firstPartialSignature, secondPartialSignature])
+let aggregateSignature = try P256K.MuSig.aggregateSignatures([firstPartialSignature, secondPartialSignature])
 
 // Verify the aggregate signature
 let isValid = aggregateKey.isValidSignature(

README.md

@@ -0,0 +1 @@
+../ZKP/P256K.swift

Sources/P256K/P256K.swift

@@ -11,7 +11,7 @@
 import Foundation
 
 /// An elliptic curve that enables secp256k1 signatures and key agreement.
-public extension secp256k1 {
+public extension P256K {
     /// A mechanism used to create or verify a cryptographic signature using the secp256k1
     /// elliptic curve digital signature algorithm (ECDSA).
     enum Signing {
@@ -49,7 +49,7 @@ public extension secp256k1 {
             ///
             /// - Parameter format: The key format, default is .compressed.
             /// - Throws: An error if the private key cannot be generated.
-            public init(format: secp256k1.Format = .compressed) throws {
+            public init(format: P256K.Format = .compressed) throws {
                 self.baseKey = try PrivateKeyImplementation(format: format)
             }
 
@@ -58,7 +58,7 @@ public extension secp256k1 {
             /// - Parameter data: A data representation of the key.
             /// - Parameter format: The key format, default is .compressed.
             /// - Throws: An error if the raw representation does not create a private key for signing.
-            public init<D: ContiguousBytes>(dataRepresentation data: D, format: secp256k1.Format = .compressed) throws {
+            public init<D: ContiguousBytes>(dataRepresentation data: D, format: P256K.Format = .compressed) throws {
                 self.baseKey = try PrivateKeyImplementation(dataRepresentation: data, format: format)
             }
 
@@ -135,7 +135,7 @@ public extension secp256k1 {
             }
 
             /// The key format representation of the public key.
-            public var format: secp256k1.Format {
+            public var format: P256K.Format {
                 baseKey.format
             }
 
@@ -170,7 +170,7 @@ public extension secp256k1 {
             /// - Parameter data: A data representation of the key.
             /// - Parameter format: The key format.
             /// - Throws: An error if the data representation does not create a public key.
-            public init<D: ContiguousBytes>(dataRepresentation data: D, format: secp256k1.Format) throws {
+            public init<D: ContiguousBytes>(dataRepresentation data: D, format: P256K.Format) throws {
                 self.baseKey = try PublicKeyImplementation(dataRepresentation: data, format: format)
             }
 
@@ -205,7 +205,7 @@ public extension secp256k1 {
                 let length = x963Representation.withUnsafeBytes { $0.count }
 
                 switch length {
-                case (2 * secp256k1.ByteLength.dimension) + 1:
+                case (2 * P256K.ByteLength.dimension) + 1:
                     self.baseKey = try PublicKeyImplementation(dataRepresentation: x963Representation, format: .uncompressed)
 
                 default:

Sources/P256K/secp256k1.swift

@@ -16,14 +16,14 @@ import Foundation
 @_implementationOnly import libsecp256k1
 #endif
 
-public extension secp256k1.Signing.PublicKey {
+public extension P256K.Signing.PublicKey {
     /// Create a new `PublicKey` by combining the current public key with an array of public keys.
     /// - Parameters:
     ///   - pubkeys: the array of public key objects to be combined with
     ///   - format: the format of the combined `PublicKey` object
     /// - Returns: combined `PublicKey` object
-    func combine(_ pubkeys: [Self], format: secp256k1.Format = .compressed) throws -> Self {
-        let context = secp256k1.Context.rawRepresentation
+    func combine(_ pubkeys: [Self], format: P256K.Format = .compressed) throws -> Self {
+        let context = P256K.Context.rawRepresentation
         let allPubKeys = [self] + pubkeys
         var pubKeyLen = format.length
         var combinedKey = secp256k1_pubkey()

Sources/ZKP/Asymmetric.swift

@@ -23,7 +23,7 @@
 /// A constructed context can safely be used from multiple threads simultaneously, but API calls that take a non-const
 /// pointer to a context need exclusive access to it. In particular this is the case for `secp256k1_context_destroy`,
 /// `secp256k1_context_preallocated_destroy`, and `secp256k1_context_randomize`.
-public extension secp256k1 {
+public extension P256K {
     /// A structure that represents the context flags for `secp256k1` operations.
     ///
     /// This structure conforms to the `OptionSet` protocol, allowing you to combine different context flags.
@@ -34,7 +34,7 @@ public extension secp256k1 {
     /// memory for the context.
     struct Context: OptionSet {
         /// The raw representation of `secp256k1.Context`
-        public static let rawRepresentation = try! secp256k1.Context.create()
+        public static let rawRepresentation = try! P256K.Context.create()
 
         /// The raw value of the context flags.
         public let rawValue: UInt32
@@ -63,7 +63,7 @@ public extension secp256k1 {
         /// the `Context` structure. The method throws an error if the context creation or randomization fails. If the
         /// context creation is successful, the method returns an opaque pointer to the created context.
         public static func create(_ context: Self = .none) throws -> OpaquePointer {
-            var randomBytes = SecureBytes(count: secp256k1.ByteLength.privateKey).bytes
+            var randomBytes = SecureBytes(count: P256K.ByteLength.privateKey).bytes
             guard let context = secp256k1_context_create(context.rawValue),
                   secp256k1_context_randomize(context, &randomBytes).boolValue else {
                 throw secp256k1Error.underlyingCryptoError

Sources/ZKP/Combine.swift

@@ -53,7 +53,7 @@ public struct SharedSecret: ContiguousBytes {
     var ss: SecureBytes
 
     // An enum that represents the format of the shared secret
-    let format: secp256k1.Format
+    let format: P256K.Format
 
     public func withUnsafeBytes<R>(_ body: (UnsafeRawBufferPointer) throws -> R) rethrows -> R {
         try ss.withUnsafeBytes(body)