Merge #7123: backport: Merge bitcoin#28903, 28924, 29056, 28455, 29037

dc72085 Merge bitcoin#29037: Add multiplication operator to CFeeRate (Ava Chow)
32f945e Merge bitcoin#28455: refactor: share and use `GenerateRandomKey` helper (Ava Chow)
7ab8da3 Merge bitcoin#29056: refactor: Print verbose serialize compiler error messages (Ava Chow)
57f8b72 Merge bitcoin#28924: refactor: Remove unused and fragile string interface from arith_uint256 (fanquake)
4afafe2 Merge bitcoin#28903: refactor: Make CTxMemPoolEntry only explicitly copyable (Andrew Chow)

Pull request description:

  bitcoin backports

ACKs for top commit:
  UdjinM6:
    utACK dc72085
  knst:
    utACK dc72085

Tree-SHA512: ea6726887b269d09ed7b8d024374c3a17111ad5d17557d55ca1ef55d5d60e3ad7e931d965a6ebc742e74c55d6e2695e37a1c5933bdd284f57d529e2651a78c00

Author: PastaPastaPasta

src/.clang-format

@@ -52,5 +52,7 @@ SpacesInAngles:  false
 SpacesInContainerLiterals: true
 SpacesInCStyleCastParentheses: false
 SpacesInParentheses: false
+BreakBeforeConceptDeclarations: Always
+RequiresExpressionIndentation: OuterScope
 Standard: c++20
 UseTab:          Never

src/arith_uint256.cpp

@@ -8,14 +8,7 @@
 #include <uint256.h>
 #include <crypto/common.h>
 
-
-template <unsigned int BITS>
-base_uint<BITS>::base_uint(const std::string& str)
-{
-    static_assert(BITS/32 > 0 && BITS%32 == 0, "Template parameter BITS must be a positive multiple of 32.");
-
-    SetHex(str);
-}
+#include <cassert>
 
 template <unsigned int BITS>
 base_uint<BITS>& base_uint<BITS>::operator<<=(unsigned int shift)
@@ -153,22 +146,6 @@ std::string base_uint<BITS>::GetHex() const
     return b.GetHex();
 }
 
-template <unsigned int BITS>
-void base_uint<BITS>::SetHex(const char* psz)
-{
-    base_blob<BITS> b;
-    b.SetHex(psz);
-    for (int x = 0; x < this->WIDTH; ++x) {
-        this->pn[x] = ReadLE32(b.begin() + x*4);
-    }
-}
-
-template <unsigned int BITS>
-void base_uint<BITS>::SetHex(const std::string& str)
-{
-    SetHex(str.c_str());
-}
-
 template <unsigned int BITS>
 std::string base_uint<BITS>::ToString() const
 {

src/arith_uint256.h

@@ -6,10 +6,10 @@
 #ifndef BITCOIN_ARITH_UINT256_H
 #define BITCOIN_ARITH_UINT256_H
 
+#include <cstdint>
 #include <cstring>
 #include <limits>
 #include <stdexcept>
-#include <stdint.h>
 #include <string>
 
 class uint256;
@@ -56,8 +56,6 @@ class base_uint
             pn[i] = 0;
     }
 
