Adds ability to specify the curve while constructing Private Key (#4324)

* Adds ability to specify the curve while constructing Private Key

* Adds signing functions without a curve

* Migrates to new API

* Use TWCoinTypeCurve

* Adds Curve

Author: gupnik

src/Aeternity/Signer.cpp

@@ -15,7 +15,7 @@ using namespace TW;
 namespace TW::Aeternity {
 
 Proto::SigningOutput Signer::sign(const Proto::SigningInput& input) noexcept {
-    auto privateKey = PrivateKey(Data(input.private_key().begin(), input.private_key().end()));
+    auto privateKey = PrivateKey(Data(input.private_key().begin(), input.private_key().end()), TWCurveED25519);
     std::string sender_id = input.from_address();
     std::string recipient_id = input.to_address();
     std::string payload = input.payload();
@@ -34,7 +34,7 @@ Proto::SigningOutput Signer::sign(const TW::PrivateKey& privateKey, Transaction&
     auto msg = buildMessageToSign(txRlp);
 
     /// sign ed25519
-    auto sigRaw = privateKey.sign(msg, TWCurveED25519);
+    auto sigRaw = privateKey.sign(msg);
     auto signature = Identifiers::prefixSignature + Base58::encodeCheck(sigRaw);
 
     /// encode the message using rlp

src/Aion/Signer.cpp

@@ -9,7 +9,7 @@ using namespace TW;
 namespace TW::Aion {
 
 Proto::SigningOutput Signer::sign(const Proto::SigningInput& input) noexcept {
-    auto key = PrivateKey(Data(input.private_key().begin(), input.private_key().end()));
+    auto key = PrivateKey(Data(input.private_key().begin(), input.private_key().end()), TWCurveED25519);
     auto transaction = Signer::buildTransaction(input);
     Signer::sign(key, transaction);
 
@@ -23,7 +23,7 @@ Proto::SigningOutput Signer::sign(const Proto::SigningInput& input) noexcept {
 void Signer::sign(const PrivateKey& privateKey, Transaction& transaction) noexcept {
     auto encoded = transaction.encode();
     auto hashData = Hash::blake2b(encoded, 32);
-    auto hashSignature = privateKey.sign(hashData, TWCurveED25519);
+    auto hashSignature = privateKey.sign(hashData);
     auto publicKeyData = privateKey.getPublicKey(TWPublicKeyTypeED25519).bytes;
 
     // Aion signature = pubKeyBytes + signatureBytes

src/Algorand/Signer.cpp

@@ -18,11 +18,11 @@ const std::string ASSET_TRANSACTION = "axfer";
 
 Proto::SigningOutput Signer::sign(const Proto::SigningInput& input) noexcept {
     auto protoOutput = Proto::SigningOutput();
-    auto key = PrivateKey(Data(input.private_key().begin(), input.private_key().end()));
+    auto key = PrivateKey(Data(input.private_key().begin(), input.private_key().end()), TWCurveED25519);
     auto pubkey = key.getPublicKey(TWPublicKeyTypeED25519);
 
     auto preImageData = Signer::preImage(pubkey, input);
-    auto signature = key.sign(preImageData, TWCurveED25519);
+    auto signature = key.sign(preImageData);
     return Signer::encodeTransaction(signature, pubkey, input);
 }
 
@@ -37,7 +37,7 @@ Data Signer::sign(const PrivateKey& privateKey, const BaseTransaction& transacti
     Data data;
     append(data, TRANSACTION_TAG);
     append(data, transaction.serialize());
-    auto signature = privateKey.sign(data, TWCurveED25519);
+    auto signature = privateKey.sign(data);
     return {signature.begin(), signature.end()};
 }
 

src/Bitcoin/SigningInput.cpp

@@ -17,7 +17,7 @@ SigningInput::SigningInput(const Proto::SigningInput& input) {
     toAddress = input.to_address();
     changeAddress = input.change_address();
     for (auto&& key : input.private_key()) {
-        privateKeys.emplace_back(key);
+        privateKeys.emplace_back(key, TWCurveSECP256k1);
     }
     for (auto&& script : input.scripts()) {
         scripts[script.first] = Script(script.second.begin(), script.second.end());

src/Cardano/Signer.cpp

@@ -129,7 +129,7 @@ Common::Proto::SigningError Signer::assembleSignatures(std::vector<std::pair<Dat
         }
 
         // Add this private key and associated address
-        const auto privateKey = PrivateKey(privateKeyData);
+        const auto privateKey = PrivateKey(privateKeyData, TWCurveED25519ExtendedCardano);
         const auto publicKey = privateKey.getPublicKey(TWPublicKeyTypeED25519Cardano);
         const auto address = AddressV3(publicKey);
         privateKeys[address.string()] = privateKeyData;
@@ -190,9 +190,9 @@ Common::Proto::SigningError Signer::assembleSignatures(std::vector<std::pair<Dat
                 return Common::Proto::Error_missing_private_key;
             }
         }
-        const auto privateKey = PrivateKey(privateKeyData);
+        const auto privateKey = PrivateKey(privateKeyData, TWCurveED25519ExtendedCardano);
         const auto publicKey = privateKey.getPublicKey(TWPublicKeyTypeED25519Cardano);
-        const auto signature = privateKey.sign(txId, TWCurveED25519ExtendedCardano);
+        const auto signature = privateKey.sign(txId);
         signatures.emplace_back(publicKey.bytes, signature);
     }
 

src/Decred/Signer.cpp

@@ -181,7 +181,7 @@ Result<std::vector<Data>, Common::Proto::SigningError> Signer::signStep(Bitcoin:
                 return Result<std::vector<Data>, Common::Proto::SigningError>::failure(Common::Proto::Error_missing_private_key);
             }
         } else {
-            pubkey = PrivateKey(key).getPublicKey(TWPublicKeyTypeSECP256k1).bytes;
+            pubkey = PrivateKey(key, TWCurveSECP256k1).getPublicKey(TWPublicKeyTypeSECP256k1).bytes;
         }
 
         auto signature = createSignature(transactionToSign, script, key, data, index);
@@ -263,7 +263,7 @@ Data Signer::createSignature(const Transaction& transaction, const Bitcoin::Scri
         return externalSignature;
     }
 
-    auto pk = PrivateKey(key);
+    auto pk = PrivateKey(key, TWCurveSECP256k1);
     auto signature = pk.signAsDER(Data(begin(sighash), end(sighash)));
     if (script.empty()) {
         return {};
@@ -275,7 +275,7 @@ Data Signer::createSignature(const Transaction& transaction, const Bitcoin::Scri
 
 Data Signer::keyForPublicKeyHash(const Data& hash) const {
     for (auto& key : input.private_key()) {
-        auto publicKey = PrivateKey(key).getPublicKey(TWPublicKeyTypeSECP256k1);
+        auto publicKey = PrivateKey(key, TWCurveSECP256k1).getPublicKey(TWPublicKeyTypeSECP256k1);
         auto keyHash = TW::Hash::ripemd(TW::Hash::blake256(publicKey.bytes));
         if (std::equal(std::begin(keyHash), std::end(keyHash), std::begin(hash), std::end(hash))) {
             return Data(key.begin(), key.end());

src/EOS/Signer.cpp

@@ -17,6 +17,8 @@ Proto::SigningOutput Signer::sign(const Proto::SigningInput& input) noexcept {
         auto signer = Signer(chainId);
         auto tx = signer.buildTx(input);
 
+        // values for Legacy and ModernK1
+        TWCurve curve = TWCurveSECP256k1;
         // get key type
         EOS::Type type = Type::Legacy;
         switch (input.private_key_type()) {
@@ -29,14 +31,15 @@ Proto::SigningOutput Signer::sign(const Proto::SigningInput& input) noexcept {
             break;
 
         case Proto::KeyType::MODERNR1:
+            curve = TWCurveNIST256p1;
             type = Type::ModernR1;
             break;
         default:
             break;
         }
 
         // sign the transaction with a Signer
-        auto key = PrivateKey(Data(input.private_key().begin(), input.private_key().end()));
+        auto key = PrivateKey(Data(input.private_key().begin(), input.private_key().end()), curve);
         signer.sign(key, type, tx);
 
         // Pack the transaction and add the json encoding to Signing outputput
@@ -55,17 +58,14 @@ void Signer::sign(const PrivateKey& privateKey, Type type, Transaction& transact
         throw std::invalid_argument("Invalid transaction!");
     }
 
-    // values for Legacy and ModernK1
-    TWCurve curve = TWCurveSECP256k1;
     auto canonicalChecker = isCanonical;
 
     //  Values for ModernR1
     if (type == Type::ModernR1) {
-        curve = TWCurveNIST256p1;
         canonicalChecker = nullptr;
     }
 
-    const Data result = privateKey.sign(hash(transaction), curve, canonicalChecker);
+    const Data result = privateKey.sign(hash(transaction), canonicalChecker);
 
     transaction.signatures.emplace_back(Signature(result, type));
 }

src/Ethereum/Barz.cpp

@@ -243,8 +243,8 @@ Data getAuthorizationHash(const Data& chainId, const std::string& contractAddres
 
 std::vector<Data> getRSVY(const Data& hash, const std::string& privateKey) {
     auto privateKeyData = parse_hex(privateKey);
-    auto privateKeyObj = PrivateKey(privateKeyData);
-    auto signature = privateKeyObj.sign(hash, TWCurveSECP256k1);
+    auto privateKeyObj = PrivateKey(privateKeyData, TWCurveSECP256k1);
+    auto signature = privateKeyObj.sign(hash);
     if (signature.empty()) {
         return {};
     }

src/Everscale/Signer.cpp

@@ -12,7 +12,7 @@
 namespace TW::Everscale {
 
 Proto::SigningOutput Signer::sign(const Proto::SigningInput& input) noexcept {
-    auto key = PrivateKey(input.private_key());
+    auto key = PrivateKey(input.private_key(), TWCurveED25519);
     auto publicKey = key.getPublicKey(TWPublicKeyTypeED25519);
 
     auto protoOutput = Proto::SigningOutput();

src/FIO/TransactionBuilder.cpp

@@ -70,7 +70,7 @@ string TransactionBuilder::actionName(const Proto::SigningInput& input) {
 }
 
 string TransactionBuilder::sign(Proto::SigningInput in) {
-    PrivateKey privateKey(in.private_key());
+    PrivateKey privateKey(in.private_key(), TWCurveSECP256k1);
     PublicKey publicKey = privateKey.getPublicKey(TWPublicKeyTypeSECP256k1);
     Address owner(publicKey);