Branch data     Line data    Source code

       1                 :             : // Copyright (c) 2024-present The Bitcoin Core 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 <musig.h>
       6                 :             : 
       7                 :             : #include <secp256k1_musig.h>
       8                 :             : 
       9                 :         125 : bool GetMuSig2KeyAggCache(const std::vector<CPubKey>& pubkeys, secp256k1_musig_keyagg_cache& keyagg_cache)
      10                 :             : {
      11                 :             :     // Parse the pubkeys
      12                 :         125 :     std::vector<secp256k1_pubkey> secp_pubkeys;
      13                 :         125 :     std::vector<const secp256k1_pubkey*> pubkey_ptrs;
      14         [ +  + ]:         466 :     for (const CPubKey& pubkey : pubkeys) {
      15   [ +  -  +  -  :         341 :         if (!secp256k1_ec_pubkey_parse(secp256k1_context_static, &secp_pubkeys.emplace_back(), pubkey.data(), pubkey.size())) {
                   +  - ]
      16                 :             :             return false;
      17                 :             :         }
      18                 :             :     }
      19         [ +  - ]:         125 :     pubkey_ptrs.reserve(secp_pubkeys.size());
      20         [ +  + ]:         466 :     for (const secp256k1_pubkey& p : secp_pubkeys) {
      21         [ +  - ]:         341 :         pubkey_ptrs.push_back(&p);
      22                 :             :     }
      23                 :             : 
      24                 :             :     // Aggregate the pubkey
      25   [ +  -  -  + ]:         125 :     if (!secp256k1_musig_pubkey_agg(secp256k1_context_static, nullptr, &keyagg_cache, pubkey_ptrs.data(), pubkey_ptrs.size())) {
      26                 :           0 :         return false;
      27                 :             :     }
      28                 :             :     return true;
      29                 :         125 : }
      30                 :             : 
      31                 :         125 : std::optional<CPubKey> GetCPubKeyFromMuSig2KeyAggCache(secp256k1_musig_keyagg_cache& keyagg_cache)
      32                 :             : {
      33                 :             :     // Get the plain aggregated pubkey
      34                 :         125 :     secp256k1_pubkey agg_pubkey;
      35         [ -  + ]:         125 :     if (!secp256k1_musig_pubkey_get(secp256k1_context_static, &agg_pubkey, &keyagg_cache)) {
      36                 :           0 :         return std::nullopt;
      37                 :             :     }
      38                 :             : 
      39                 :             :     // Turn into CPubKey
      40                 :         125 :     unsigned char ser_agg_pubkey[CPubKey::COMPRESSED_SIZE];
      41                 :         125 :     size_t ser_agg_pubkey_len = CPubKey::COMPRESSED_SIZE;
      42                 :         125 :     secp256k1_ec_pubkey_serialize(secp256k1_context_static, ser_agg_pubkey, &ser_agg_pubkey_len, &agg_pubkey, SECP256K1_EC_COMPRESSED);
      43                 :         125 :     return CPubKey(ser_agg_pubkey, ser_agg_pubkey + ser_agg_pubkey_len);
      44                 :             : }
      45                 :             : 
      46                 :         125 : std::optional<CPubKey> MuSig2AggregatePubkeys(const std::vector<CPubKey>& pubkeys)
      47                 :             : {
      48                 :         125 :     secp256k1_musig_keyagg_cache keyagg_cache;
      49         [ -  + ]:         125 :     if (!GetMuSig2KeyAggCache(pubkeys, keyagg_cache)) {
      50                 :           0 :         return std::nullopt;
      51                 :             :     }
      52                 :         125 :     return GetCPubKeyFromMuSig2KeyAggCache(keyagg_cache);
      53                 :             : }