-    explicit base_uint(const std::string& str);
-
     base_uint operator~() const
     {
         base_uint ret;
@@ -219,8 +217,6 @@ class base_uint
     friend inline bool operator!=(const base_uint& a, uint64_t b) { return !a.EqualTo(b); }
 
     std::string GetHex() const;
-    void SetHex(const char* psz);
-    void SetHex(const std::string& str);
     std::string ToString() const;
 
     unsigned int size() const
@@ -247,7 +243,6 @@ class arith_uint256 : public base_uint<256> {
     arith_uint256() {}
     arith_uint256(const base_uint<256>& b) : base_uint<256>(b) {}
     arith_uint256(uint64_t b) : base_uint<256>(b) {}
-    explicit arith_uint256(const std::string& str) : base_uint<256>(str) {}
 
     /**
      * The "compact" format is a representation of a whole

src/bench/ellswift.cpp

@@ -11,9 +11,7 @@ static void EllSwiftCreate(benchmark::Bench& bench)
 {
     ECC_Start();
 
-    CKey key;
-    key.MakeNewKey(true);
-
+    CKey key = GenerateRandomKey();
     uint256 entropy = GetRandHash();
 
     bench.batch(1).unit("pubkey").run([&] {

src/key.cpp

@@ -340,6 +340,13 @@ ECDHSecret CKey::ComputeBIP324ECDHSecret(const EllSwiftPubKey& their_ellswift, c
     return output;
 }
 
+CKey GenerateRandomKey(bool compressed) noexcept
+{
+    CKey key;
+    key.MakeNewKey(/*fCompressed=*/compressed);
+    return key;
+}
+
 bool CExtKey::Derive(CExtKey &out, unsigned int _nChild) const {
     if (nDepth == std::numeric_limits<unsigned char>::max()) return false;
     out.nDepth = nDepth + 1;
@@ -391,8 +398,7 @@ void CExtKey::Decode(const unsigned char code[BIP32_EXTKEY_SIZE]) {
 }
 
 bool ECC_InitSanityCheck() {
-    CKey key;
-    key.MakeNewKey(true);
+    CKey key = GenerateRandomKey();
     CPubKey pubkey = key.GetPubKey();
     return key.VerifyPubKey(pubkey);
 }

src/key.h

@@ -168,6 +168,8 @@ class CKey
                                        bool initiating) const;
 };
 
