improve ed25519 bip32 derivation

Author: ERussel

SubstrateSdk/Classes/Crypto/BIP32ExtendedKeypair.swift

@@ -2,16 +2,13 @@ import NovaCrypto
 
 public class BIP32ExtendedKeypair {
     let keypair: IRCryptoKeypairProtocol
-    let nextSeed: Data
     let chaincode: Data
 
     init(
         keypair: IRCryptoKeypairProtocol,
-        nextSeed: Data,
         chaincode: Data
     ) {
         self.keypair = keypair
-        self.nextSeed = nextSeed
         self.chaincode = chaincode
     }
 }

SubstrateSdk/Classes/Crypto/KeypairFactory/BIP32Ed25519KeyFactory.swift

@@ -18,13 +18,13 @@ public final class BIP32Ed25519KeyFactory: BIP32KeypairFactory {
         let privateKeySeed = hmacResult[...31]
         let chainCode = hmacResult[32...]
 
-        let keypair = try internalFactory.derive(fromSeed: privateKeySeed)
+        // we are returning seed as private key as both further derivation and signature requires it
+        let publicKey = try internalFactory.derive(fromSeed: privateKeySeed).publicKey()
+        let secretKey = try EDPrivateKey(rawData: privateKeySeed)
+        
+        let keypair = IRCryptoKeypair(publicKey: publicKey, privateKey: secretKey)
 
-        return BIP32ExtendedKeypair(
-            keypair: keypair,
-            nextSeed: privateKeySeed,
-            chaincode: chainCode
-        )
+        return BIP32ExtendedKeypair(keypair: keypair, chaincode: chainCode)
     }
 
     override func createKeypairFrom(
@@ -35,8 +35,9 @@ public final class BIP32Ed25519KeyFactory: BIP32KeypairFactory {
             switch chaincode.type {
             case .hard:
                 let padding = Data(repeating: 0, count: 1)
+                let privateKeyData = parentKeypair.privateKey().rawData()
 
-                return padding + parentKeypair.nextSeed + chaincode.data
+                return padding + privateKeyData + chaincode.data
 
             case .soft:
                 throw BIP32KeypairFactoryError.unsupportedSoftDerivation
@@ -50,12 +51,13 @@ public final class BIP32Ed25519KeyFactory: BIP32KeypairFactory {
 
         let childPrivateKeySeed = hmacResult[...31]
         let childChaincode = hmacResult[32...]
-        let keypair = try internalFactory.derive(fromSeed: childPrivateKeySeed)
-
-        return BIP32ExtendedKeypair(
-            keypair: keypair,
-            nextSeed: childPrivateKeySeed,
-            chaincode: childChaincode
-        )
+        
+        // we are returning seed as private key as both further derivation and signature requires it
+        let publicKey = try internalFactory.derive(fromSeed: childPrivateKeySeed).publicKey()
+        let secretKey = try EDPrivateKey(rawData: childPrivateKeySeed)
+
+        let keypair = IRCryptoKeypair(publicKey: publicKey, privateKey: secretKey)
+        
+        return BIP32ExtendedKeypair(keypair: keypair, chaincode: childChaincode)
     }
 }

SubstrateSdk/Classes/Crypto/KeypairFactory/BIP32KeypairFactoryError.swift

@@ -1,6 +1,7 @@
 import NovaCrypto
 
 public enum BIP32KeypairFactoryError: Error {
+    case invalidMasterKey
     case invalidChildKey
     case unsupportedSoftDerivation
 }

SubstrateSdk/Classes/Crypto/KeypairFactory/BIP32Secp256KeypairFactory.swift

@@ -16,16 +16,19 @@ public final class BIP32Secp256KeypairFactory: BIP32KeypairFactory {
         )
 
         let privateKeyData = hmacResult[...31]
+        
+        let privateKeyInt = BigUInt(privateKeyData)
+
+        guard privateKeyInt < .secp256k1CurveOrder, privateKeyInt > 0 else {
+            throw BIP32KeypairFactoryError.invalidMasterKey
+        }
+        
         let privateKey = try SECPrivateKey(rawData: privateKeyData)
         let chainCode = hmacResult[32...]
 
         let keypair = try internalFactory.derive(fromPrivateKey: privateKey)
 
-        return BIP32ExtendedKeypair(
-            keypair: keypair,
-            nextSeed: privateKeyData,
-            chaincode: chainCode
-        )
+        return BIP32ExtendedKeypair(keypair: keypair, chaincode: chainCode)
     }
 
     override func createKeypairFrom(
@@ -36,8 +39,9 @@ public final class BIP32Secp256KeypairFactory: BIP32KeypairFactory {
             switch chaincode.type {
             case .hard:
                 let padding = Data(repeating: 0, count: 1)
-
-                return padding + parentKeypair.nextSeed + chaincode.data
+                let privateKeyData = parentKeypair.privateKey().rawData()
+                
+                return padding + privateKeyData + chaincode.data
 
             case .soft:
                 return parentKeypair.publicKey().rawData() + chaincode.data
@@ -58,7 +62,7 @@ public final class BIP32Secp256KeypairFactory: BIP32KeypairFactory {
             throw BIP32KeypairFactoryError.invalidChildKey
         }
 
-        privateKeyInt += BigUInt(parentKeypair.nextSeed)
+        privateKeyInt += BigUInt(parentKeypair.privateKey().rawData())
         privateKeyInt %= .secp256k1CurveOrder
 
         guard privateKeyInt > 0 else {
@@ -82,7 +86,6 @@ public final class BIP32Secp256KeypairFactory: BIP32KeypairFactory {
 
         return BIP32ExtendedKeypair(
             keypair: keypair,
-            nextSeed: privateKeyData,
             chaincode: childChaincode
         )
     }

Tests/Crypto/BIP32/BIP32Ed25519KeypairDerivationTests.swift

@@ -79,10 +79,18 @@ final class BIP32Ed25519KeypairDerivationTests: XCTestCase {
 
                 let keypair = try keypairFactory.createKeypairFromSeed(seed, chaincodeList: result.chaincodes)
 
+                let expectedPrivateKey = try Data(hexString: item.privateKey)
                 let expectedPublicKey = try item.getPublicKeyWithoutPrefix()
-
+                
+                let actualPrivateKey = keypair.privateKey().rawData()
                 let actualPublicKey = keypair.publicKey().rawData()
 
+                XCTAssertEqual(
+                    expectedPrivateKey,
+                    actualPrivateKey,
+                    "Expected private key \(expectedPrivateKey.toHex()) but received \(actualPrivateKey.toHex())"
+                )
+                
                 XCTAssertEqual(
                     expectedPublicKey,
                     actualPublicKey,