sign_transaction.cpp raw

   1  // Copyright (c) 2023 The Limenka developers
   2  // Distributed under the MIT software license, see the accompanying
   3  // file COPYING or http://www.opensource.org/licenses/mit-license.php.
   4  
   5  #include <addresstype.h>
   6  #include <bench/bench.h>
   7  #include <coins.h>
   8  #include <key.h>
   9  #include <primitives/transaction.h>
  10  #include <pubkey.h>
  11  #include <script/interpreter.h>
  12  #include <script/script.h>
  13  #include <script/sign.h>
  14  #include <script/signingprovider.h>
  15  #include <span.h>
  16  #include <test/util/random.h>
  17  #include <uint256.h>
  18  #include <util/translation.h>
  19  
  20  #include <cassert>
  21  #include <map>
  22  #include <vector>
  23  
  24  enum class InputType {
  25      P2WPKH, // segwitv0, witness-pubkey-hash (ECDSA signature)
  26      P2TR,   // segwitv1, taproot key-path spend (Schnorr signature)
  27  };
  28  
  29  static void SignTransactionSingleInput(benchmark::Bench& bench, InputType input_type)
  30  {
  31      ECC_Context ecc_context{};
  32  
  33      FlatSigningProvider keystore;
  34      std::vector<CScript> prev_spks;
  35  
  36      // Create a bunch of keys / UTXOs to avoid signing with the same key repeatedly
  37      for (int i = 0; i < 32; i++) {
  38          CKey privkey = GenerateRandomKey();
  39          CPubKey pubkey = privkey.GetPubKey();
  40          CKeyID key_id = pubkey.GetID();
  41          keystore.keys.emplace(key_id, privkey);
  42          keystore.pubkeys.emplace(key_id, pubkey);
  43  
  44          // Create specified locking script type
  45          CScript prev_spk;
  46          switch (input_type) {
  47          case InputType::P2WPKH: prev_spk = GetScriptForDestination(WitnessV0KeyHash(pubkey)); break;
  48          case InputType::P2TR:   prev_spk = GetScriptForDestination(WitnessV1Taproot(XOnlyPubKey{pubkey})); break;
  49          default: assert(false);
  50          }
  51          prev_spks.push_back(prev_spk);
  52      }
  53  
  54      // Simple 1-input tx with artificial outpoint
  55      // (note that for the purpose of signing with SIGHASH_ALL we don't need any outputs)
  56      COutPoint prevout{/*hashIn=*/Txid::FromUint256(uint256::ONE), /*nIn=*/1337};
  57      CMutableTransaction unsigned_tx;
  58      unsigned_tx.vin.emplace_back(prevout);
  59  
  60      // Benchmark.
  61      int iter = 0;
  62      bench.minEpochIterations(100).run([&] {
  63          CMutableTransaction tx{unsigned_tx};
  64          std::map<COutPoint, Coin> coins;
  65          const CScript& prev_spk = prev_spks[(iter++) % prev_spks.size()];
  66          coins[prevout] = Coin(CTxOut(10000, prev_spk), /*nHeightIn=*/100, /*fCoinBaseIn=*/false);
  67          std::map<int, bilingual_str> input_errors;
  68          bool complete = SignTransaction(tx, &keystore, coins, SIGHASH_ALL, input_errors);
  69          assert(complete);
  70      });
  71  }
  72  
  73  static void SignTransactionECDSA(benchmark::Bench& bench)   { SignTransactionSingleInput(bench, InputType::P2WPKH); }
  74  static void SignTransactionSchnorr(benchmark::Bench& bench) { SignTransactionSingleInput(bench, InputType::P2TR);   }
  75  
  76  static void SignSchnorrTapTweakBenchmark(benchmark::Bench& bench, bool use_null_merkle_root)
  77  {
  78      FastRandomContext rng;
  79      ECC_Context ecc_context{};
  80  
  81      auto key = GenerateRandomKey();
  82      auto msg = rng.rand256();
  83      auto merkle_root = use_null_merkle_root ? uint256() : rng.rand256();
  84      auto aux = rng.rand256();
  85      std::vector<unsigned char> sig(64);
  86  
  87      bench.minEpochIterations(100).run([&] {
  88          bool success = key.SignSchnorr(msg, sig, &merkle_root, aux);
  89          assert(success);
  90      });
  91  }
  92  
  93  static void SignSchnorrWithMerkleRoot(benchmark::Bench& bench)
  94  {
  95      SignSchnorrTapTweakBenchmark(bench, /*use_null_merkle_root=*/false);
  96  }
  97  
  98  static void SignSchnorrWithNullMerkleRoot(benchmark::Bench& bench)
  99  {
 100      SignSchnorrTapTweakBenchmark(bench, /*use_null_merkle_root=*/true);
 101  }
 102  
 103  BENCHMARK(SignTransactionECDSA, benchmark::PriorityLevel::HIGH);
 104  BENCHMARK(SignTransactionSchnorr, benchmark::PriorityLevel::HIGH);
 105  BENCHMARK(SignSchnorrWithMerkleRoot, benchmark::PriorityLevel::HIGH);
 106  BENCHMARK(SignSchnorrWithNullMerkleRoot, benchmark::PriorityLevel::HIGH);
 107