+CKey GenerateRandomKey(bool compressed = true) noexcept;
+
 struct CExtKey {
     unsigned char nDepth;
     unsigned char vchFingerprint[4];

src/net.cpp

@@ -21,6 +21,7 @@
 #include <node/eviction.h>
 #include <fs.h>
 #include <i2p.h>
+#include <key.h>
 #include <memusage.h>
 #include <net_permissions.h>
 #include <netaddress.h>
@@ -1057,13 +1058,6 @@ class V2MessageMap
 
 const V2MessageMap V2_MESSAGE_MAP;
 
-CKey GenerateRandomKey() noexcept
-{
-    CKey key;
-    key.MakeNewKey(/*fCompressed=*/true);
-    return key;
-}
-
 std::vector<uint8_t> GenerateRandomGarbage() noexcept
 {
     std::vector<uint8_t> ret;

src/policy/feerate.h

@@ -70,6 +70,8 @@ class CFeeRate
     friend bool operator!=(const CFeeRate& a, const CFeeRate& b) { return a.nSatoshisPerK != b.nSatoshisPerK; }
     CFeeRate& operator+=(const CFeeRate& a) { nSatoshisPerK += a.nSatoshisPerK; return *this; }
     std::string ToString(const FeeEstimateMode& fee_estimate_mode = FeeEstimateMode::DASH_KB) const;
+    friend CFeeRate operator*(const CFeeRate& f, int a) { return CFeeRate(a * f.nSatoshisPerK); }
+    friend CFeeRate operator*(int a, const CFeeRate& f) { return CFeeRate(a * f.nSatoshisPerK); }
 
     SERIALIZE_METHODS(CFeeRate, obj) { READWRITE(obj.nSatoshisPerK); }
 };

src/qt/test/addressbooktests.cpp

@@ -81,8 +81,7 @@ void TestAddAddressesToSendBook(interfaces::Node& node)
     }
 
     auto build_address = [wallet]() {
-        CKey key;
-        key.MakeNewKey(true);
+        CKey key = GenerateRandomKey();
         CTxDestination dest = PKHash(key.GetPubKey());
 
         return std::make_pair(dest, QString::fromStdString(EncodeDestination(dest)));

src/serialize.h

@@ -213,9 +213,9 @@ template<typename Stream> inline void Serialize(Stream& s, int32_t a ) { ser_wri
 template<typename Stream> inline void Serialize(Stream& s, uint32_t a) { ser_writedata32(s, a); }
 template<typename Stream> inline void Serialize(Stream& s, int64_t a ) { ser_writedata64(s, a); }
 template<typename Stream> inline void Serialize(Stream& s, uint64_t a) { ser_writedata64(s, a); }
-template<typename Stream, int N> inline void Serialize(Stream& s, const char (&a)[N]) { s.write(MakeByteSpan(a)); }
-template<typename Stream, int N> inline void Serialize(Stream& s, const unsigned char (&a)[N]) { s.write(MakeByteSpan(a)); }
-template <typename Stream, typename B> void Serialize(Stream& s, Span<B> span) { (void)/* force byte-type */UCharCast(span.data()); s.write(AsBytes(span)); }
+template <typename Stream, BasicByte B, int N> void Serialize(Stream& s, const B (&a)[N]) { s.write(MakeByteSpan(a)); }
+template <typename Stream, BasicByte B, std::size_t N> void Serialize(Stream& s, const std::array<B, N>& a) { s.write(MakeByteSpan(a)); }
+template <typename Stream, BasicByte B> void Serialize(Stream& s, Span<B> span) { s.write(AsBytes(span)); }
 
 template <typename Stream, CharNotInt8 V> void Unserialize(Stream&, V) = delete; // char serialization forbidden. Use uint8_t or int8_t
 template <typename Stream> void Unserialize(Stream& s, std::byte& a) { a = std::byte{ser_readdata8(s)}; }
@@ -227,9 +227,9 @@ template<typename Stream> inline void Unserialize(Stream& s, int32_t& a ) { a =
 template<typename Stream> inline void Unserialize(Stream& s, uint32_t& a) { a = ser_readdata32(s); }
 template<typename Stream> inline void Unserialize(Stream& s, int64_t& a ) { a = ser_readdata64(s); }
 template<typename Stream> inline void Unserialize(Stream& s, uint64_t& a) { a = ser_readdata64(s); }
-template<typename Stream, int N> inline void Unserialize(Stream& s, char (&a)[N]) { s.read(MakeWritableByteSpan(a)); }
-template<typename Stream, int N> inline void Unserialize(Stream& s, unsigned char (&a)[N]) { s.read(MakeWritableByteSpan(a)); }
-template <typename Stream, typename B> void Unserialize(Stream& s, Span<B> span) { (void)/* force byte-type */UCharCast(span.data()); s.read(AsWritableBytes(span)); }
+template <typename Stream, BasicByte B, int N> void Unserialize(Stream& s, B (&a)[N]) { s.read(MakeWritableByteSpan(a)); }
+template <typename Stream, BasicByte B, std::size_t N> void Unserialize(Stream& s, std::array<B, N>& a) { s.read(MakeWritableByteSpan(a)); }
+template <typename Stream, BasicByte B> void Unserialize(Stream& s, Span<B> span) { s.read(AsWritableBytes(span)); }
 
 template <typename Stream> inline void Serialize(Stream& s, bool a) { uint8_t f = a; ser_writedata8(s, f); }
 template <typename Stream> inline void Unserialize(Stream& s, bool& a) { uint8_t f = ser_readdata8(s); a = f; }
@@ -886,18 +886,23 @@ template<typename Stream, typename T> void Serialize(Stream& os, const std::atom
 template<typename Stream, typename T> void Unserialize(Stream& is, std::atomic<T>& a);
 
 
-
 /**
  * If none of the specialized versions above matched and T is a class, default to calling member function.
  */
-template<typename Stream, typename T, typename std::enable_if<std::is_class<T>::value>::type* = nullptr>
-inline void Serialize(Stream& os, const T& a)
+template <class T, class Stream, typename std::enable_if<std::is_class<T>::value>::type* = nullptr >
+concept Serializable = requires(T a, Stream s) { a.Serialize(s); };
+template <typename Stream, typename T>
+    requires Serializable<T, Stream>
+void Serialize(Stream& os, const T& a)
 {
     a.Serialize(os);
 }
 
-template<typename Stream, typename T, typename std::enable_if<std::is_class<std::remove_reference<T> >::value>::type* = nullptr>
-inline void Unserialize(Stream& is, T&& a)
+template <class T, class Stream, typename std::enable_if<std::is_class<std::remove_reference<T> >::value>::type* = nullptr>
+concept Unserializable = requires(T a, Stream s) { a.Unserialize(s); };
+template <typename Stream, typename T>
+    requires Unserializable<T, Stream>
+void Unserialize(Stream& is, T&& a)
 {
     a.Unserialize(is);
 }