From cba69dda3da0e4fa39cff5ce4dc81d1242fe651b Mon Sep 17 00:00:00 2001
From: Anthony Towns <aj@erisian.com.au>
Date: Tue, 11 Oct 2022 14:20:22 +1000
Subject: [PATCH 1/9] Move MANDATORY_SCRIPT_VERIFY_FLAGS from script/standard.h
 to policy/policy.h

---
 src/policy/policy.h   | 16 ++++++++++++++--
 src/script/standard.h | 10 ----------
 2 files changed, 14 insertions(+), 12 deletions(-)

diff --git a/src/policy/policy.h b/src/policy/policy.h
index 9135cae91c1..657ee8b32df 100644
--- a/src/policy/policy.h
+++ b/src/policy/policy.h
@@ -69,10 +69,22 @@ static constexpr unsigned int DEFAULT_DESCENDANT_SIZE_LIMIT_KVB{101};
  * configurable as it doesn't materially change DoS parameters.
  */
 static constexpr unsigned int EXTRA_DESCENDANT_TX_SIZE_LIMIT{10000};
+
+
+/**
+ * Mandatory script verification flags that all new transactions must comply with for
+ * them to be valid. Failing one of these tests may trigger a DoS ban;
+ * see CheckInputScripts() for details.
+ *
+ * Note that this does not affect consensus validity; see GetBlockScriptFlags()
+ * for that.
+ */
+static const unsigned int MANDATORY_SCRIPT_VERIFY_FLAGS = SCRIPT_VERIFY_P2SH;
+
 /**
  * Standard script verification flags that standard transactions will comply
- * with. However scripts violating these flags may still be present in valid
- * blocks and we must accept those blocks.
+ * with. However we do not ban/disconnect nodes that forward txs violating
+ * these rules, for better forwards and backwards compatability.
  */
 static constexpr unsigned int STANDARD_SCRIPT_VERIFY_FLAGS{MANDATORY_SCRIPT_VERIFY_FLAGS |
                                                              SCRIPT_VERIFY_DERSIG |
diff --git a/src/script/standard.h b/src/script/standard.h
index 18cf5c8c884..54065f6e302 100644
--- a/src/script/standard.h
+++ b/src/script/standard.h
@@ -38,16 +38,6 @@ public:
  */
 static const unsigned int MAX_OP_RETURN_RELAY = 83;
 
-/**
- * Mandatory script verification flags that all new blocks must comply with for
- * them to be valid. (but old blocks may not comply with) Currently just P2SH,
- * but in the future other flags may be added.
- *
- * Failing one of these tests may trigger a DoS ban - see CheckInputScripts() for
- * details.
- */
-static const unsigned int MANDATORY_SCRIPT_VERIFY_FLAGS = SCRIPT_VERIFY_P2SH;
-
 enum class TxoutType {
     NONSTANDARD,
     // 'standard' transaction types:

From b81ebff0d99c45c071b999796b8ae3f0f2517b22 Mon Sep 17 00:00:00 2001
From: Andrew Chow <github@achow101.com>
Date: Tue, 8 Aug 2023 10:35:08 -0400
Subject: [PATCH 2/9] Remove ScriptHash from CScriptID constructor

Replaces the constructor in CScriptID that converts a ScriptHash with a
function ToScriptID that does the same. This prepares for a move of
CScriptID to avoid a circular dependency.
---
 src/script/signingprovider.cpp | 2 +-
 src/script/standard.cpp        | 6 +++++-
 src/script/standard.h          | 3 +--
 src/wallet/rpc/addresses.cpp   | 3 +--
 src/wallet/rpc/coins.cpp       | 2 +-
 5 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/src/script/signingprovider.cpp b/src/script/signingprovider.cpp
index ef055573b97..fb5ae79c19f 100644
--- a/src/script/signingprovider.cpp
+++ b/src/script/signingprovider.cpp
@@ -205,7 +205,7 @@ CKeyID GetKeyForDestination(const SigningProvider& store, const CTxDestination&
     }
     if (auto script_hash = std::get_if<ScriptHash>(&dest)) {
         CScript script;
-        CScriptID script_id(*script_hash);
+        CScriptID script_id = ToScriptID(*script_hash);
         CTxDestination inner_dest;
         if (store.GetCScript(script_id, script) && ExtractDestination(script, inner_dest)) {
             if (auto inner_witness_id = std::get_if<WitnessV0KeyHash>(&inner_dest)) {
diff --git a/src/script/standard.cpp b/src/script/standard.cpp
index 7c4a05b6e69..e13784e0fc3 100644
--- a/src/script/standard.cpp
+++ b/src/script/standard.cpp
@@ -17,7 +17,6 @@
 typedef std::vector<unsigned char> valtype;
 
 CScriptID::CScriptID(const CScript& in) : BaseHash(Hash160(in)) {}
-CScriptID::CScriptID(const ScriptHash& in) : BaseHash(static_cast<uint160>(in)) {}
 
 ScriptHash::ScriptHash(const CScript& in) : BaseHash(Hash160(in)) {}
 ScriptHash::ScriptHash(const CScriptID& in) : BaseHash(static_cast<uint160>(in)) {}
@@ -38,6 +37,11 @@ CKeyID ToKeyID(const WitnessV0KeyHash& key_hash)
     return CKeyID{static_cast<uint160>(key_hash)};
 }
 
+CScriptID ToScriptID(const ScriptHash& script_hash)
+{
+    return CScriptID{static_cast<uint160>(script_hash)};
+}
+
 WitnessV0ScriptHash::WitnessV0ScriptHash(const CScript& in)
 {
     CSHA256().Write(in.data(), in.size()).Finalize(begin());
diff --git a/src/script/standard.h b/src/script/standard.h
index 54065f6e302..3e60ea453db 100644
--- a/src/script/standard.h
+++ b/src/script/standard.h
@@ -20,7 +20,6 @@ static const bool DEFAULT_ACCEPT_DATACARRIER = true;
 
 class CKeyID;
 class CScript;
-struct ScriptHash;
 
 /** A reference to a CScript: the Hash160 of its serialization (see script.h) */
 class CScriptID : public BaseHash<uint160>
@@ -29,7 +28,6 @@ public:
     CScriptID() : BaseHash() {}
     explicit CScriptID(const CScript& in);
     explicit CScriptID(const uint160& in) : BaseHash(in) {}
-    explicit CScriptID(const ScriptHash& in);
 };
 
 /**
@@ -80,6 +78,7 @@ struct ScriptHash : public BaseHash<uint160>
     explicit ScriptHash(const CScript& script);
     explicit ScriptHash(const CScriptID& script);
 };
+CScriptID ToScriptID(const ScriptHash& script_hash);
 
 struct WitnessV0ScriptHash : public BaseHash<uint256>
 {
diff --git a/src/wallet/rpc/addresses.cpp b/src/wallet/rpc/addresses.cpp
index a8ef0a5731f..06f396a6d7c 100644
--- a/src/wallet/rpc/addresses.cpp
+++ b/src/wallet/rpc/addresses.cpp
@@ -440,10 +440,9 @@ public:
 
     UniValue operator()(const ScriptHash& scripthash) const
     {
-        CScriptID scriptID(scripthash);
         UniValue obj(UniValue::VOBJ);
         CScript subscript;
-        if (provider && provider->GetCScript(scriptID, subscript)) {
+        if (provider && provider->GetCScript(ToScriptID(scripthash), subscript)) {
             ProcessSubScript(subscript, obj);
         }
         return obj;
diff --git a/src/wallet/rpc/coins.cpp b/src/wallet/rpc/coins.cpp
index 22f0f0b83c5..521378e188c 100644
--- a/src/wallet/rpc/coins.cpp
+++ b/src/wallet/rpc/coins.cpp
@@ -672,7 +672,7 @@ RPCHelpMan listunspent()
             std::unique_ptr<SigningProvider> provider = pwallet->GetSolvingProvider(scriptPubKey);
             if (provider) {
                 if (scriptPubKey.IsPayToScriptHash()) {
-                    const CScriptID& hash = CScriptID(std::get<ScriptHash>(address));
+                    const CScriptID hash = ToScriptID(std::get<ScriptHash>(address));
                     CScript redeemScript;
                     if (provider->GetCScript(hash, redeemScript)) {
                         entry.pushKV("redeemScript", HexStr(redeemScript));

From 86ea8bed5473f400f7a93fcc455393a574a2f319 Mon Sep 17 00:00:00 2001
From: Andrew Chow <github@achow101.com>
Date: Tue, 8 Aug 2023 10:39:01 -0400
Subject: [PATCH 3/9] Move CScriptID to script.{h/cpp}

CScriptID should be next to CScript just as CKeyID is next to CPubKey
---
 src/compressor.cpp             |  1 +
 src/interfaces/wallet.h        |  1 +
 src/script/script.cpp          |  3 +++
 src/script/script.h            | 11 +++++++++++
 src/script/sign.cpp            |  1 +
 src/script/standard.cpp        |  2 --
 src/script/standard.h          |  9 ---------
 src/test/compress_tests.cpp    |  1 +
 src/test/fuzz/integer.cpp      |  1 +
 src/wallet/rpc/addresses.cpp   |  1 +
 src/wallet/rpc/coins.cpp       |  1 +
 src/wallet/rpc/spend.cpp       |  1 +
 src/wallet/scriptpubkeyman.cpp |  1 +
 src/wallet/scriptpubkeyman.h   |  1 +
 src/wallet/spend.cpp           |  1 +
 src/wallet/walletdb.cpp        |  1 +
 16 files changed, 26 insertions(+), 11 deletions(-)

diff --git a/src/compressor.cpp b/src/compressor.cpp
index 32af8eab494..2dbd586bfac 100644
--- a/src/compressor.cpp
+++ b/src/compressor.cpp
@@ -6,6 +6,7 @@
 #include <compressor.h>
 
 #include <pubkey.h>
+#include <script/script.h>
 #include <script/standard.h>
 
 /*
diff --git a/src/interfaces/wallet.h b/src/interfaces/wallet.h
index 8c31112fc94..9d8bebb406a 100644
--- a/src/interfaces/wallet.h
+++ b/src/interfaces/wallet.h
@@ -8,6 +8,7 @@
 #include <consensus/amount.h>
 #include <interfaces/chain.h>          // For ChainClient
 #include <pubkey.h>                    // For CKeyID and CScriptID (definitions needed in CTxDestination instantiation)
+#include <script/script.h>
 #include <script/standard.h>           // For CTxDestination
 #include <support/allocators/secure.h> // For SecureString
 #include <util/fs.h>
diff --git a/src/script/script.cpp b/src/script/script.cpp
index 79d19b90853..1594d3cc793 100644
--- a/src/script/script.cpp
+++ b/src/script/script.cpp
@@ -5,10 +5,13 @@
 
 #include <script/script.h>
 
+#include <hash.h>
 #include <util/strencodings.h>
 
 #include <string>
 
+CScriptID::CScriptID(const CScript& in) : BaseHash(Hash160(in)) {}
+
 std::string GetOpName(opcodetype opcode)
 {
     switch (opcode)
diff --git a/src/script/script.h b/src/script/script.h
index 374ae1642e9..902f756afcf 100644
--- a/src/script/script.h
+++ b/src/script/script.h
@@ -10,6 +10,8 @@
 #include <crypto/common.h>
 #include <prevector.h>
 #include <serialize.h>
+#include <uint256.h>
+#include <util/hash_type.h>
 
 #include <assert.h>
 #include <climits>
@@ -575,6 +577,15 @@ struct CScriptWitness
     std::string ToString() const;
 };
 
+/** A reference to a CScript: the Hash160 of its serialization */
+class CScriptID : public BaseHash<uint160>
+{
+public:
+    CScriptID() : BaseHash() {}
+    explicit CScriptID(const CScript& in);
+    explicit CScriptID(const uint160& in) : BaseHash(in) {}
+};
+
 /** Test for OP_SUCCESSx opcodes as defined by BIP342. */
 bool IsOpSuccess(const opcodetype& opcode);
 
diff --git a/src/script/sign.cpp b/src/script/sign.cpp
index 85589fe86b9..c28773ed0eb 100644
--- a/src/script/sign.cpp
+++ b/src/script/sign.cpp
@@ -11,6 +11,7 @@
 #include <primitives/transaction.h>
 #include <script/keyorigin.h>
 #include <script/miniscript.h>
+#include <script/script.h>
 #include <script/signingprovider.h>
 #include <script/standard.h>
 #include <uint256.h>
diff --git a/src/script/standard.cpp b/src/script/standard.cpp
index e13784e0fc3..6f5145a74bb 100644
--- a/src/script/standard.cpp
+++ b/src/script/standard.cpp
@@ -16,8 +16,6 @@
 
 typedef std::vector<unsigned char> valtype;
 
-CScriptID::CScriptID(const CScript& in) : BaseHash(Hash160(in)) {}
-
 ScriptHash::ScriptHash(const CScript& in) : BaseHash(Hash160(in)) {}
 ScriptHash::ScriptHash(const CScriptID& in) : BaseHash(static_cast<uint160>(in)) {}
 
diff --git a/src/script/standard.h b/src/script/standard.h
index 3e60ea453db..8a76606082a 100644
--- a/src/script/standard.h
+++ b/src/script/standard.h
@@ -21,15 +21,6 @@ static const bool DEFAULT_ACCEPT_DATACARRIER = true;
 class CKeyID;
 class CScript;
 
-/** A reference to a CScript: the Hash160 of its serialization (see script.h) */
-class CScriptID : public BaseHash<uint160>
-{
-public:
-    CScriptID() : BaseHash() {}
-    explicit CScriptID(const CScript& in);
-    explicit CScriptID(const uint160& in) : BaseHash(in) {}
-};
-
 /**
  * Default setting for -datacarriersize. 80 bytes of data, +1 for OP_RETURN,
  * +2 for the pushdata opcodes.
diff --git a/src/test/compress_tests.cpp b/src/test/compress_tests.cpp
index de99b91c7f2..bf9aba1868c 100644
--- a/src/test/compress_tests.cpp
+++ b/src/test/compress_tests.cpp
@@ -3,6 +3,7 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <compressor.h>
+#include <script/script.h>
 #include <script/standard.h>
 #include <test/util/setup_common.h>
 
diff --git a/src/test/fuzz/integer.cpp b/src/test/fuzz/integer.cpp
index 91521bc7f43..54f968c53cb 100644
--- a/src/test/fuzz/integer.cpp
+++ b/src/test/fuzz/integer.cpp
@@ -19,6 +19,7 @@
 #include <pow.h>
 #include <protocol.h>
 #include <pubkey.h>
+#include <script/script.h>
 #include <script/standard.h>
 #include <serialize.h>
 #include <streams.h>
diff --git a/src/wallet/rpc/addresses.cpp b/src/wallet/rpc/addresses.cpp
index 06f396a6d7c..dbd5c605118 100644
--- a/src/wallet/rpc/addresses.cpp
+++ b/src/wallet/rpc/addresses.cpp
@@ -5,6 +5,7 @@
 #include <core_io.h>
 #include <key_io.h>
 #include <rpc/util.h>
+#include <script/script.h>
 #include <util/bip32.h>
 #include <util/translation.h>
 #include <wallet/receive.h>
diff --git a/src/wallet/rpc/coins.cpp b/src/wallet/rpc/coins.cpp
index 521378e188c..6f0623cdf5e 100644
--- a/src/wallet/rpc/coins.cpp
+++ b/src/wallet/rpc/coins.cpp
@@ -6,6 +6,7 @@
 #include <hash.h>
 #include <key_io.h>
 #include <rpc/util.h>
+#include <script/script.h>
 #include <util/moneystr.h>
 #include <wallet/coincontrol.h>
 #include <wallet/receive.h>
diff --git a/src/wallet/rpc/spend.cpp b/src/wallet/rpc/spend.cpp
index b695d4bed35..0e3f10dc761 100644
--- a/src/wallet/rpc/spend.cpp
+++ b/src/wallet/rpc/spend.cpp
@@ -8,6 +8,7 @@
 #include <policy/policy.h>
 #include <rpc/rawtransaction_util.h>
 #include <rpc/util.h>
+#include <script/script.h>
 #include <util/fees.h>
 #include <util/rbf.h>
 #include <util/translation.h>
diff --git a/src/wallet/scriptpubkeyman.cpp b/src/wallet/scriptpubkeyman.cpp
index 5b110b4d149..284bd531be8 100644
--- a/src/wallet/scriptpubkeyman.cpp
+++ b/src/wallet/scriptpubkeyman.cpp
@@ -7,6 +7,7 @@
 #include <logging.h>
 #include <outputtype.h>
 #include <script/descriptor.h>
+#include <script/script.h>
 #include <script/sign.h>
 #include <util/bip32.h>
 #include <util/strencodings.h>
diff --git a/src/wallet/scriptpubkeyman.h b/src/wallet/scriptpubkeyman.h
index bf35c776ae1..00159abbef2 100644
--- a/src/wallet/scriptpubkeyman.h
+++ b/src/wallet/scriptpubkeyman.h
@@ -8,6 +8,7 @@
 #include <logging.h>
 #include <psbt.h>
 #include <script/descriptor.h>
+#include <script/script.h>
 #include <script/signingprovider.h>
 #include <script/standard.h>
 #include <util/error.h>
diff --git a/src/wallet/spend.cpp b/src/wallet/spend.cpp
index a3728223fbe..9358bbeebe9 100644
--- a/src/wallet/spend.cpp
+++ b/src/wallet/spend.cpp
@@ -11,6 +11,7 @@
 #include <numeric>
 #include <policy/policy.h>
 #include <primitives/transaction.h>
+#include <script/script.h>
 #include <script/signingprovider.h>
 #include <util/check.h>
 #include <util/fees.h>
diff --git a/src/wallet/walletdb.cpp b/src/wallet/walletdb.cpp
index 8212c044649..92eca46f051 100644
--- a/src/wallet/walletdb.cpp
+++ b/src/wallet/walletdb.cpp
@@ -8,6 +8,7 @@
 #include <common/system.h>
 #include <key_io.h>
 #include <protocol.h>
+#include <script/script.h>
 #include <serialize.h>
 #include <sync.h>
 #include <util/bip32.h>

From 145f36ec81e79d2e391847520364c2420ef0e0e8 Mon Sep 17 00:00:00 2001
From: Andrew Chow <github@achow101.com>
Date: Tue, 8 Aug 2023 10:45:06 -0400
Subject: [PATCH 4/9] Move Taproot{SpendData/Builder} to
 signingprovider.{h/cpp}

TaprootSpendData and TaprootBuilder are used in signing in
SigningProvider contexts, so they should live near that.
---
 src/psbt.cpp                     |   1 +
 src/script/descriptor.cpp        |   1 +
 src/script/sign.h                |   1 +
 src/script/signingprovider.cpp   | 295 +++++++++++++++++++++++++++++++
 src/script/signingprovider.h     | 132 ++++++++++++++
 src/script/standard.cpp          | 295 -------------------------------
 src/script/standard.h            | 132 --------------
 src/wallet/test/ismine_tests.cpp |   1 +
 8 files changed, 431 insertions(+), 427 deletions(-)

diff --git a/src/psbt.cpp b/src/psbt.cpp
index 009ed966ed3..7ec9b9c136a 100644
--- a/src/psbt.cpp
+++ b/src/psbt.cpp
@@ -5,6 +5,7 @@
 #include <psbt.h>
 
 #include <policy/policy.h>
+#include <script/signingprovider.h>
 #include <util/check.h>
 #include <util/strencodings.h>
 
diff --git a/src/script/descriptor.cpp b/src/script/descriptor.cpp
index 09ded5fc613..3d8497ef19d 100644
--- a/src/script/descriptor.cpp
+++ b/src/script/descriptor.cpp
@@ -9,6 +9,7 @@
 #include <pubkey.h>
 #include <script/miniscript.h>
 #include <script/script.h>
+#include <script/signingprovider.h>
 #include <script/standard.h>
 #include <uint256.h>
 
diff --git a/src/script/sign.h b/src/script/sign.h
index f46bc559928..b8806876a21 100644
--- a/src/script/sign.h
+++ b/src/script/sign.h
@@ -13,6 +13,7 @@
 #include <script/interpreter.h>
 #include <script/keyorigin.h>
 #include <script/standard.h>
+#include <script/signingprovider.h>
 #include <uint256.h>
 
 class CKey;
diff --git a/src/script/signingprovider.cpp b/src/script/signingprovider.cpp
index fb5ae79c19f..248305c82ea 100644
--- a/src/script/signingprovider.cpp
+++ b/src/script/signingprovider.cpp
@@ -4,6 +4,7 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <script/keyorigin.h>
+#include <script/interpreter.h>
 #include <script/signingprovider.h>
 #include <script/standard.h>
 
@@ -225,3 +226,297 @@ CKeyID GetKeyForDestination(const SigningProvider& store, const CTxDestination&
     }
     return CKeyID();
 }
+/*static*/ TaprootBuilder::NodeInfo TaprootBuilder::Combine(NodeInfo&& a, NodeInfo&& b)
+{
+    NodeInfo ret;
+    /* Iterate over all tracked leaves in a, add b's hash to their Merkle branch, and move them to ret. */
+    for (auto& leaf : a.leaves) {
+        leaf.merkle_branch.push_back(b.hash);
+        ret.leaves.emplace_back(std::move(leaf));
+    }
+    /* Iterate over all tracked leaves in b, add a's hash to their Merkle branch, and move them to ret. */
+    for (auto& leaf : b.leaves) {
+        leaf.merkle_branch.push_back(a.hash);
+        ret.leaves.emplace_back(std::move(leaf));
+    }
+    ret.hash = ComputeTapbranchHash(a.hash, b.hash);
+    return ret;
+}
+
+void TaprootSpendData::Merge(TaprootSpendData other)
+{
+    // TODO: figure out how to better deal with conflicting information
+    // being merged.
+    if (internal_key.IsNull() && !other.internal_key.IsNull()) {
+        internal_key = other.internal_key;
+    }
+    if (merkle_root.IsNull() && !other.merkle_root.IsNull()) {
+        merkle_root = other.merkle_root;
+    }
+    for (auto& [key, control_blocks] : other.scripts) {
+        scripts[key].merge(std::move(control_blocks));
+    }
+}
+
+void TaprootBuilder::Insert(TaprootBuilder::NodeInfo&& node, int depth)
+{
+    assert(depth >= 0 && (size_t)depth <= TAPROOT_CONTROL_MAX_NODE_COUNT);
+    /* We cannot insert a leaf at a lower depth while a deeper branch is unfinished. Doing
+     * so would mean the Add() invocations do not correspond to a DFS traversal of a
+     * binary tree. */
+    if ((size_t)depth + 1 < m_branch.size()) {
+        m_valid = false;
+        return;
+    }
+    /* As long as an entry in the branch exists at the specified depth, combine it and propagate up.
+     * The 'node' variable is overwritten here with the newly combined node. */
+    while (m_valid && m_branch.size() > (size_t)depth && m_branch[depth].has_value()) {
+        node = Combine(std::move(node), std::move(*m_branch[depth]));
+        m_branch.pop_back();
+        if (depth == 0) m_valid = false; /* Can't propagate further up than the root */
+        --depth;
+    }
+    if (m_valid) {
+        /* Make sure the branch is big enough to place the new node. */
+        if (m_branch.size() <= (size_t)depth) m_branch.resize((size_t)depth + 1);
+        assert(!m_branch[depth].has_value());
+        m_branch[depth] = std::move(node);
+    }
+}
+
+/*static*/ bool TaprootBuilder::ValidDepths(const std::vector<int>& depths)
+{
+    std::vector<bool> branch;
+    for (int depth : depths) {
+        // This inner loop corresponds to effectively the same logic on branch
+        // as what Insert() performs on the m_branch variable. Instead of
+        // storing a NodeInfo object, just remember whether or not there is one
+        // at that depth.
+        if (depth < 0 || (size_t)depth > TAPROOT_CONTROL_MAX_NODE_COUNT) return false;
+        if ((size_t)depth + 1 < branch.size()) return false;
+        while (branch.size() > (size_t)depth && branch[depth]) {
+            branch.pop_back();
+            if (depth == 0) return false;
+            --depth;
+        }
+        if (branch.size() <= (size_t)depth) branch.resize((size_t)depth + 1);
+        assert(!branch[depth]);
+        branch[depth] = true;
+    }
+    // And this check corresponds to the IsComplete() check on m_branch.
+    return branch.size() == 0 || (branch.size() == 1 && branch[0]);
+}
+
+TaprootBuilder& TaprootBuilder::Add(int depth, Span<const unsigned char> script, int leaf_version, bool track)
+{
+    assert((leaf_version & ~TAPROOT_LEAF_MASK) == 0);
+    if (!IsValid()) return *this;
+    /* Construct NodeInfo object with leaf hash and (if track is true) also leaf information. */
+    NodeInfo node;
+    node.hash = ComputeTapleafHash(leaf_version, script);
+    if (track) node.leaves.emplace_back(LeafInfo{std::vector<unsigned char>(script.begin(), script.end()), leaf_version, {}});
+    /* Insert into the branch. */
+    Insert(std::move(node), depth);
+    return *this;
+}
+
+TaprootBuilder& TaprootBuilder::AddOmitted(int depth, const uint256& hash)
+{
+    if (!IsValid()) return *this;
+    /* Construct NodeInfo object with the hash directly, and insert it into the branch. */
+    NodeInfo node;
+    node.hash = hash;
+    Insert(std::move(node), depth);
+    return *this;
+}
+
+TaprootBuilder& TaprootBuilder::Finalize(const XOnlyPubKey& internal_key)
+{
+    /* Can only call this function when IsComplete() is true. */
+    assert(IsComplete());
+    m_internal_key = internal_key;
+    auto ret = m_internal_key.CreateTapTweak(m_branch.size() == 0 ? nullptr : &m_branch[0]->hash);
+    assert(ret.has_value());
+    std::tie(m_output_key, m_parity) = *ret;
+    return *this;
+}
+
+WitnessV1Taproot TaprootBuilder::GetOutput() { return WitnessV1Taproot{m_output_key}; }
+
+TaprootSpendData TaprootBuilder::GetSpendData() const
+{
+    assert(IsComplete());
+    assert(m_output_key.IsFullyValid());
+    TaprootSpendData spd;
+    spd.merkle_root = m_branch.size() == 0 ? uint256() : m_branch[0]->hash;
+    spd.internal_key = m_internal_key;
+    if (m_branch.size()) {
+        // If any script paths exist, they have been combined into the root m_branch[0]
+        // by now. Compute the control block for each of its tracked leaves, and put them in
+        // spd.scripts.
+        for (const auto& leaf : m_branch[0]->leaves) {
+            std::vector<unsigned char> control_block;
+            control_block.resize(TAPROOT_CONTROL_BASE_SIZE + TAPROOT_CONTROL_NODE_SIZE * leaf.merkle_branch.size());
+            control_block[0] = leaf.leaf_version | (m_parity ? 1 : 0);
+            std::copy(m_internal_key.begin(), m_internal_key.end(), control_block.begin() + 1);
+            if (leaf.merkle_branch.size()) {
+                std::copy(leaf.merkle_branch[0].begin(),
+                          leaf.merkle_branch[0].begin() + TAPROOT_CONTROL_NODE_SIZE * leaf.merkle_branch.size(),
+                          control_block.begin() + TAPROOT_CONTROL_BASE_SIZE);
+            }
+            spd.scripts[{leaf.script, leaf.leaf_version}].insert(std::move(control_block));
+        }
+    }
+    return spd;
+}
+
+std::optional<std::vector<std::tuple<int, std::vector<unsigned char>, int>>> InferTaprootTree(const TaprootSpendData& spenddata, const XOnlyPubKey& output)
+{
+    // Verify that the output matches the assumed Merkle root and internal key.
+    auto tweak = spenddata.internal_key.CreateTapTweak(spenddata.merkle_root.IsNull() ? nullptr : &spenddata.merkle_root);
+    if (!tweak || tweak->first != output) return std::nullopt;
+    // If the Merkle root is 0, the tree is empty, and we're done.
+    std::vector<std::tuple<int, std::vector<unsigned char>, int>> ret;
+    if (spenddata.merkle_root.IsNull()) return ret;
+
+    /** Data structure to represent the nodes of the tree we're going to build. */
+    struct TreeNode {
+        /** Hash of this node, if known; 0 otherwise. */
+        uint256 hash;
+        /** The left and right subtrees (note that their order is irrelevant). */
+        std::unique_ptr<TreeNode> sub[2];
+        /** If this is known to be a leaf node, a pointer to the (script, leaf_ver) pair.
+         *  nullptr otherwise. */
+        const std::pair<std::vector<unsigned char>, int>* leaf = nullptr;
+        /** Whether or not this node has been explored (is known to be a leaf, or known to have children). */
+        bool explored = false;
+        /** Whether or not this node is an inner node (unknown until explored = true). */
+        bool inner;
+        /** Whether or not we have produced output for this subtree. */
+        bool done = false;
+    };
+
+    // Build tree from the provided branches.
+    TreeNode root;
+    root.hash = spenddata.merkle_root;
+    for (const auto& [key, control_blocks] : spenddata.scripts) {
+        const auto& [script, leaf_ver] = key;
+        for (const auto& control : control_blocks) {
+            // Skip script records with nonsensical leaf version.
+            if (leaf_ver < 0 || leaf_ver >= 0x100 || leaf_ver & 1) continue;
+            // Skip script records with invalid control block sizes.
+            if (control.size() < TAPROOT_CONTROL_BASE_SIZE || control.size() > TAPROOT_CONTROL_MAX_SIZE ||
+                ((control.size() - TAPROOT_CONTROL_BASE_SIZE) % TAPROOT_CONTROL_NODE_SIZE) != 0) continue;
+            // Skip script records that don't match the control block.
+            if ((control[0] & TAPROOT_LEAF_MASK) != leaf_ver) continue;
+            // Skip script records that don't match the provided Merkle root.
+            const uint256 leaf_hash = ComputeTapleafHash(leaf_ver, script);
+            const uint256 merkle_root = ComputeTaprootMerkleRoot(control, leaf_hash);
+            if (merkle_root != spenddata.merkle_root) continue;
+
+            TreeNode* node = &root;
+            size_t levels = (control.size() - TAPROOT_CONTROL_BASE_SIZE) / TAPROOT_CONTROL_NODE_SIZE;
+            for (size_t depth = 0; depth < levels; ++depth) {
+                // Can't descend into a node which we already know is a leaf.
+                if (node->explored && !node->inner) return std::nullopt;
+
+                // Extract partner hash from Merkle branch in control block.
+                uint256 hash;
+                std::copy(control.begin() + TAPROOT_CONTROL_BASE_SIZE + (levels - 1 - depth) * TAPROOT_CONTROL_NODE_SIZE,
+                          control.begin() + TAPROOT_CONTROL_BASE_SIZE + (levels - depth) * TAPROOT_CONTROL_NODE_SIZE,
+                          hash.begin());
+
+                if (node->sub[0]) {
+                    // Descend into the existing left or right branch.
+                    bool desc = false;
+                    for (int i = 0; i < 2; ++i) {
+                        if (node->sub[i]->hash == hash || (node->sub[i]->hash.IsNull() && node->sub[1-i]->hash != hash)) {
+                            node->sub[i]->hash = hash;
+                            node = &*node->sub[1-i];
+                            desc = true;
+                            break;
+                        }
+                    }
+                    if (!desc) return std::nullopt; // This probably requires a hash collision to hit.
+                } else {
+                    // We're in an unexplored node. Create subtrees and descend.
+                    node->explored = true;
+                    node->inner = true;
+                    node->sub[0] = std::make_unique<TreeNode>();
+                    node->sub[1] = std::make_unique<TreeNode>();
+                    node->sub[1]->hash = hash;
+                    node = &*node->sub[0];
+                }
+            }
+            // Cannot turn a known inner node into a leaf.
+            if (node->sub[0]) return std::nullopt;
+            node->explored = true;
+            node->inner = false;
+            node->leaf = &key;
+            node->hash = leaf_hash;
+        }
+    }
+
+    // Recursive processing to turn the tree into flattened output. Use an explicit stack here to avoid
+    // overflowing the call stack (the tree may be 128 levels deep).
+    std::vector<TreeNode*> stack{&root};
+    while (!stack.empty()) {
+        TreeNode& node = *stack.back();
+        if (!node.explored) {
+            // Unexplored node, which means the tree is incomplete.
+            return std::nullopt;
+        } else if (!node.inner) {
+            // Leaf node; produce output.
+            ret.emplace_back(stack.size() - 1, node.leaf->first, node.leaf->second);
+            node.done = true;
+            stack.pop_back();
+        } else if (node.sub[0]->done && !node.sub[1]->done && !node.sub[1]->explored && !node.sub[1]->hash.IsNull() &&
+                   ComputeTapbranchHash(node.sub[1]->hash, node.sub[1]->hash) == node.hash) {
+            // Whenever there are nodes with two identical subtrees under it, we run into a problem:
+            // the control blocks for the leaves underneath those will be identical as well, and thus
+            // they will all be matched to the same path in the tree. The result is that at the location
+            // where the duplicate occurred, the left child will contain a normal tree that can be explored
+            // and processed, but the right one will remain unexplored.
+            //
+            // This situation can be detected, by encountering an inner node with unexplored right subtree
+            // with known hash, and H_TapBranch(hash, hash) is equal to the parent node (this node)'s hash.
+            //
+            // To deal with this, simply process the left tree a second time (set its done flag to false;
+            // noting that the done flag of its children have already been set to false after processing
+            // those). To avoid ending up in an infinite loop, set the done flag of the right (unexplored)
+            // subtree to true.
+            node.sub[0]->done = false;
+            node.sub[1]->done = true;
+        } else if (node.sub[0]->done && node.sub[1]->done) {
+            // An internal node which we're finished with.
+            node.sub[0]->done = false;
+            node.sub[1]->done = false;
+            node.done = true;
+            stack.pop_back();
+        } else if (!node.sub[0]->done) {
+            // An internal node whose left branch hasn't been processed yet. Do so first.
+            stack.push_back(&*node.sub[0]);
+        } else if (!node.sub[1]->done) {
+            // An internal node whose right branch hasn't been processed yet. Do so first.
+            stack.push_back(&*node.sub[1]);
+        }
+    }
+
+    return ret;
+}
+
+std::vector<std::tuple<uint8_t, uint8_t, std::vector<unsigned char>>> TaprootBuilder::GetTreeTuples() const
+{
+    assert(IsComplete());
+    std::vector<std::tuple<uint8_t, uint8_t, std::vector<unsigned char>>> tuples;
+    if (m_branch.size()) {
+        const auto& leaves = m_branch[0]->leaves;
+        for (const auto& leaf : leaves) {
+            assert(leaf.merkle_branch.size() <= TAPROOT_CONTROL_MAX_NODE_COUNT);
+            uint8_t depth = (uint8_t)leaf.merkle_branch.size();
+            uint8_t leaf_ver = (uint8_t)leaf.leaf_version;
+            tuples.push_back(std::make_tuple(depth, leaf_ver, leaf.script));
+        }
+    }
+    return tuples;
+}
diff --git a/src/script/signingprovider.h b/src/script/signingprovider.h
index a5bbcff6a07..26886e0d575 100644
--- a/src/script/signingprovider.h
+++ b/src/script/signingprovider.h
@@ -14,6 +14,138 @@
 #include <script/standard.h>
 #include <sync.h>
 
+struct ShortestVectorFirstComparator
+{
+    bool operator()(const std::vector<unsigned char>& a, const std::vector<unsigned char>& b) const
+    {
+        if (a.size() < b.size()) return true;
+        if (a.size() > b.size()) return false;
+        return a < b;
+    }
+};
+
+struct TaprootSpendData
+{
+    /** The BIP341 internal key. */
+    XOnlyPubKey internal_key;
+    /** The Merkle root of the script tree (0 if no scripts). */
+    uint256 merkle_root;
+    /** Map from (script, leaf_version) to (sets of) control blocks.
+     *  More than one control block for a given script is only possible if it
+     *  appears in multiple branches of the tree. We keep them all so that
+     *  inference can reconstruct the full tree. Within each set, the control
+     *  blocks are sorted by size, so that the signing logic can easily
+     *  prefer the cheapest one. */
+    std::map<std::pair<std::vector<unsigned char>, int>, std::set<std::vector<unsigned char>, ShortestVectorFirstComparator>> scripts;
+    /** Merge other TaprootSpendData (for the same scriptPubKey) into this. */
+    void Merge(TaprootSpendData other);
+};
+
+/** Utility class to construct Taproot outputs from internal key and script tree. */
+class TaprootBuilder
+{
+private:
+    /** Information about a tracked leaf in the Merkle tree. */
+    struct LeafInfo
+    {
+        std::vector<unsigned char> script;   //!< The script.
+        int leaf_version;                    //!< The leaf version for that script.
+        std::vector<uint256> merkle_branch;  //!< The hashing partners above this leaf.
+    };
+
+    /** Information associated with a node in the Merkle tree. */
+    struct NodeInfo
+    {
+        /** Merkle hash of this node. */
+        uint256 hash;
+        /** Tracked leaves underneath this node (either from the node itself, or its children).
+         *  The merkle_branch field of each is the partners to get to *this* node. */
+        std::vector<LeafInfo> leaves;
+    };
+    /** Whether the builder is in a valid state so far. */
+    bool m_valid = true;
+
+    /** The current state of the builder.
+     *
+     * For each level in the tree, one NodeInfo object may be present. m_branch[0]
+     * is information about the root; further values are for deeper subtrees being
+     * explored.
+     *
+     * For every right branch taken to reach the position we're currently
+     * working in, there will be a (non-nullopt) entry in m_branch corresponding
+     * to the left branch at that level.
+     *
+     * For example, imagine this tree:     - N0 -
+     *                                    /      \
+     *                                   N1      N2
+     *                                  /  \    /  \
+     *                                 A    B  C   N3
+     *                                            /  \
+     *                                           D    E
+     *
+     * Initially, m_branch is empty. After processing leaf A, it would become
+     * {nullopt, nullopt, A}. When processing leaf B, an entry at level 2 already
+     * exists, and it would thus be combined with it to produce a level 1 one,
+     * resulting in {nullopt, N1}. Adding C and D takes us to {nullopt, N1, C}
+     * and {nullopt, N1, C, D} respectively. When E is processed, it is combined
+     * with D, and then C, and then N1, to produce the root, resulting in {N0}.
+     *
+     * This structure allows processing with just O(log n) overhead if the leaves
+     * are computed on the fly.
+     *
+     * As an invariant, there can never be nullopt entries at the end. There can
+     * also not be more than 128 entries (as that would mean more than 128 levels
+     * in the tree). The depth of newly added entries will always be at least
+     * equal to the current size of m_branch (otherwise it does not correspond
+     * to a depth-first traversal of a tree). m_branch is only empty if no entries
+     * have ever be processed. m_branch having length 1 corresponds to being done.
+     */
+    std::vector<std::optional<NodeInfo>> m_branch;
+
+    XOnlyPubKey m_internal_key;  //!< The internal key, set when finalizing.
+    XOnlyPubKey m_output_key;    //!< The output key, computed when finalizing.
+    bool m_parity;               //!< The tweak parity, computed when finalizing.
+
+    /** Combine information about a parent Merkle tree node from its child nodes. */
+    static NodeInfo Combine(NodeInfo&& a, NodeInfo&& b);
+    /** Insert information about a node at a certain depth, and propagate information up. */
+    void Insert(NodeInfo&& node, int depth);
+
+public:
+    /** Add a new script at a certain depth in the tree. Add() operations must be called
+     *  in depth-first traversal order of binary tree. If track is true, it will be included in
+     *  the GetSpendData() output. */
+    TaprootBuilder& Add(int depth, Span<const unsigned char> script, int leaf_version, bool track = true);
+    /** Like Add(), but for a Merkle node with a given hash to the tree. */
+    TaprootBuilder& AddOmitted(int depth, const uint256& hash);
+    /** Finalize the construction. Can only be called when IsComplete() is true.
+        internal_key.IsFullyValid() must be true. */
+    TaprootBuilder& Finalize(const XOnlyPubKey& internal_key);
+
+    /** Return true if so far all input was valid. */
+    bool IsValid() const { return m_valid; }
+    /** Return whether there were either no leaves, or the leaves form a Huffman tree. */
+    bool IsComplete() const { return m_valid && (m_branch.size() == 0 || (m_branch.size() == 1 && m_branch[0].has_value())); }
+    /** Compute scriptPubKey (after Finalize()). */
+    WitnessV1Taproot GetOutput();
+    /** Check if a list of depths is legal (will lead to IsComplete()). */
+    static bool ValidDepths(const std::vector<int>& depths);
+    /** Compute spending data (after Finalize()). */
+    TaprootSpendData GetSpendData() const;
+    /** Returns a vector of tuples representing the depth, leaf version, and script */
+    std::vector<std::tuple<uint8_t, uint8_t, std::vector<unsigned char>>> GetTreeTuples() const;
+    /** Returns true if there are any tapscripts */
+    bool HasScripts() const { return !m_branch.empty(); }
+};
+
+/** Given a TaprootSpendData and the output key, reconstruct its script tree.
+ *
+ * If the output doesn't match the spenddata, or if the data in spenddata is incomplete,
+ * std::nullopt is returned. Otherwise, a vector of (depth, script, leaf_ver) tuples is
+ * returned, corresponding to a depth-first traversal of the script tree.
+ */
+std::optional<std::vector<std::tuple<int, std::vector<unsigned char>, int>>> InferTaprootTree(const TaprootSpendData& spenddata, const XOnlyPubKey& output);
+
 /** An interface to be implemented by keystores that support signing. */
 class SigningProvider
 {
diff --git a/src/script/standard.cpp b/src/script/standard.cpp
index 6f5145a74bb..01b074e27cc 100644
--- a/src/script/standard.cpp
+++ b/src/script/standard.cpp
@@ -358,298 +358,3 @@ CScript GetScriptForMultisig(int nRequired, const std::vector<CPubKey>& keys)
 bool IsValidDestination(const CTxDestination& dest) {
     return dest.index() != 0;
 }
-
-/*static*/ TaprootBuilder::NodeInfo TaprootBuilder::Combine(NodeInfo&& a, NodeInfo&& b)
-{
-    NodeInfo ret;
-    /* Iterate over all tracked leaves in a, add b's hash to their Merkle branch, and move them to ret. */
-    for (auto& leaf : a.leaves) {
-        leaf.merkle_branch.push_back(b.hash);
-        ret.leaves.emplace_back(std::move(leaf));
-    }
-    /* Iterate over all tracked leaves in b, add a's hash to their Merkle branch, and move them to ret. */
-    for (auto& leaf : b.leaves) {
-        leaf.merkle_branch.push_back(a.hash);
-        ret.leaves.emplace_back(std::move(leaf));
-    }
-    ret.hash = ComputeTapbranchHash(a.hash, b.hash);
-    return ret;
-}
-
-void TaprootSpendData::Merge(TaprootSpendData other)
-{
-    // TODO: figure out how to better deal with conflicting information
-    // being merged.
-    if (internal_key.IsNull() && !other.internal_key.IsNull()) {
-        internal_key = other.internal_key;
-    }
-    if (merkle_root.IsNull() && !other.merkle_root.IsNull()) {
-        merkle_root = other.merkle_root;
-    }
-    for (auto& [key, control_blocks] : other.scripts) {
-        scripts[key].merge(std::move(control_blocks));
-    }
-}
-
-void TaprootBuilder::Insert(TaprootBuilder::NodeInfo&& node, int depth)
-{
-    assert(depth >= 0 && (size_t)depth <= TAPROOT_CONTROL_MAX_NODE_COUNT);
-    /* We cannot insert a leaf at a lower depth while a deeper branch is unfinished. Doing
-     * so would mean the Add() invocations do not correspond to a DFS traversal of a
-     * binary tree. */
-    if ((size_t)depth + 1 < m_branch.size()) {
-        m_valid = false;
-        return;
-    }
-    /* As long as an entry in the branch exists at the specified depth, combine it and propagate up.
-     * The 'node' variable is overwritten here with the newly combined node. */
-    while (m_valid && m_branch.size() > (size_t)depth && m_branch[depth].has_value()) {
-        node = Combine(std::move(node), std::move(*m_branch[depth]));
-        m_branch.pop_back();
-        if (depth == 0) m_valid = false; /* Can't propagate further up than the root */
-        --depth;
-    }
-    if (m_valid) {
-        /* Make sure the branch is big enough to place the new node. */
-        if (m_branch.size() <= (size_t)depth) m_branch.resize((size_t)depth + 1);
-        assert(!m_branch[depth].has_value());
-        m_branch[depth] = std::move(node);
-    }
-}
-
-/*static*/ bool TaprootBuilder::ValidDepths(const std::vector<int>& depths)
-{
-    std::vector<bool> branch;
-    for (int depth : depths) {
-        // This inner loop corresponds to effectively the same logic on branch
-        // as what Insert() performs on the m_branch variable. Instead of
-        // storing a NodeInfo object, just remember whether or not there is one
-        // at that depth.
-        if (depth < 0 || (size_t)depth > TAPROOT_CONTROL_MAX_NODE_COUNT) return false;
-        if ((size_t)depth + 1 < branch.size()) return false;
-        while (branch.size() > (size_t)depth && branch[depth]) {
-            branch.pop_back();
-            if (depth == 0) return false;
-            --depth;
-        }
-        if (branch.size() <= (size_t)depth) branch.resize((size_t)depth + 1);
-        assert(!branch[depth]);
-        branch[depth] = true;
-    }
-    // And this check corresponds to the IsComplete() check on m_branch.
-    return branch.size() == 0 || (branch.size() == 1 && branch[0]);
-}
-
-TaprootBuilder& TaprootBuilder::Add(int depth, Span<const unsigned char> script, int leaf_version, bool track)
-{
-    assert((leaf_version & ~TAPROOT_LEAF_MASK) == 0);
-    if (!IsValid()) return *this;
-    /* Construct NodeInfo object with leaf hash and (if track is true) also leaf information. */
-    NodeInfo node;
-    node.hash = ComputeTapleafHash(leaf_version, script);
-    if (track) node.leaves.emplace_back(LeafInfo{std::vector<unsigned char>(script.begin(), script.end()), leaf_version, {}});
-    /* Insert into the branch. */
-    Insert(std::move(node), depth);
-    return *this;
-}
-
-TaprootBuilder& TaprootBuilder::AddOmitted(int depth, const uint256& hash)
-{
-    if (!IsValid()) return *this;
-    /* Construct NodeInfo object with the hash directly, and insert it into the branch. */
-    NodeInfo node;
-    node.hash = hash;
-    Insert(std::move(node), depth);
-    return *this;
-}
-
-TaprootBuilder& TaprootBuilder::Finalize(const XOnlyPubKey& internal_key)
-{
-    /* Can only call this function when IsComplete() is true. */
-    assert(IsComplete());
-    m_internal_key = internal_key;
-    auto ret = m_internal_key.CreateTapTweak(m_branch.size() == 0 ? nullptr : &m_branch[0]->hash);
-    assert(ret.has_value());
-    std::tie(m_output_key, m_parity) = *ret;
-    return *this;
-}
-
-WitnessV1Taproot TaprootBuilder::GetOutput() { return WitnessV1Taproot{m_output_key}; }
-
-TaprootSpendData TaprootBuilder::GetSpendData() const
-{
-    assert(IsComplete());
-    assert(m_output_key.IsFullyValid());
-    TaprootSpendData spd;
-    spd.merkle_root = m_branch.size() == 0 ? uint256() : m_branch[0]->hash;
-    spd.internal_key = m_internal_key;
-    if (m_branch.size()) {
-        // If any script paths exist, they have been combined into the root m_branch[0]
-        // by now. Compute the control block for each of its tracked leaves, and put them in
-        // spd.scripts.
-        for (const auto& leaf : m_branch[0]->leaves) {
-            std::vector<unsigned char> control_block;
-            control_block.resize(TAPROOT_CONTROL_BASE_SIZE + TAPROOT_CONTROL_NODE_SIZE * leaf.merkle_branch.size());
-            control_block[0] = leaf.leaf_version | (m_parity ? 1 : 0);
-            std::copy(m_internal_key.begin(), m_internal_key.end(), control_block.begin() + 1);
-            if (leaf.merkle_branch.size()) {
-                std::copy(leaf.merkle_branch[0].begin(),
-                          leaf.merkle_branch[0].begin() + TAPROOT_CONTROL_NODE_SIZE * leaf.merkle_branch.size(),
-                          control_block.begin() + TAPROOT_CONTROL_BASE_SIZE);
-            }
-            spd.scripts[{leaf.script, leaf.leaf_version}].insert(std::move(control_block));
-        }
-    }
-    return spd;
-}
-
-std::optional<std::vector<std::tuple<int, std::vector<unsigned char>, int>>> InferTaprootTree(const TaprootSpendData& spenddata, const XOnlyPubKey& output)
-{
-    // Verify that the output matches the assumed Merkle root and internal key.
-    auto tweak = spenddata.internal_key.CreateTapTweak(spenddata.merkle_root.IsNull() ? nullptr : &spenddata.merkle_root);
-    if (!tweak || tweak->first != output) return std::nullopt;
-    // If the Merkle root is 0, the tree is empty, and we're done.
-    std::vector<std::tuple<int, std::vector<unsigned char>, int>> ret;
-    if (spenddata.merkle_root.IsNull()) return ret;
-
-    /** Data structure to represent the nodes of the tree we're going to build. */
-    struct TreeNode {
-        /** Hash of this node, if known; 0 otherwise. */
-        uint256 hash;
-        /** The left and right subtrees (note that their order is irrelevant). */
-        std::unique_ptr<TreeNode> sub[2];
-        /** If this is known to be a leaf node, a pointer to the (script, leaf_ver) pair.
-         *  nullptr otherwise. */
-        const std::pair<std::vector<unsigned char>, int>* leaf = nullptr;
-        /** Whether or not this node has been explored (is known to be a leaf, or known to have children). */
-        bool explored = false;
-        /** Whether or not this node is an inner node (unknown until explored = true). */
-        bool inner;
-        /** Whether or not we have produced output for this subtree. */
-        bool done = false;
-    };
-
-    // Build tree from the provided branches.
-    TreeNode root;
-    root.hash = spenddata.merkle_root;
-    for (const auto& [key, control_blocks] : spenddata.scripts) {
-        const auto& [script, leaf_ver] = key;
-        for (const auto& control : control_blocks) {
-            // Skip script records with nonsensical leaf version.
-            if (leaf_ver < 0 || leaf_ver >= 0x100 || leaf_ver & 1) continue;
-            // Skip script records with invalid control block sizes.
-            if (control.size() < TAPROOT_CONTROL_BASE_SIZE || control.size() > TAPROOT_CONTROL_MAX_SIZE ||
-                ((control.size() - TAPROOT_CONTROL_BASE_SIZE) % TAPROOT_CONTROL_NODE_SIZE) != 0) continue;
-            // Skip script records that don't match the control block.
-            if ((control[0] & TAPROOT_LEAF_MASK) != leaf_ver) continue;
-            // Skip script records that don't match the provided Merkle root.
-            const uint256 leaf_hash = ComputeTapleafHash(leaf_ver, script);
-            const uint256 merkle_root = ComputeTaprootMerkleRoot(control, leaf_hash);
-            if (merkle_root != spenddata.merkle_root) continue;
-
-            TreeNode* node = &root;
-            size_t levels = (control.size() - TAPROOT_CONTROL_BASE_SIZE) / TAPROOT_CONTROL_NODE_SIZE;
-            for (size_t depth = 0; depth < levels; ++depth) {
-                // Can't descend into a node which we already know is a leaf.
-                if (node->explored && !node->inner) return std::nullopt;
-
-                // Extract partner hash from Merkle branch in control block.
-                uint256 hash;
-                std::copy(control.begin() + TAPROOT_CONTROL_BASE_SIZE + (levels - 1 - depth) * TAPROOT_CONTROL_NODE_SIZE,
-                          control.begin() + TAPROOT_CONTROL_BASE_SIZE + (levels - depth) * TAPROOT_CONTROL_NODE_SIZE,
-                          hash.begin());
-
-                if (node->sub[0]) {
-                    // Descend into the existing left or right branch.
-                    bool desc = false;
-                    for (int i = 0; i < 2; ++i) {
-                        if (node->sub[i]->hash == hash || (node->sub[i]->hash.IsNull() && node->sub[1-i]->hash != hash)) {
-                            node->sub[i]->hash = hash;
-                            node = &*node->sub[1-i];
-                            desc = true;
-                            break;
-                        }
-                    }
-                    if (!desc) return std::nullopt; // This probably requires a hash collision to hit.
-                } else {
-                    // We're in an unexplored node. Create subtrees and descend.
-                    node->explored = true;
-                    node->inner = true;
-                    node->sub[0] = std::make_unique<TreeNode>();
-                    node->sub[1] = std::make_unique<TreeNode>();
-                    node->sub[1]->hash = hash;
-                    node = &*node->sub[0];
-                }
-            }
-            // Cannot turn a known inner node into a leaf.
-            if (node->sub[0]) return std::nullopt;
-            node->explored = true;
-            node->inner = false;
-            node->leaf = &key;
-            node->hash = leaf_hash;
-        }
-    }
-
-    // Recursive processing to turn the tree into flattened output. Use an explicit stack here to avoid
-    // overflowing the call stack (the tree may be 128 levels deep).
-    std::vector<TreeNode*> stack{&root};
-    while (!stack.empty()) {
-        TreeNode& node = *stack.back();
-        if (!node.explored) {
-            // Unexplored node, which means the tree is incomplete.
-            return std::nullopt;
-        } else if (!node.inner) {
-            // Leaf node; produce output.
-            ret.emplace_back(stack.size() - 1, node.leaf->first, node.leaf->second);
-            node.done = true;
-            stack.pop_back();
-        } else if (node.sub[0]->done && !node.sub[1]->done && !node.sub[1]->explored && !node.sub[1]->hash.IsNull() &&
-                   ComputeTapbranchHash(node.sub[1]->hash, node.sub[1]->hash) == node.hash) {
-            // Whenever there are nodes with two identical subtrees under it, we run into a problem:
-            // the control blocks for the leaves underneath those will be identical as well, and thus
-            // they will all be matched to the same path in the tree. The result is that at the location
-            // where the duplicate occurred, the left child will contain a normal tree that can be explored
-            // and processed, but the right one will remain unexplored.
-            //
-            // This situation can be detected, by encountering an inner node with unexplored right subtree
-            // with known hash, and H_TapBranch(hash, hash) is equal to the parent node (this node)'s hash.
-            //
-            // To deal with this, simply process the left tree a second time (set its done flag to false;
-            // noting that the done flag of its children have already been set to false after processing
-            // those). To avoid ending up in an infinite loop, set the done flag of the right (unexplored)
-            // subtree to true.
-            node.sub[0]->done = false;
-            node.sub[1]->done = true;
-        } else if (node.sub[0]->done && node.sub[1]->done) {
-            // An internal node which we're finished with.
-            node.sub[0]->done = false;
-            node.sub[1]->done = false;
-            node.done = true;
-            stack.pop_back();
-        } else if (!node.sub[0]->done) {
-            // An internal node whose left branch hasn't been processed yet. Do so first.
-            stack.push_back(&*node.sub[0]);
-        } else if (!node.sub[1]->done) {
-            // An internal node whose right branch hasn't been processed yet. Do so first.
-            stack.push_back(&*node.sub[1]);
-        }
-    }
-
-    return ret;
-}
-
-std::vector<std::tuple<uint8_t, uint8_t, std::vector<unsigned char>>> TaprootBuilder::GetTreeTuples() const
-{
-    assert(IsComplete());
-    std::vector<std::tuple<uint8_t, uint8_t, std::vector<unsigned char>>> tuples;
-    if (m_branch.size()) {
-        const auto& leaves = m_branch[0]->leaves;
-        for (const auto& leaf : leaves) {
-            assert(leaf.merkle_branch.size() <= TAPROOT_CONTROL_MAX_NODE_COUNT);
-            uint8_t depth = (uint8_t)leaf.merkle_branch.size();
-            uint8_t leaf_ver = (uint8_t)leaf.leaf_version;
-            tuples.push_back(std::make_tuple(depth, leaf_ver, leaf.script));
-        }
-    }
-    return tuples;
-}
diff --git a/src/script/standard.h b/src/script/standard.h
index 8a76606082a..9555cc2b612 100644
--- a/src/script/standard.h
+++ b/src/script/standard.h
@@ -175,136 +175,4 @@ std::optional<std::pair<int, std::vector<Span<const unsigned char>>>> MatchMulti
 /** Generate a multisig script. */
 CScript GetScriptForMultisig(int nRequired, const std::vector<CPubKey>& keys);
 
-struct ShortestVectorFirstComparator
-{
-    bool operator()(const std::vector<unsigned char>& a, const std::vector<unsigned char>& b) const
-    {
-        if (a.size() < b.size()) return true;
-        if (a.size() > b.size()) return false;
-        return a < b;
-    }
-};
-
-struct TaprootSpendData
-{
-    /** The BIP341 internal key. */
-    XOnlyPubKey internal_key;
-    /** The Merkle root of the script tree (0 if no scripts). */
-    uint256 merkle_root;
-    /** Map from (script, leaf_version) to (sets of) control blocks.
-     *  More than one control block for a given script is only possible if it
-     *  appears in multiple branches of the tree. We keep them all so that
-     *  inference can reconstruct the full tree. Within each set, the control
-     *  blocks are sorted by size, so that the signing logic can easily
-     *  prefer the cheapest one. */
-    std::map<std::pair<std::vector<unsigned char>, int>, std::set<std::vector<unsigned char>, ShortestVectorFirstComparator>> scripts;
-    /** Merge other TaprootSpendData (for the same scriptPubKey) into this. */
-    void Merge(TaprootSpendData other);
-};
-
-/** Utility class to construct Taproot outputs from internal key and script tree. */
-class TaprootBuilder
-{
-private:
-    /** Information about a tracked leaf in the Merkle tree. */
-    struct LeafInfo
-    {
-        std::vector<unsigned char> script;   //!< The script.
-        int leaf_version;                    //!< The leaf version for that script.
-        std::vector<uint256> merkle_branch;  //!< The hashing partners above this leaf.
-    };
-
-    /** Information associated with a node in the Merkle tree. */
-    struct NodeInfo
-    {
-        /** Merkle hash of this node. */
-        uint256 hash;
-        /** Tracked leaves underneath this node (either from the node itself, or its children).
-         *  The merkle_branch field of each is the partners to get to *this* node. */
-        std::vector<LeafInfo> leaves;
-    };
-    /** Whether the builder is in a valid state so far. */
-    bool m_valid = true;
-
-    /** The current state of the builder.
-     *
-     * For each level in the tree, one NodeInfo object may be present. m_branch[0]
-     * is information about the root; further values are for deeper subtrees being
-     * explored.
-     *
-     * For every right branch taken to reach the position we're currently
-     * working in, there will be a (non-nullopt) entry in m_branch corresponding
-     * to the left branch at that level.
-     *
-     * For example, imagine this tree:     - N0 -
-     *                                    /      \
-     *                                   N1      N2
-     *                                  /  \    /  \
-     *                                 A    B  C   N3
-     *                                            /  \
-     *                                           D    E
-     *
-     * Initially, m_branch is empty. After processing leaf A, it would become
-     * {nullopt, nullopt, A}. When processing leaf B, an entry at level 2 already
-     * exists, and it would thus be combined with it to produce a level 1 one,
-     * resulting in {nullopt, N1}. Adding C and D takes us to {nullopt, N1, C}
-     * and {nullopt, N1, C, D} respectively. When E is processed, it is combined
-     * with D, and then C, and then N1, to produce the root, resulting in {N0}.
-     *
-     * This structure allows processing with just O(log n) overhead if the leaves
-     * are computed on the fly.
-     *
-     * As an invariant, there can never be nullopt entries at the end. There can
-     * also not be more than 128 entries (as that would mean more than 128 levels
-     * in the tree). The depth of newly added entries will always be at least
-     * equal to the current size of m_branch (otherwise it does not correspond
-     * to a depth-first traversal of a tree). m_branch is only empty if no entries
-     * have ever be processed. m_branch having length 1 corresponds to being done.
-     */
-    std::vector<std::optional<NodeInfo>> m_branch;
-
-    XOnlyPubKey m_internal_key;  //!< The internal key, set when finalizing.
-    XOnlyPubKey m_output_key;    //!< The output key, computed when finalizing.
-    bool m_parity;               //!< The tweak parity, computed when finalizing.
-
-    /** Combine information about a parent Merkle tree node from its child nodes. */
-    static NodeInfo Combine(NodeInfo&& a, NodeInfo&& b);
-    /** Insert information about a node at a certain depth, and propagate information up. */
-    void Insert(NodeInfo&& node, int depth);
-
-public:
-    /** Add a new script at a certain depth in the tree. Add() operations must be called
-     *  in depth-first traversal order of binary tree. If track is true, it will be included in
-     *  the GetSpendData() output. */
-    TaprootBuilder& Add(int depth, Span<const unsigned char> script, int leaf_version, bool track = true);
-    /** Like Add(), but for a Merkle node with a given hash to the tree. */
-    TaprootBuilder& AddOmitted(int depth, const uint256& hash);
-    /** Finalize the construction. Can only be called when IsComplete() is true.
-        internal_key.IsFullyValid() must be true. */
-    TaprootBuilder& Finalize(const XOnlyPubKey& internal_key);
-
-    /** Return true if so far all input was valid. */
-    bool IsValid() const { return m_valid; }
-    /** Return whether there were either no leaves, or the leaves form a Huffman tree. */
-    bool IsComplete() const { return m_valid && (m_branch.size() == 0 || (m_branch.size() == 1 && m_branch[0].has_value())); }
-    /** Compute scriptPubKey (after Finalize()). */
-    WitnessV1Taproot GetOutput();
-    /** Check if a list of depths is legal (will lead to IsComplete()). */
-    static bool ValidDepths(const std::vector<int>& depths);
-    /** Compute spending data (after Finalize()). */
-    TaprootSpendData GetSpendData() const;
-    /** Returns a vector of tuples representing the depth, leaf version, and script */
-    std::vector<std::tuple<uint8_t, uint8_t, std::vector<unsigned char>>> GetTreeTuples() const;
-    /** Returns true if there are any tapscripts */
-    bool HasScripts() const { return !m_branch.empty(); }
-};
-
-/** Given a TaprootSpendData and the output key, reconstruct its script tree.
- *
- * If the output doesn't match the spenddata, or if the data in spenddata is incomplete,
- * std::nullopt is returned. Otherwise, a vector of (depth, script, leaf_ver) tuples is
- * returned, corresponding to a depth-first traversal of the script tree.
- */
-std::optional<std::vector<std::tuple<int, std::vector<unsigned char>, int>>> InferTaprootTree(const TaprootSpendData& spenddata, const XOnlyPubKey& output);
-
 #endif // BITCOIN_SCRIPT_STANDARD_H
diff --git a/src/wallet/test/ismine_tests.cpp b/src/wallet/test/ismine_tests.cpp
index fd0718fbb9c..8fdfaf946ef 100644
--- a/src/wallet/test/ismine_tests.cpp
+++ b/src/wallet/test/ismine_tests.cpp
@@ -6,6 +6,7 @@
 #include <key_io.h>
 #include <node/context.h>
 #include <script/script.h>
+#include <script/signingprovider.h>
 #include <script/standard.h>
 #include <test/util/setup_common.h>
 #include <wallet/types.h>

From 7a172c76d2361fc3cdf6345590e26c79a7821672 Mon Sep 17 00:00:00 2001
From: Andrew Chow <github@achow101.com>
Date: Tue, 8 Aug 2023 10:57:31 -0400
Subject: [PATCH 5/9] Move CTxDestination to its own file

CTxDestination is really our internal representation of an address and
doesn't really have anything to do with standard script types, so move
them to their own file.
---
 src/Makefile.am                      |   2 +
 src/addresstype.cpp                  | 150 +++++++++++++++++++++++++++
 src/addresstype.h                    | 121 +++++++++++++++++++++
 src/bench/descriptors.cpp            |   1 -
 src/interfaces/wallet.h              |   8 +-
 src/key_io.h                         |   1 +
 src/outputtype.h                     |   2 +-
 src/script/signingprovider.h         |   1 +
 src/script/standard.cpp              | 135 ------------------------
 src/script/standard.h                | 105 -------------------
 src/test/blockfilter_index_tests.cpp |   1 +
 src/test/coins_tests.cpp             |   1 +
 src/test/fuzz/util.h                 |   1 +
 src/test/miner_tests.cpp             |   1 +
 src/test/miniscript_tests.cpp        |   1 +
 src/test/sigopcount_tests.cpp        |   1 +
 src/test/txindex_tests.cpp           |   1 +
 src/wallet/scriptpubkeyman.h         |   1 +
 src/wallet/test/util.h               |   2 +-
 src/wallet/test/wallet_tests.cpp     |   1 +
 src/wallet/wallet.h                  |   1 +
 21 files changed, 291 insertions(+), 247 deletions(-)
 create mode 100644 src/addresstype.cpp
 create mode 100644 src/addresstype.h

diff --git a/src/Makefile.am b/src/Makefile.am
index a108e60c86b..3efc008e33e 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -117,6 +117,7 @@ endif
 .PHONY: FORCE check-symbols check-security
 # bitcoin core #
 BITCOIN_CORE_H = \
+  addresstype.h \
   addrdb.h \
   addrman.h \
   addrman_impl.h \
@@ -657,6 +658,7 @@ libbitcoin_consensus_a_SOURCES = \
 libbitcoin_common_a_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES) $(BOOST_CPPFLAGS)
 libbitcoin_common_a_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
 libbitcoin_common_a_SOURCES = \
+  addresstype.cpp \
   base58.cpp \
   bech32.cpp \
   chainparams.cpp \
diff --git a/src/addresstype.cpp b/src/addresstype.cpp
new file mode 100644
index 00000000000..96428df846e
--- /dev/null
+++ b/src/addresstype.cpp
@@ -0,0 +1,150 @@
+// Copyright (c) 2023 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or https://www.opensource.org/licenses/mit-license.php.
+
+#include <addresstype.h>
+#include <script/script.h>
+#include <script/standard.h>
+#include <hash.h>
+#include <pubkey.h>
+#include <uint256.h>
+#include <util/hash_type.h>
+
+#include <vector>
+
+typedef std::vector<unsigned char> valtype;
+
+ScriptHash::ScriptHash(const CScript& in) : BaseHash(Hash160(in)) {}
+ScriptHash::ScriptHash(const CScriptID& in) : BaseHash(static_cast<uint160>(in)) {}
+
+PKHash::PKHash(const CPubKey& pubkey) : BaseHash(pubkey.GetID()) {}
+PKHash::PKHash(const CKeyID& pubkey_id) : BaseHash(pubkey_id) {}
+
+WitnessV0KeyHash::WitnessV0KeyHash(const CPubKey& pubkey) : BaseHash(pubkey.GetID()) {}
+WitnessV0KeyHash::WitnessV0KeyHash(const PKHash& pubkey_hash) : BaseHash(static_cast<uint160>(pubkey_hash)) {}
+
+CKeyID ToKeyID(const PKHash& key_hash)
+{
+    return CKeyID{static_cast<uint160>(key_hash)};
+}
+
+CKeyID ToKeyID(const WitnessV0KeyHash& key_hash)
+{
+    return CKeyID{static_cast<uint160>(key_hash)};
+}
+
+CScriptID ToScriptID(const ScriptHash& script_hash)
+{
+    return CScriptID{static_cast<uint160>(script_hash)};
+}
+
+WitnessV0ScriptHash::WitnessV0ScriptHash(const CScript& in)
+{
+    CSHA256().Write(in.data(), in.size()).Finalize(begin());
+}
+
+bool ExtractDestination(const CScript& scriptPubKey, CTxDestination& addressRet)
+{
+    std::vector<valtype> vSolutions;
+    TxoutType whichType = Solver(scriptPubKey, vSolutions);
+
+    switch (whichType) {
+    case TxoutType::PUBKEY: {
+        CPubKey pubKey(vSolutions[0]);
+        if (!pubKey.IsValid())
+            return false;
+
+        addressRet = PKHash(pubKey);
+        return true;
+    }
+    case TxoutType::PUBKEYHASH: {
+        addressRet = PKHash(uint160(vSolutions[0]));
+        return true;
+    }
+    case TxoutType::SCRIPTHASH: {
+        addressRet = ScriptHash(uint160(vSolutions[0]));
+        return true;
+    }
+    case TxoutType::WITNESS_V0_KEYHASH: {
+        WitnessV0KeyHash hash;
+        std::copy(vSolutions[0].begin(), vSolutions[0].end(), hash.begin());
+        addressRet = hash;
+        return true;
+    }
+    case TxoutType::WITNESS_V0_SCRIPTHASH: {
+        WitnessV0ScriptHash hash;
+        std::copy(vSolutions[0].begin(), vSolutions[0].end(), hash.begin());
+        addressRet = hash;
+        return true;
+    }
+    case TxoutType::WITNESS_V1_TAPROOT: {
+        WitnessV1Taproot tap;
+        std::copy(vSolutions[0].begin(), vSolutions[0].end(), tap.begin());
+        addressRet = tap;
+        return true;
+    }
+    case TxoutType::WITNESS_UNKNOWN: {
+        WitnessUnknown unk;
+        unk.version = vSolutions[0][0];
+        std::copy(vSolutions[1].begin(), vSolutions[1].end(), unk.program);
+        unk.length = vSolutions[1].size();
+        addressRet = unk;
+        return true;
+    }
+    case TxoutType::MULTISIG:
+    case TxoutType::NULL_DATA:
+    case TxoutType::NONSTANDARD:
+        return false;
+    } // no default case, so the compiler can warn about missing cases
+    assert(false);
+}
+
+namespace {
+class CScriptVisitor
+{
+public:
+    CScript operator()(const CNoDestination& dest) const
+    {
+        return CScript();
+    }
+
+    CScript operator()(const PKHash& keyID) const
+    {
+        return CScript() << OP_DUP << OP_HASH160 << ToByteVector(keyID) << OP_EQUALVERIFY << OP_CHECKSIG;
+    }
+
+    CScript operator()(const ScriptHash& scriptID) const
+    {
+        return CScript() << OP_HASH160 << ToByteVector(scriptID) << OP_EQUAL;
+    }
+
+    CScript operator()(const WitnessV0KeyHash& id) const
+    {
+        return CScript() << OP_0 << ToByteVector(id);
+    }
+
+    CScript operator()(const WitnessV0ScriptHash& id) const
+    {
+        return CScript() << OP_0 << ToByteVector(id);
+    }
+
+    CScript operator()(const WitnessV1Taproot& tap) const
+    {
+        return CScript() << OP_1 << ToByteVector(tap);
+    }
+
+    CScript operator()(const WitnessUnknown& id) const
+    {
+        return CScript() << CScript::EncodeOP_N(id.version) << std::vector<unsigned char>(id.program, id.program + id.length);
+    }
+};
+} // namespace
+
+CScript GetScriptForDestination(const CTxDestination& dest)
+{
+    return std::visit(CScriptVisitor(), dest);
+}
+
+bool IsValidDestination(const CTxDestination& dest) {
+    return dest.index() != 0;
+}
diff --git a/src/addresstype.h b/src/addresstype.h
new file mode 100644
index 00000000000..6b651e90140
--- /dev/null
+++ b/src/addresstype.h
@@ -0,0 +1,121 @@
+// Copyright (c) 2023 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or https://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_ADDRESSTYPE_H
+#define BITCOIN_ADDRESSTYPE_H
+
+#include <pubkey.h>
+#include <script/script.h>
+#include <uint256.h>
+#include <util/hash_type.h>
+
+#include <variant>
+#include <algorithm>
+
+class CNoDestination {
+public:
+    friend bool operator==(const CNoDestination &a, const CNoDestination &b) { return true; }
+    friend bool operator<(const CNoDestination &a, const CNoDestination &b) { return true; }
+};
+
+struct PKHash : public BaseHash<uint160>
+{
+    PKHash() : BaseHash() {}
+    explicit PKHash(const uint160& hash) : BaseHash(hash) {}
+    explicit PKHash(const CPubKey& pubkey);
+    explicit PKHash(const CKeyID& pubkey_id);
+};
+CKeyID ToKeyID(const PKHash& key_hash);
+
+struct WitnessV0KeyHash;
+
+struct ScriptHash : public BaseHash<uint160>
+{
+    ScriptHash() : BaseHash() {}
+    // These don't do what you'd expect.
+    // Use ScriptHash(GetScriptForDestination(...)) instead.
+    explicit ScriptHash(const WitnessV0KeyHash& hash) = delete;
+    explicit ScriptHash(const PKHash& hash) = delete;
+
+    explicit ScriptHash(const uint160& hash) : BaseHash(hash) {}
+    explicit ScriptHash(const CScript& script);
+    explicit ScriptHash(const CScriptID& script);
+};
+CScriptID ToScriptID(const ScriptHash& script_hash);
+
+struct WitnessV0ScriptHash : public BaseHash<uint256>
+{
+    WitnessV0ScriptHash() : BaseHash() {}
+    explicit WitnessV0ScriptHash(const uint256& hash) : BaseHash(hash) {}
+    explicit WitnessV0ScriptHash(const CScript& script);
+};
+
+struct WitnessV0KeyHash : public BaseHash<uint160>
+{
+    WitnessV0KeyHash() : BaseHash() {}
+    explicit WitnessV0KeyHash(const uint160& hash) : BaseHash(hash) {}
+    explicit WitnessV0KeyHash(const CPubKey& pubkey);
+    explicit WitnessV0KeyHash(const PKHash& pubkey_hash);
+};
+CKeyID ToKeyID(const WitnessV0KeyHash& key_hash);
+
+struct WitnessV1Taproot : public XOnlyPubKey
+{
+    WitnessV1Taproot() : XOnlyPubKey() {}
+    explicit WitnessV1Taproot(const XOnlyPubKey& xpk) : XOnlyPubKey(xpk) {}
+};
+
+//! CTxDestination subtype to encode any future Witness version
+struct WitnessUnknown
+{
+    unsigned int version;
+    unsigned int length;
+    unsigned char program[40];
+
+    friend bool operator==(const WitnessUnknown& w1, const WitnessUnknown& w2) {
+        if (w1.version != w2.version) return false;
+        if (w1.length != w2.length) return false;
+        return std::equal(w1.program, w1.program + w1.length, w2.program);
+    }
+
+    friend bool operator<(const WitnessUnknown& w1, const WitnessUnknown& w2) {
+        if (w1.version < w2.version) return true;
+        if (w1.version > w2.version) return false;
+        if (w1.length < w2.length) return true;
+        if (w1.length > w2.length) return false;
+        return std::lexicographical_compare(w1.program, w1.program + w1.length, w2.program, w2.program + w2.length);
+    }
+};
+
+/**
+ * A txout script template with a specific destination. It is either:
+ *  * CNoDestination: no destination set
+ *  * PKHash: TxoutType::PUBKEYHASH destination (P2PKH)
+ *  * ScriptHash: TxoutType::SCRIPTHASH destination (P2SH)
+ *  * WitnessV0ScriptHash: TxoutType::WITNESS_V0_SCRIPTHASH destination (P2WSH)
+ *  * WitnessV0KeyHash: TxoutType::WITNESS_V0_KEYHASH destination (P2WPKH)
+ *  * WitnessV1Taproot: TxoutType::WITNESS_V1_TAPROOT destination (P2TR)
+ *  * WitnessUnknown: TxoutType::WITNESS_UNKNOWN destination (P2W???)
+ *  A CTxDestination is the internal data type encoded in a bitcoin address
+ */
+using CTxDestination = std::variant<CNoDestination, PKHash, ScriptHash, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessV1Taproot, WitnessUnknown>;
+
+/** Check whether a CTxDestination is a CNoDestination. */
+bool IsValidDestination(const CTxDestination& dest);
+
+/**
+ * Parse a standard scriptPubKey for the destination address. Assigns result to
+ * the addressRet parameter and returns true if successful. Currently only works for P2PK,
+ * P2PKH, P2SH, P2WPKH, and P2WSH scripts.
+ */
+bool ExtractDestination(const CScript& scriptPubKey, CTxDestination& addressRet);
+
+/**
+ * Generate a Bitcoin scriptPubKey for the given CTxDestination. Returns a P2PKH
+ * script for a CKeyID destination, a P2SH script for a CScriptID, and an empty
+ * script for CNoDestination.
+ */
+CScript GetScriptForDestination(const CTxDestination& dest);
+
+#endif // BITCOIN_ADDRESSTYPE_H
diff --git a/src/bench/descriptors.cpp b/src/bench/descriptors.cpp
index 5d28d269092..fbef1395fba 100644
--- a/src/bench/descriptors.cpp
+++ b/src/bench/descriptors.cpp
@@ -6,7 +6,6 @@
 #include <key.h>
 #include <pubkey.h>
 #include <script/descriptor.h>
-#include <script/standard.h>
 
 #include <string>
 #include <utility>
diff --git a/src/interfaces/wallet.h b/src/interfaces/wallet.h
index 9d8bebb406a..9987681367a 100644
--- a/src/interfaces/wallet.h
+++ b/src/interfaces/wallet.h
@@ -5,12 +5,12 @@
 #ifndef BITCOIN_INTERFACES_WALLET_H
 #define BITCOIN_INTERFACES_WALLET_H
 
+#include <addresstype.h>
 #include <consensus/amount.h>
-#include <interfaces/chain.h>          // For ChainClient
-#include <pubkey.h>                    // For CKeyID and CScriptID (definitions needed in CTxDestination instantiation)
+#include <interfaces/chain.h>
+#include <pubkey.h>
 #include <script/script.h>
-#include <script/standard.h>           // For CTxDestination
-#include <support/allocators/secure.h> // For SecureString
+#include <support/allocators/secure.h>
 #include <util/fs.h>
 #include <util/message.h>
 #include <util/result.h>
diff --git a/src/key_io.h b/src/key_io.h
index 07b80c4b859..6d2aface4cb 100644
--- a/src/key_io.h
+++ b/src/key_io.h
@@ -6,6 +6,7 @@
 #ifndef BITCOIN_KEY_IO_H
 #define BITCOIN_KEY_IO_H
 
+#include <addresstype.h>
 #include <chainparams.h>
 #include <key.h>
 #include <pubkey.h>
diff --git a/src/outputtype.h b/src/outputtype.h
index 7c50f445fc6..a2d59423208 100644
--- a/src/outputtype.h
+++ b/src/outputtype.h
@@ -6,8 +6,8 @@
 #ifndef BITCOIN_OUTPUTTYPE_H
 #define BITCOIN_OUTPUTTYPE_H
 
+#include <addresstype.h>
 #include <script/signingprovider.h>
-#include <script/standard.h>
 
 #include <array>
 #include <optional>
diff --git a/src/script/signingprovider.h b/src/script/signingprovider.h
index 26886e0d575..40927f57bcd 100644
--- a/src/script/signingprovider.h
+++ b/src/script/signingprovider.h
@@ -6,6 +6,7 @@
 #ifndef BITCOIN_SCRIPT_SIGNINGPROVIDER_H
 #define BITCOIN_SCRIPT_SIGNINGPROVIDER_H
 
+#include <addresstype.h>
 #include <attributes.h>
 #include <key.h>
 #include <pubkey.h>
diff --git a/src/script/standard.cpp b/src/script/standard.cpp
index 01b074e27cc..6cbcf9a016b 100644
--- a/src/script/standard.cpp
+++ b/src/script/standard.cpp
@@ -16,35 +16,6 @@
 
 typedef std::vector<unsigned char> valtype;
 
-ScriptHash::ScriptHash(const CScript& in) : BaseHash(Hash160(in)) {}
-ScriptHash::ScriptHash(const CScriptID& in) : BaseHash(static_cast<uint160>(in)) {}
-
-PKHash::PKHash(const CPubKey& pubkey) : BaseHash(pubkey.GetID()) {}
-PKHash::PKHash(const CKeyID& pubkey_id) : BaseHash(pubkey_id) {}
-
-WitnessV0KeyHash::WitnessV0KeyHash(const CPubKey& pubkey) : BaseHash(pubkey.GetID()) {}
-WitnessV0KeyHash::WitnessV0KeyHash(const PKHash& pubkey_hash) : BaseHash(static_cast<uint160>(pubkey_hash)) {}
-
-CKeyID ToKeyID(const PKHash& key_hash)
-{
-    return CKeyID{static_cast<uint160>(key_hash)};
-}
-
-CKeyID ToKeyID(const WitnessV0KeyHash& key_hash)
-{
-    return CKeyID{static_cast<uint160>(key_hash)};
-}
-
-CScriptID ToScriptID(const ScriptHash& script_hash)
-{
-    return CScriptID{static_cast<uint160>(script_hash)};
-}
-
-WitnessV0ScriptHash::WitnessV0ScriptHash(const CScript& in)
-{
-    CSHA256().Write(in.data(), in.size()).Finalize(begin());
-}
-
 std::string GetTxnOutputType(TxoutType t)
 {
     switch (t) {
@@ -236,108 +207,6 @@ TxoutType Solver(const CScript& scriptPubKey, std::vector<std::vector<unsigned c
     return TxoutType::NONSTANDARD;
 }
 
-bool ExtractDestination(const CScript& scriptPubKey, CTxDestination& addressRet)
-{
-    std::vector<valtype> vSolutions;
-    TxoutType whichType = Solver(scriptPubKey, vSolutions);
-
-    switch (whichType) {
-    case TxoutType::PUBKEY: {
-        CPubKey pubKey(vSolutions[0]);
-        if (!pubKey.IsValid())
-            return false;
-
-        addressRet = PKHash(pubKey);
-        return true;
-    }
-    case TxoutType::PUBKEYHASH: {
-        addressRet = PKHash(uint160(vSolutions[0]));
-        return true;
-    }
-    case TxoutType::SCRIPTHASH: {
-        addressRet = ScriptHash(uint160(vSolutions[0]));
-        return true;
-    }
-    case TxoutType::WITNESS_V0_KEYHASH: {
-        WitnessV0KeyHash hash;
-        std::copy(vSolutions[0].begin(), vSolutions[0].end(), hash.begin());
-        addressRet = hash;
-        return true;
-    }
-    case TxoutType::WITNESS_V0_SCRIPTHASH: {
-        WitnessV0ScriptHash hash;
-        std::copy(vSolutions[0].begin(), vSolutions[0].end(), hash.begin());
-        addressRet = hash;
-        return true;
-    }
-    case TxoutType::WITNESS_V1_TAPROOT: {
-        WitnessV1Taproot tap;
-        std::copy(vSolutions[0].begin(), vSolutions[0].end(), tap.begin());
-        addressRet = tap;
-        return true;
-    }
-    case TxoutType::WITNESS_UNKNOWN: {
-        WitnessUnknown unk;
-        unk.version = vSolutions[0][0];
-        std::copy(vSolutions[1].begin(), vSolutions[1].end(), unk.program);
-        unk.length = vSolutions[1].size();
-        addressRet = unk;
-        return true;
-    }
-    case TxoutType::MULTISIG:
-    case TxoutType::NULL_DATA:
-    case TxoutType::NONSTANDARD:
-        return false;
-    } // no default case, so the compiler can warn about missing cases
-    assert(false);
-}
-
-namespace {
-class CScriptVisitor
-{
-public:
-    CScript operator()(const CNoDestination& dest) const
-    {
-        return CScript();
-    }
-
-    CScript operator()(const PKHash& keyID) const
-    {
-        return CScript() << OP_DUP << OP_HASH160 << ToByteVector(keyID) << OP_EQUALVERIFY << OP_CHECKSIG;
-    }
-
-    CScript operator()(const ScriptHash& scriptID) const
-    {
-        return CScript() << OP_HASH160 << ToByteVector(scriptID) << OP_EQUAL;
-    }
-
-    CScript operator()(const WitnessV0KeyHash& id) const
-    {
-        return CScript() << OP_0 << ToByteVector(id);
-    }
-
-    CScript operator()(const WitnessV0ScriptHash& id) const
-    {
-        return CScript() << OP_0 << ToByteVector(id);
-    }
-
-    CScript operator()(const WitnessV1Taproot& tap) const
-    {
-        return CScript() << OP_1 << ToByteVector(tap);
-    }
-
-    CScript operator()(const WitnessUnknown& id) const
-    {
-        return CScript() << CScript::EncodeOP_N(id.version) << std::vector<unsigned char>(id.program, id.program + id.length);
-    }
-};
-} // namespace
-
-CScript GetScriptForDestination(const CTxDestination& dest)
-{
-    return std::visit(CScriptVisitor(), dest);
-}
-
 CScript GetScriptForRawPubKey(const CPubKey& pubKey)
 {
     return CScript() << std::vector<unsigned char>(pubKey.begin(), pubKey.end()) << OP_CHECKSIG;
@@ -354,7 +223,3 @@ CScript GetScriptForMultisig(int nRequired, const std::vector<CPubKey>& keys)
 
     return script;
 }
-
-bool IsValidDestination(const CTxDestination& dest) {
-    return dest.index() != 0;
-}
diff --git a/src/script/standard.h b/src/script/standard.h
index 9555cc2b612..097ab926522 100644
--- a/src/script/standard.h
+++ b/src/script/standard.h
@@ -18,7 +18,6 @@
 
 static const bool DEFAULT_ACCEPT_DATACARRIER = true;
 
-class CKeyID;
 class CScript;
 
 /**
@@ -41,96 +40,6 @@ enum class TxoutType {
     WITNESS_UNKNOWN, //!< Only for Witness versions not already defined above
 };
 
-class CNoDestination {
-public:
-    friend bool operator==(const CNoDestination &a, const CNoDestination &b) { return true; }
-    friend bool operator<(const CNoDestination &a, const CNoDestination &b) { return true; }
-};
-
-struct PKHash : public BaseHash<uint160>
-{
-    PKHash() : BaseHash() {}
-    explicit PKHash(const uint160& hash) : BaseHash(hash) {}
-    explicit PKHash(const CPubKey& pubkey);
-    explicit PKHash(const CKeyID& pubkey_id);
-};
-CKeyID ToKeyID(const PKHash& key_hash);
-
-struct WitnessV0KeyHash;
-struct ScriptHash : public BaseHash<uint160>
-{
-    ScriptHash() : BaseHash() {}
-    // These don't do what you'd expect.
-    // Use ScriptHash(GetScriptForDestination(...)) instead.
-    explicit ScriptHash(const WitnessV0KeyHash& hash) = delete;
-    explicit ScriptHash(const PKHash& hash) = delete;
-
-    explicit ScriptHash(const uint160& hash) : BaseHash(hash) {}
-    explicit ScriptHash(const CScript& script);
-    explicit ScriptHash(const CScriptID& script);
-};
-CScriptID ToScriptID(const ScriptHash& script_hash);
-
-struct WitnessV0ScriptHash : public BaseHash<uint256>
-{
-    WitnessV0ScriptHash() : BaseHash() {}
-    explicit WitnessV0ScriptHash(const uint256& hash) : BaseHash(hash) {}
-    explicit WitnessV0ScriptHash(const CScript& script);
-};
-
-struct WitnessV0KeyHash : public BaseHash<uint160>
-{
-    WitnessV0KeyHash() : BaseHash() {}
-    explicit WitnessV0KeyHash(const uint160& hash) : BaseHash(hash) {}
-    explicit WitnessV0KeyHash(const CPubKey& pubkey);
-    explicit WitnessV0KeyHash(const PKHash& pubkey_hash);
-};
-CKeyID ToKeyID(const WitnessV0KeyHash& key_hash);
-
-struct WitnessV1Taproot : public XOnlyPubKey
-{
-    WitnessV1Taproot() : XOnlyPubKey() {}
-    explicit WitnessV1Taproot(const XOnlyPubKey& xpk) : XOnlyPubKey(xpk) {}
-};
-
-//! CTxDestination subtype to encode any future Witness version
-struct WitnessUnknown
-{
-    unsigned int version;
-    unsigned int length;
-    unsigned char program[40];
-
-    friend bool operator==(const WitnessUnknown& w1, const WitnessUnknown& w2) {
-        if (w1.version != w2.version) return false;
-        if (w1.length != w2.length) return false;
-        return std::equal(w1.program, w1.program + w1.length, w2.program);
-    }
-
-    friend bool operator<(const WitnessUnknown& w1, const WitnessUnknown& w2) {
-        if (w1.version < w2.version) return true;
-        if (w1.version > w2.version) return false;
-        if (w1.length < w2.length) return true;
-        if (w1.length > w2.length) return false;
-        return std::lexicographical_compare(w1.program, w1.program + w1.length, w2.program, w2.program + w2.length);
-    }
-};
-
-/**
- * A txout script template with a specific destination. It is either:
- *  * CNoDestination: no destination set
- *  * PKHash: TxoutType::PUBKEYHASH destination (P2PKH)
- *  * ScriptHash: TxoutType::SCRIPTHASH destination (P2SH)
- *  * WitnessV0ScriptHash: TxoutType::WITNESS_V0_SCRIPTHASH destination (P2WSH)
- *  * WitnessV0KeyHash: TxoutType::WITNESS_V0_KEYHASH destination (P2WPKH)
- *  * WitnessV1Taproot: TxoutType::WITNESS_V1_TAPROOT destination (P2TR)
- *  * WitnessUnknown: TxoutType::WITNESS_UNKNOWN destination (P2W???)
- *  A CTxDestination is the internal data type encoded in a bitcoin address
- */
-using CTxDestination = std::variant<CNoDestination, PKHash, ScriptHash, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessV1Taproot, WitnessUnknown>;
-
-/** Check whether a CTxDestination is a CNoDestination. */
-bool IsValidDestination(const CTxDestination& dest);
-
 /** Get the name of a TxoutType as a string */
 std::string GetTxnOutputType(TxoutType t);
 
@@ -151,20 +60,6 @@ constexpr bool IsPushdataOp(opcodetype opcode)
  */
 TxoutType Solver(const CScript& scriptPubKey, std::vector<std::vector<unsigned char>>& vSolutionsRet);
 
-/**
- * Parse a standard scriptPubKey for the destination address. Assigns result to
- * the addressRet parameter and returns true if successful. Currently only works for P2PK,
- * P2PKH, P2SH, P2WPKH, and P2WSH scripts.
- */
-bool ExtractDestination(const CScript& scriptPubKey, CTxDestination& addressRet);
-
-/**
- * Generate a Bitcoin scriptPubKey for the given CTxDestination. Returns a P2PKH
- * script for a CKeyID destination, a P2SH script for a CScriptID, and an empty
- * script for CNoDestination.
- */
-CScript GetScriptForDestination(const CTxDestination& dest);
-
 /** Generate a P2PK script for the given pubkey. */
 CScript GetScriptForRawPubKey(const CPubKey& pubkey);
 
diff --git a/src/test/blockfilter_index_tests.cpp b/src/test/blockfilter_index_tests.cpp
index 9bd5c7c2b6e..cd90448e28a 100644
--- a/src/test/blockfilter_index_tests.cpp
+++ b/src/test/blockfilter_index_tests.cpp
@@ -2,6 +2,7 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <addresstype.h>
 #include <blockfilter.h>
 #include <chainparams.h>
 #include <consensus/merkle.h>
diff --git a/src/test/coins_tests.cpp b/src/test/coins_tests.cpp
index 853dc6dc1ea..f8a29179781 100644
--- a/src/test/coins_tests.cpp
+++ b/src/test/coins_tests.cpp
@@ -2,6 +2,7 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <addresstype.h>
 #include <clientversion.h>
 #include <coins.h>
 #include <script/standard.h>
diff --git a/src/test/fuzz/util.h b/src/test/fuzz/util.h
index 5f2aff08dae..2d612a82721 100644
--- a/src/test/fuzz/util.h
+++ b/src/test/fuzz/util.h
@@ -5,6 +5,7 @@
 #ifndef BITCOIN_TEST_FUZZ_UTIL_H
 #define BITCOIN_TEST_FUZZ_UTIL_H
 
+#include <addresstype.h>
 #include <arith_uint256.h>
 #include <coins.h>
 #include <compat/compat.h>
diff --git a/src/test/miner_tests.cpp b/src/test/miner_tests.cpp
index 94e3f27930b..ea13989eb33 100644
--- a/src/test/miner_tests.cpp
+++ b/src/test/miner_tests.cpp
@@ -2,6 +2,7 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <addresstype.h>
 #include <coins.h>
 #include <common/system.h>
 #include <consensus/consensus.h>
diff --git a/src/test/miniscript_tests.cpp b/src/test/miniscript_tests.cpp
index 9c811db3e95..2a67da5cabe 100644
--- a/src/test/miniscript_tests.cpp
+++ b/src/test/miniscript_tests.cpp
@@ -10,6 +10,7 @@
 #include <test/util/setup_common.h>
 #include <boost/test/unit_test.hpp>
 
+#include <addresstype.h>
 #include <core_io.h>
 #include <hash.h>
 #include <pubkey.h>
diff --git a/src/test/sigopcount_tests.cpp b/src/test/sigopcount_tests.cpp
index a17be544194..e20b591c807 100644
--- a/src/test/sigopcount_tests.cpp
+++ b/src/test/sigopcount_tests.cpp
@@ -2,6 +2,7 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <addresstype.h>
 #include <coins.h>
 #include <consensus/consensus.h>
 #include <consensus/tx_verify.h>
diff --git a/src/test/txindex_tests.cpp b/src/test/txindex_tests.cpp
index cb80dbed69c..1471290d4be 100644
--- a/src/test/txindex_tests.cpp
+++ b/src/test/txindex_tests.cpp
@@ -2,6 +2,7 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <addresstype.h>
 #include <chainparams.h>
 #include <index/txindex.h>
 #include <interfaces/chain.h>
diff --git a/src/wallet/scriptpubkeyman.h b/src/wallet/scriptpubkeyman.h
index 00159abbef2..c775d26c4f7 100644
--- a/src/wallet/scriptpubkeyman.h
+++ b/src/wallet/scriptpubkeyman.h
@@ -5,6 +5,7 @@
 #ifndef BITCOIN_WALLET_SCRIPTPUBKEYMAN_H
 #define BITCOIN_WALLET_SCRIPTPUBKEYMAN_H
 
+#include <addresstype.h>
 #include <logging.h>
 #include <psbt.h>
 #include <script/descriptor.h>
diff --git a/src/wallet/test/util.h b/src/wallet/test/util.h
index 2a1fe639de6..8bd238648ff 100644
--- a/src/wallet/test/util.h
+++ b/src/wallet/test/util.h
@@ -5,7 +5,7 @@
 #ifndef BITCOIN_WALLET_TEST_UTIL_H
 #define BITCOIN_WALLET_TEST_UTIL_H
 
-#include <script/standard.h>
+#include <addresstype.h>
 #include <wallet/db.h>
 
 #include <memory>
diff --git a/src/wallet/test/wallet_tests.cpp b/src/wallet/test/wallet_tests.cpp
index dd914f159c8..1c128a85df8 100644
--- a/src/wallet/test/wallet_tests.cpp
+++ b/src/wallet/test/wallet_tests.cpp
@@ -9,6 +9,7 @@
 #include <stdint.h>
 #include <vector>
 
+#include <addresstype.h>
 #include <interfaces/chain.h>
 #include <key_io.h>
 #include <node/blockstorage.h>
diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h
index cbd50083669..91c8e89d2d9 100644
--- a/src/wallet/wallet.h
+++ b/src/wallet/wallet.h
@@ -6,6 +6,7 @@
 #ifndef BITCOIN_WALLET_WALLET_H
 #define BITCOIN_WALLET_WALLET_H
 
+#include <addresstype.h>
 #include <consensus/amount.h>
 #include <interfaces/chain.h>
 #include <interfaces/handler.h>

From 8bbe257bac751859a272ddf52dc0328c1b5a1ede Mon Sep 17 00:00:00 2001
From: Andrew Chow <github@achow101.com>
Date: Wed, 9 Aug 2023 05:05:22 -0400
Subject: [PATCH 6/9] MOVEONLY: Move datacarrier defaults to policy.h

---
 src/policy/policy.h   | 7 +++++++
 src/script/standard.h | 8 --------
 2 files changed, 7 insertions(+), 8 deletions(-)

diff --git a/src/policy/policy.h b/src/policy/policy.h
index 657ee8b32df..79e6725e73f 100644
--- a/src/policy/policy.h
+++ b/src/policy/policy.h
@@ -63,6 +63,13 @@ static constexpr unsigned int DEFAULT_ANCESTOR_SIZE_LIMIT_KVB{101};
 static constexpr unsigned int DEFAULT_DESCENDANT_LIMIT{25};
 /** Default for -limitdescendantsize, maximum kilobytes of in-mempool descendants */
 static constexpr unsigned int DEFAULT_DESCENDANT_SIZE_LIMIT_KVB{101};
+/** Default for -datacarrier */
+static const bool DEFAULT_ACCEPT_DATACARRIER = true;
+/**
+ * Default setting for -datacarriersize. 80 bytes of data, +1 for OP_RETURN,
+ * +2 for the pushdata opcodes.
+ */
+static const unsigned int MAX_OP_RETURN_RELAY = 83;
 /**
  * An extra transaction can be added to a package, as long as it only has one
  * ancestor and is no larger than this. Not really any reason to make this
diff --git a/src/script/standard.h b/src/script/standard.h
index 097ab926522..53987ed2443 100644
--- a/src/script/standard.h
+++ b/src/script/standard.h
@@ -16,16 +16,8 @@
 #include <string>
 #include <variant>
 
-static const bool DEFAULT_ACCEPT_DATACARRIER = true;
-
 class CScript;
 
-/**
- * Default setting for -datacarriersize. 80 bytes of data, +1 for OP_RETURN,
- * +2 for the pushdata opcodes.
- */
-static const unsigned int MAX_OP_RETURN_RELAY = 83;
-
 enum class TxoutType {
     NONSTANDARD,
     // 'standard' transaction types:

From f3c9078b4cddec5581e52de5c216ae53984ec130 Mon Sep 17 00:00:00 2001
From: Andrew Chow <github@achow101.com>
Date: Wed, 9 Aug 2023 05:17:30 -0400
Subject: [PATCH 7/9] Clean up things that include script/standard.h

Remove standard.h from files that don't use anything in it, and include
it in files that do.
---
 src/bench/verify_script.cpp               | 2 +-
 src/compressor.cpp                        | 1 -
 src/init.cpp                              | 1 -
 src/kernel/mempool_options.h              | 1 -
 src/key_io.cpp                            | 1 +
 src/key_io.h                              | 1 -
 src/node/mempool_args.cpp                 | 1 -
 src/outputtype.cpp                        | 1 -
 src/qt/guiutil.cpp                        | 2 +-
 src/qt/test/wallettests.cpp               | 1 +
 src/qt/walletmodel.h                      | 1 -
 src/rpc/mempool.cpp                       | 1 -
 src/rpc/output_script.cpp                 | 1 -
 src/rpc/util.cpp                          | 1 +
 src/rpc/util.h                            | 2 +-
 src/script/miniscript.cpp                 | 1 -
 src/script/sign.h                         | 1 -
 src/script/signingprovider.cpp            | 1 -
 src/script/signingprovider.h              | 1 -
 src/signet.cpp                            | 1 -
 src/test/blockfilter_index_tests.cpp      | 1 -
 src/test/blockmanager_tests.cpp           | 1 +
 src/test/coins_tests.cpp                  | 1 -
 src/test/compress_tests.cpp               | 1 -
 src/test/denialofservice_tests.cpp        | 1 -
 src/test/descriptor_tests.cpp             | 1 -
 src/test/fuzz/integer.cpp                 | 1 -
 src/test/fuzz/util.h                      | 1 -
 src/test/interfaces_tests.cpp             | 2 +-
 src/test/miner_tests.cpp                  | 1 -
 src/test/miniscript_tests.cpp             | 1 -
 src/test/orphanage_tests.cpp              | 1 -
 src/test/script_tests.cpp                 | 1 +
 src/test/txindex_tests.cpp                | 1 -
 src/test/txpackage_tests.cpp              | 1 -
 src/test/txvalidation_tests.cpp           | 1 -
 src/test/txvalidationcache_tests.cpp      | 1 -
 src/test/util/mining.cpp                  | 1 -
 src/test/validation_block_tests.cpp       | 1 -
 src/util/message.cpp                      | 1 -
 src/wallet/coincontrol.h                  | 1 -
 src/wallet/interfaces.cpp                 | 1 -
 src/wallet/rpc/addresses.cpp              | 1 +
 src/wallet/scriptpubkeyman.cpp            | 1 +
 src/wallet/scriptpubkeyman.h              | 1 -
 src/wallet/spend.cpp                      | 1 +
 src/wallet/test/ismine_tests.cpp          | 2 +-
 src/wallet/test/scriptpubkeyman_tests.cpp | 2 +-
 src/wallet/test/spend_tests.cpp           | 1 +
 src/wallet/test/wallet_tests.cpp          | 1 +
 src/wallet/wallet.cpp                     | 1 +
 src/wallet/walletdb.h                     | 1 -
 52 files changed, 17 insertions(+), 41 deletions(-)

diff --git a/src/bench/verify_script.cpp b/src/bench/verify_script.cpp
index 757094167a5..11f96b1005d 100644
--- a/src/bench/verify_script.cpp
+++ b/src/bench/verify_script.cpp
@@ -8,7 +8,7 @@
 #include <script/bitcoinconsensus.h>
 #endif
 #include <script/script.h>
-#include <script/standard.h>
+#include <script/interpreter.h>
 #include <streams.h>
 #include <test/util/transaction_utils.h>
 
diff --git a/src/compressor.cpp b/src/compressor.cpp
index 2dbd586bfac..668e25581cb 100644
--- a/src/compressor.cpp
+++ b/src/compressor.cpp
@@ -7,7 +7,6 @@
 
 #include <pubkey.h>
 #include <script/script.h>
-#include <script/standard.h>
 
 /*
  * These check for scripts for which a special case with a shorter encoding is defined.
diff --git a/src/init.cpp b/src/init.cpp
index 33389e695ce..ae5f35f8d3f 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -65,7 +65,6 @@
 #include <rpc/util.h>
 #include <scheduler.h>
 #include <script/sigcache.h>
-#include <script/standard.h>
 #include <shutdown.h>
 #include <sync.h>
 #include <timedata.h>
diff --git a/src/kernel/mempool_options.h b/src/kernel/mempool_options.h
index beb5fca5e9a..58bb3debbf0 100644
--- a/src/kernel/mempool_options.h
+++ b/src/kernel/mempool_options.h
@@ -8,7 +8,6 @@
 
 #include <policy/feerate.h>
 #include <policy/policy.h>
-#include <script/standard.h>
 
 #include <chrono>
 #include <cstdint>
diff --git a/src/key_io.cpp b/src/key_io.cpp
index 454a96df5e5..30fd964232a 100644
--- a/src/key_io.cpp
+++ b/src/key_io.cpp
@@ -6,6 +6,7 @@
 
 #include <base58.h>
 #include <bech32.h>
+#include <script/standard.h>
 #include <util/strencodings.h>
 
 #include <algorithm>
diff --git a/src/key_io.h b/src/key_io.h
index 6d2aface4cb..e387273e548 100644
--- a/src/key_io.h
+++ b/src/key_io.h
@@ -10,7 +10,6 @@
 #include <chainparams.h>
 #include <key.h>
 #include <pubkey.h>
-#include <script/standard.h>
 
 #include <string>
 
diff --git a/src/node/mempool_args.cpp b/src/node/mempool_args.cpp
index 5381902263b..7d8244980d1 100644
--- a/src/node/mempool_args.cpp
+++ b/src/node/mempool_args.cpp
@@ -13,7 +13,6 @@
 #include <logging.h>
 #include <policy/feerate.h>
 #include <policy/policy.h>
-#include <script/standard.h>
 #include <tinyformat.h>
 #include <util/error.h>
 #include <util/moneystr.h>
diff --git a/src/outputtype.cpp b/src/outputtype.cpp
index 9a3870d8dc9..566e5ec55ac 100644
--- a/src/outputtype.cpp
+++ b/src/outputtype.cpp
@@ -9,7 +9,6 @@
 #include <script/script.h>
 #include <script/sign.h>
 #include <script/signingprovider.h>
-#include <script/standard.h>
 #include <util/vector.h>
 
 #include <assert.h>
diff --git a/src/qt/guiutil.cpp b/src/qt/guiutil.cpp
index 8d8328aad8a..eb9c65caf28 100644
--- a/src/qt/guiutil.cpp
+++ b/src/qt/guiutil.cpp
@@ -10,6 +10,7 @@
 #include <qt/qvalidatedlineedit.h>
 #include <qt/sendcoinsrecipient.h>
 
+#include <addresstype.h>
 #include <base58.h>
 #include <chainparams.h>
 #include <common/args.h>
@@ -20,7 +21,6 @@
 #include <primitives/transaction.h>
 #include <protocol.h>
 #include <script/script.h>
-#include <script/standard.h>
 #include <util/chaintype.h>
 #include <util/exception.h>
 #include <util/fs.h>
diff --git a/src/qt/test/wallettests.cpp b/src/qt/test/wallettests.cpp
index 5f789e400ef..b3b0e85c94e 100644
--- a/src/qt/test/wallettests.cpp
+++ b/src/qt/test/wallettests.cpp
@@ -24,6 +24,7 @@
 #include <qt/transactiontablemodel.h>
 #include <qt/transactionview.h>
 #include <qt/walletmodel.h>
+#include <script/standard.h>
 #include <test/util/setup_common.h>
 #include <validation.h>
 #include <wallet/test/util.h>
diff --git a/src/qt/walletmodel.h b/src/qt/walletmodel.h
index 4f75d41404a..68218b0c1b3 100644
--- a/src/qt/walletmodel.h
+++ b/src/qt/walletmodel.h
@@ -10,7 +10,6 @@
 #endif
 
 #include <key.h>
-#include <script/standard.h>
 
 #include <qt/walletmodeltransaction.h>
 
diff --git a/src/rpc/mempool.cpp b/src/rpc/mempool.cpp
index 11d2874961d..e8a3979469c 100644
--- a/src/rpc/mempool.cpp
+++ b/src/rpc/mempool.cpp
@@ -17,7 +17,6 @@
 #include <rpc/server.h>
 #include <rpc/server_util.h>
 #include <rpc/util.h>
-#include <script/standard.h>
 #include <txmempool.h>
 #include <univalue.h>
 #include <util/fs.h>
diff --git a/src/rpc/output_script.cpp b/src/rpc/output_script.cpp
index 990ec3ab0c6..4dd424fa147 100644
--- a/src/rpc/output_script.cpp
+++ b/src/rpc/output_script.cpp
@@ -13,7 +13,6 @@
 #include <script/descriptor.h>
 #include <script/script.h>
 #include <script/signingprovider.h>
-#include <script/standard.h>
 #include <tinyformat.h>
 #include <univalue.h>
 #include <util/check.h>
diff --git a/src/rpc/util.cpp b/src/rpc/util.cpp
index faae840d40f..4c1aa9ee039 100644
--- a/src/rpc/util.cpp
+++ b/src/rpc/util.cpp
@@ -12,6 +12,7 @@
 #include <rpc/util.h>
 #include <script/descriptor.h>
 #include <script/signingprovider.h>
+#include <script/standard.h>
 #include <tinyformat.h>
 #include <util/check.h>
 #include <util/result.h>
diff --git a/src/rpc/util.h b/src/rpc/util.h
index 02d26f1ab7b..ac0b2c088ee 100644
--- a/src/rpc/util.h
+++ b/src/rpc/util.h
@@ -5,6 +5,7 @@
 #ifndef BITCOIN_RPC_UTIL_H
 #define BITCOIN_RPC_UTIL_H
 
+#include <addresstype.h>
 #include <node/transaction.h>
 #include <outputtype.h>
 #include <protocol.h>
@@ -13,7 +14,6 @@
 #include <rpc/request.h>
 #include <script/script.h>
 #include <script/sign.h>
-#include <script/standard.h>
 #include <univalue.h>
 #include <util/check.h>
 
diff --git a/src/script/miniscript.cpp b/src/script/miniscript.cpp
index 3937638cf80..19556a97753 100644
--- a/src/script/miniscript.cpp
+++ b/src/script/miniscript.cpp
@@ -5,7 +5,6 @@
 #include <string>
 #include <vector>
 #include <script/script.h>
-#include <script/standard.h>
 #include <script/miniscript.h>
 
 #include <assert.h>
diff --git a/src/script/sign.h b/src/script/sign.h
index b8806876a21..4d7dade44ef 100644
--- a/src/script/sign.h
+++ b/src/script/sign.h
@@ -12,7 +12,6 @@
 #include <pubkey.h>
 #include <script/interpreter.h>
 #include <script/keyorigin.h>
-#include <script/standard.h>
 #include <script/signingprovider.h>
 #include <uint256.h>
 
diff --git a/src/script/signingprovider.cpp b/src/script/signingprovider.cpp
index 248305c82ea..f3a69e5d21e 100644
--- a/src/script/signingprovider.cpp
+++ b/src/script/signingprovider.cpp
@@ -6,7 +6,6 @@
 #include <script/keyorigin.h>
 #include <script/interpreter.h>
 #include <script/signingprovider.h>
-#include <script/standard.h>
 
 #include <logging.h>
 
diff --git a/src/script/signingprovider.h b/src/script/signingprovider.h
index 40927f57bcd..712e2e73d1b 100644
--- a/src/script/signingprovider.h
+++ b/src/script/signingprovider.h
@@ -12,7 +12,6 @@
 #include <pubkey.h>
 #include <script/keyorigin.h>
 #include <script/script.h>
-#include <script/standard.h>
 #include <sync.h>
 
 struct ShortestVectorFirstComparator
diff --git a/src/signet.cpp b/src/signet.cpp
index b73d82bb2e8..21b289b637b 100644
--- a/src/signet.cpp
+++ b/src/signet.cpp
@@ -18,7 +18,6 @@
 #include <primitives/block.h>
 #include <primitives/transaction.h>
 #include <script/interpreter.h>
-#include <script/standard.h>
 #include <span.h>
 #include <streams.h>
 #include <uint256.h>
diff --git a/src/test/blockfilter_index_tests.cpp b/src/test/blockfilter_index_tests.cpp
index cd90448e28a..97ea5cfbf3b 100644
--- a/src/test/blockfilter_index_tests.cpp
+++ b/src/test/blockfilter_index_tests.cpp
@@ -11,7 +11,6 @@
 #include <interfaces/chain.h>
 #include <node/miner.h>
 #include <pow.h>
-#include <script/standard.h>
 #include <test/util/blockfilter.h>
 #include <test/util/index.h>
 #include <test/util/setup_common.h>
diff --git a/src/test/blockmanager_tests.cpp b/src/test/blockmanager_tests.cpp
index f52c692649e..224a00ce466 100644
--- a/src/test/blockmanager_tests.cpp
+++ b/src/test/blockmanager_tests.cpp
@@ -6,6 +6,7 @@
 #include <node/blockstorage.h>
 #include <node/context.h>
 #include <node/kernel_notifications.h>
+#include <script/standard.h>
 #include <util/chaintype.h>
 #include <validation.h>
 
diff --git a/src/test/coins_tests.cpp b/src/test/coins_tests.cpp
index f8a29179781..12dc4d1ccc4 100644
--- a/src/test/coins_tests.cpp
+++ b/src/test/coins_tests.cpp
@@ -5,7 +5,6 @@
 #include <addresstype.h>
 #include <clientversion.h>
 #include <coins.h>
-#include <script/standard.h>
 #include <streams.h>
 #include <test/util/poolresourcetester.h>
 #include <test/util/random.h>
diff --git a/src/test/compress_tests.cpp b/src/test/compress_tests.cpp
index bf9aba1868c..b56629ae40d 100644
--- a/src/test/compress_tests.cpp
+++ b/src/test/compress_tests.cpp
@@ -4,7 +4,6 @@
 
 #include <compressor.h>
 #include <script/script.h>
-#include <script/standard.h>
 #include <test/util/setup_common.h>
 
 #include <stdint.h>
diff --git a/src/test/denialofservice_tests.cpp b/src/test/denialofservice_tests.cpp
index b740a515743..90e5bb34ed3 100644
--- a/src/test/denialofservice_tests.cpp
+++ b/src/test/denialofservice_tests.cpp
@@ -12,7 +12,6 @@
 #include <pubkey.h>
 #include <script/sign.h>
 #include <script/signingprovider.h>
-#include <script/standard.h>
 #include <serialize.h>
 #include <test/util/net.h>
 #include <test/util/random.h>
diff --git a/src/test/descriptor_tests.cpp b/src/test/descriptor_tests.cpp
index 5cec0b07c95..829afab8dad 100644
--- a/src/test/descriptor_tests.cpp
+++ b/src/test/descriptor_tests.cpp
@@ -5,7 +5,6 @@
 #include <pubkey.h>
 #include <script/descriptor.h>
 #include <script/sign.h>
-#include <script/standard.h>
 #include <test/util/setup_common.h>
 #include <util/strencodings.h>
 
diff --git a/src/test/fuzz/integer.cpp b/src/test/fuzz/integer.cpp
index 54f968c53cb..849618d748c 100644
--- a/src/test/fuzz/integer.cpp
+++ b/src/test/fuzz/integer.cpp
@@ -20,7 +20,6 @@
 #include <protocol.h>
 #include <pubkey.h>
 #include <script/script.h>
-#include <script/standard.h>
 #include <serialize.h>
 #include <streams.h>
 #include <test/fuzz/FuzzedDataProvider.h>
diff --git a/src/test/fuzz/util.h b/src/test/fuzz/util.h
index 2d612a82721..736311ed55d 100644
--- a/src/test/fuzz/util.h
+++ b/src/test/fuzz/util.h
@@ -14,7 +14,6 @@
 #include <merkleblock.h>
 #include <primitives/transaction.h>
 #include <script/script.h>
-#include <script/standard.h>
 #include <serialize.h>
 #include <streams.h>
 #include <test/fuzz/FuzzedDataProvider.h>
diff --git a/src/test/interfaces_tests.cpp b/src/test/interfaces_tests.cpp
index 68377e197f2..07f6175debd 100644
--- a/src/test/interfaces_tests.cpp
+++ b/src/test/interfaces_tests.cpp
@@ -5,8 +5,8 @@
 #include <chainparams.h>
 #include <consensus/validation.h>
 #include <interfaces/chain.h>
-#include <script/standard.h>
 #include <test/util/setup_common.h>
+#include <script/standard.h>
 #include <validation.h>
 
 #include <boost/test/unit_test.hpp>
diff --git a/src/test/miner_tests.cpp b/src/test/miner_tests.cpp
index ea13989eb33..b4c7cac223b 100644
--- a/src/test/miner_tests.cpp
+++ b/src/test/miner_tests.cpp
@@ -10,7 +10,6 @@
 #include <consensus/tx_verify.h>
 #include <node/miner.h>
 #include <policy/policy.h>
-#include <script/standard.h>
 #include <test/util/random.h>
 #include <test/util/txmempool.h>
 #include <timedata.h>
diff --git a/src/test/miniscript_tests.cpp b/src/test/miniscript_tests.cpp
index 2a67da5cabe..0cb58450e87 100644
--- a/src/test/miniscript_tests.cpp
+++ b/src/test/miniscript_tests.cpp
@@ -19,7 +19,6 @@
 #include <crypto/sha256.h>
 #include <script/interpreter.h>
 #include <script/miniscript.h>
-#include <script/standard.h>
 #include <script/script_error.h>
 
 namespace {
diff --git a/src/test/orphanage_tests.cpp b/src/test/orphanage_tests.cpp
index a2c47743384..af53737fecb 100644
--- a/src/test/orphanage_tests.cpp
+++ b/src/test/orphanage_tests.cpp
@@ -6,7 +6,6 @@
 #include <pubkey.h>
 #include <script/sign.h>
 #include <script/signingprovider.h>
-#include <script/standard.h>
 #include <test/util/random.h>
 #include <test/util/setup_common.h>
 #include <txorphanage.h>
diff --git a/src/test/script_tests.cpp b/src/test/script_tests.cpp
index 411924496c3..1cf179c8e58 100644
--- a/src/test/script_tests.cpp
+++ b/src/test/script_tests.cpp
@@ -14,6 +14,7 @@
 #include <script/sigcache.h>
 #include <script/sign.h>
 #include <script/signingprovider.h>
+#include <script/standard.h>
 #include <streams.h>
 #include <test/util/json.h>
 #include <test/util/random.h>
diff --git a/src/test/txindex_tests.cpp b/src/test/txindex_tests.cpp
index 1471290d4be..9fa59bab578 100644
--- a/src/test/txindex_tests.cpp
+++ b/src/test/txindex_tests.cpp
@@ -6,7 +6,6 @@
 #include <chainparams.h>
 #include <index/txindex.h>
 #include <interfaces/chain.h>
-#include <script/standard.h>
 #include <test/util/index.h>
 #include <test/util/setup_common.h>
 #include <validation.h>
diff --git a/src/test/txpackage_tests.cpp b/src/test/txpackage_tests.cpp
index c08d2748a62..df5f8b4cce7 100644
--- a/src/test/txpackage_tests.cpp
+++ b/src/test/txpackage_tests.cpp
@@ -8,7 +8,6 @@
 #include <policy/policy.h>
 #include <primitives/transaction.h>
 #include <script/script.h>
-#include <script/standard.h>
 #include <test/util/random.h>
 #include <test/util/setup_common.h>
 #include <validation.h>
diff --git a/src/test/txvalidation_tests.cpp b/src/test/txvalidation_tests.cpp
index f06bef3589b..ecf08897117 100644
--- a/src/test/txvalidation_tests.cpp
+++ b/src/test/txvalidation_tests.cpp
@@ -8,7 +8,6 @@
 #include <policy/policy.h>
 #include <primitives/transaction.h>
 #include <script/script.h>
-#include <script/standard.h>
 #include <test/util/setup_common.h>
 #include <validation.h>
 
diff --git a/src/test/txvalidationcache_tests.cpp b/src/test/txvalidationcache_tests.cpp
index 8f8628169f1..c1f62269824 100644
--- a/src/test/txvalidationcache_tests.cpp
+++ b/src/test/txvalidationcache_tests.cpp
@@ -6,7 +6,6 @@
 #include <key.h>
 #include <script/sign.h>
 #include <script/signingprovider.h>
-#include <script/standard.h>
 #include <test/util/setup_common.h>
 #include <txmempool.h>
 #include <util/chaintype.h>
diff --git a/src/test/util/mining.cpp b/src/test/util/mining.cpp
index 51f4b89512a..08d1b4c9028 100644
--- a/src/test/util/mining.cpp
+++ b/src/test/util/mining.cpp
@@ -11,7 +11,6 @@
 #include <node/context.h>
 #include <pow.h>
 #include <primitives/transaction.h>
-#include <script/standard.h>
 #include <test/util/script.h>
 #include <util/check.h>
 #include <validation.h>
diff --git a/src/test/validation_block_tests.cpp b/src/test/validation_block_tests.cpp
index e08f2c98c27..d1463634cc2 100644
--- a/src/test/validation_block_tests.cpp
+++ b/src/test/validation_block_tests.cpp
@@ -10,7 +10,6 @@
 #include <node/miner.h>
 #include <pow.h>
 #include <random.h>
-#include <script/standard.h>
 #include <test/util/random.h>
 #include <test/util/script.h>
 #include <test/util/setup_common.h>
diff --git a/src/util/message.cpp b/src/util/message.cpp
index f8ea8247d5d..ec845aeffbd 100644
--- a/src/util/message.cpp
+++ b/src/util/message.cpp
@@ -7,7 +7,6 @@
 #include <key.h>
 #include <key_io.h>
 #include <pubkey.h>
-#include <script/standard.h>
 #include <uint256.h>
 #include <util/message.h>
 #include <util/strencodings.h>
diff --git a/src/wallet/coincontrol.h b/src/wallet/coincontrol.h
index 7ff8fee5bc0..71593e236f7 100644
--- a/src/wallet/coincontrol.h
+++ b/src/wallet/coincontrol.h
@@ -11,7 +11,6 @@
 #include <primitives/transaction.h>
 #include <script/keyorigin.h>
 #include <script/signingprovider.h>
-#include <script/standard.h>
 
 #include <algorithm>
 #include <map>
diff --git a/src/wallet/interfaces.cpp b/src/wallet/interfaces.cpp
index cd438cfe2f3..5f2aee6923e 100644
--- a/src/wallet/interfaces.cpp
+++ b/src/wallet/interfaces.cpp
@@ -11,7 +11,6 @@
 #include <policy/fees.h>
 #include <primitives/transaction.h>
 #include <rpc/server.h>
-#include <script/standard.h>
 #include <support/allocators/secure.h>
 #include <sync.h>
 #include <uint256.h>
diff --git a/src/wallet/rpc/addresses.cpp b/src/wallet/rpc/addresses.cpp
index dbd5c605118..d2d391daf40 100644
--- a/src/wallet/rpc/addresses.cpp
+++ b/src/wallet/rpc/addresses.cpp
@@ -6,6 +6,7 @@
 #include <key_io.h>
 #include <rpc/util.h>
 #include <script/script.h>
+#include <script/standard.h>
 #include <util/bip32.h>
 #include <util/translation.h>
 #include <wallet/receive.h>
diff --git a/src/wallet/scriptpubkeyman.cpp b/src/wallet/scriptpubkeyman.cpp
index 284bd531be8..6ece0433a2f 100644
--- a/src/wallet/scriptpubkeyman.cpp
+++ b/src/wallet/scriptpubkeyman.cpp
@@ -9,6 +9,7 @@
 #include <script/descriptor.h>
 #include <script/script.h>
 #include <script/sign.h>
+#include <script/standard.h>
 #include <util/bip32.h>
 #include <util/strencodings.h>
 #include <util/string.h>
diff --git a/src/wallet/scriptpubkeyman.h b/src/wallet/scriptpubkeyman.h
index c775d26c4f7..f03673e9d37 100644
--- a/src/wallet/scriptpubkeyman.h
+++ b/src/wallet/scriptpubkeyman.h
@@ -11,7 +11,6 @@
 #include <script/descriptor.h>
 #include <script/script.h>
 #include <script/signingprovider.h>
-#include <script/standard.h>
 #include <util/error.h>
 #include <util/message.h>
 #include <util/result.h>
diff --git a/src/wallet/spend.cpp b/src/wallet/spend.cpp
index 9358bbeebe9..49857316417 100644
--- a/src/wallet/spend.cpp
+++ b/src/wallet/spend.cpp
@@ -13,6 +13,7 @@
 #include <primitives/transaction.h>
 #include <script/script.h>
 #include <script/signingprovider.h>
+#include <script/standard.h>
 #include <util/check.h>
 #include <util/fees.h>
 #include <util/moneystr.h>
diff --git a/src/wallet/test/ismine_tests.cpp b/src/wallet/test/ismine_tests.cpp
index 8fdfaf946ef..d06bcba6cf9 100644
--- a/src/wallet/test/ismine_tests.cpp
+++ b/src/wallet/test/ismine_tests.cpp
@@ -6,8 +6,8 @@
 #include <key_io.h>
 #include <node/context.h>
 #include <script/script.h>
-#include <script/signingprovider.h>
 #include <script/standard.h>
+#include <script/signingprovider.h>
 #include <test/util/setup_common.h>
 #include <wallet/types.h>
 #include <wallet/wallet.h>
diff --git a/src/wallet/test/scriptpubkeyman_tests.cpp b/src/wallet/test/scriptpubkeyman_tests.cpp
index d4997c418ab..d3d5aa578cb 100644
--- a/src/wallet/test/scriptpubkeyman_tests.cpp
+++ b/src/wallet/test/scriptpubkeyman_tests.cpp
@@ -3,8 +3,8 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <key.h>
-#include <script/standard.h>
 #include <test/util/setup_common.h>
+#include <script/standard.h>
 #include <wallet/scriptpubkeyman.h>
 #include <wallet/wallet.h>
 #include <wallet/test/util.h>
diff --git a/src/wallet/test/spend_tests.cpp b/src/wallet/test/spend_tests.cpp
index 6e87d1cb493..3dbb0a8c340 100644
--- a/src/wallet/test/spend_tests.cpp
+++ b/src/wallet/test/spend_tests.cpp
@@ -4,6 +4,7 @@
 
 #include <consensus/amount.h>
 #include <policy/fees.h>
+#include <script/standard.h>
 #include <validation.h>
 #include <wallet/coincontrol.h>
 #include <wallet/spend.h>
diff --git a/src/wallet/test/wallet_tests.cpp b/src/wallet/test/wallet_tests.cpp
index 1c128a85df8..26285b936d5 100644
--- a/src/wallet/test/wallet_tests.cpp
+++ b/src/wallet/test/wallet_tests.cpp
@@ -15,6 +15,7 @@
 #include <node/blockstorage.h>
 #include <policy/policy.h>
 #include <rpc/server.h>
+#include <script/standard.h>
 #include <test/util/logging.h>
 #include <test/util/random.h>
 #include <test/util/setup_common.h>
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
index 6b2755ea530..91fbd0c9bec 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -26,6 +26,7 @@
 #include <script/descriptor.h>
 #include <script/script.h>
 #include <script/signingprovider.h>
+#include <script/standard.h>
 #include <support/cleanse.h>
 #include <txmempool.h>
 #include <util/bip32.h>
diff --git a/src/wallet/walletdb.h b/src/wallet/walletdb.h
index 8f7c2f030c9..dad0b18a78e 100644
--- a/src/wallet/walletdb.h
+++ b/src/wallet/walletdb.h
@@ -7,7 +7,6 @@
 #define BITCOIN_WALLET_WALLETDB_H
 
 #include <script/sign.h>
-#include <script/standard.h>
 #include <wallet/db.h>
 #include <wallet/walletutil.h>
 #include <key.h>

From bacdb2e208531124e85ed2d4ea2a4b508fbb5088 Mon Sep 17 00:00:00 2001
From: Andrew Chow <github@achow101.com>
Date: Wed, 9 Aug 2023 07:28:55 -0400
Subject: [PATCH 8/9] Clean up script/standard.{h/cpp} includes

---
 src/key_io.cpp                |  1 +
 src/script/standard.cpp       |  6 ++----
 src/script/standard.h         | 13 ++++++-------
 src/test/sigopcount_tests.cpp |  1 +
 4 files changed, 10 insertions(+), 11 deletions(-)

diff --git a/src/key_io.cpp b/src/key_io.cpp
index 30fd964232a..b7fe4d2423a 100644
--- a/src/key_io.cpp
+++ b/src/key_io.cpp
@@ -6,6 +6,7 @@
 
 #include <base58.h>
 #include <bech32.h>
+#include <script/interpreter.h>
 #include <script/standard.h>
 #include <util/strencodings.h>
 
diff --git a/src/script/standard.cpp b/src/script/standard.cpp
index 6cbcf9a016b..40ae381f0fb 100644
--- a/src/script/standard.cpp
+++ b/src/script/standard.cpp
@@ -4,15 +4,13 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <script/standard.h>
-
-#include <crypto/sha256.h>
-#include <hash.h>
 #include <pubkey.h>
 #include <script/interpreter.h>
 #include <script/script.h>
-#include <util/strencodings.h>
+#include <span.h>
 
 #include <string>
+#include <algorithm>
 
 typedef std::vector<unsigned char> valtype;
 
diff --git a/src/script/standard.h b/src/script/standard.h
index 53987ed2443..2b743776b41 100644
--- a/src/script/standard.h
+++ b/src/script/standard.h
@@ -7,16 +7,15 @@
 #define BITCOIN_SCRIPT_STANDARD_H
 
 #include <attributes.h>
-#include <pubkey.h>
-#include <script/interpreter.h>
-#include <uint256.h>
-#include <util/hash_type.h>
+#include <script/script.h>
 
-#include <map>
 #include <string>
-#include <variant>
+#include <optional>
+#include <utility>
+#include <vector>
 
-class CScript;
+class CPubKey;
+template <typename C> class Span;
 
 enum class TxoutType {
     NONSTANDARD,
diff --git a/src/test/sigopcount_tests.cpp b/src/test/sigopcount_tests.cpp
index e20b591c807..825413e0235 100644
--- a/src/test/sigopcount_tests.cpp
+++ b/src/test/sigopcount_tests.cpp
@@ -8,6 +8,7 @@
 #include <consensus/tx_verify.h>
 #include <key.h>
 #include <pubkey.h>
+#include <script/interpreter.h>
 #include <script/script.h>
 #include <script/standard.h>
 #include <test/util/setup_common.h>

From 91d924ede1b421df31c895f4f43359e453a09ca5 Mon Sep 17 00:00:00 2001
From: Andrew Chow <github@achow101.com>
Date: Wed, 9 Aug 2023 07:36:08 -0400
Subject: [PATCH 9/9] Rename script/standard.{cpp/h} to script/solver.{cpp/h}

Since script/standard only contains things that are used by the Solver
and its callers, rename the files to script/solver.
---
 src/Makefile.am                           | 6 +++---
 src/addresstype.cpp                       | 2 +-
 src/common/bloom.cpp                      | 2 +-
 src/core_write.cpp                        | 2 +-
 src/key_io.cpp                            | 2 +-
 src/policy/policy.cpp                     | 2 +-
 src/policy/policy.h                       | 2 +-
 src/qt/test/wallettests.cpp               | 2 +-
 src/rpc/rawtransaction.cpp                | 2 +-
 src/rpc/util.cpp                          | 2 +-
 src/script/descriptor.cpp                 | 2 +-
 src/script/sign.cpp                       | 2 +-
 src/script/{standard.cpp => solver.cpp}   | 2 +-
 src/script/{standard.h => solver.h}       | 8 +++++---
 src/test/blockmanager_tests.cpp           | 2 +-
 src/test/fuzz/key.cpp                     | 2 +-
 src/test/fuzz/script.cpp                  | 2 +-
 src/test/interfaces_tests.cpp             | 2 +-
 src/test/script_standard_tests.cpp        | 2 +-
 src/test/script_tests.cpp                 | 2 +-
 src/test/sigopcount_tests.cpp             | 2 +-
 src/test/transaction_tests.cpp            | 2 +-
 src/wallet/rpc/addresses.cpp              | 2 +-
 src/wallet/rpc/backup.cpp                 | 2 +-
 src/wallet/scriptpubkeyman.cpp            | 2 +-
 src/wallet/spend.cpp                      | 2 +-
 src/wallet/test/ismine_tests.cpp          | 2 +-
 src/wallet/test/scriptpubkeyman_tests.cpp | 2 +-
 src/wallet/test/spend_tests.cpp           | 2 +-
 src/wallet/test/wallet_tests.cpp          | 2 +-
 src/wallet/wallet.cpp                     | 2 +-
 31 files changed, 37 insertions(+), 35 deletions(-)
 rename src/script/{standard.cpp => solver.cpp} (99%)
 rename src/script/{standard.h => solver.h} (92%)

diff --git a/src/Makefile.am b/src/Makefile.am
index 3efc008e33e..c17953611fc 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -265,7 +265,7 @@ BITCOIN_CORE_H = \
   script/sigcache.h \
   script/sign.h \
   script/signingprovider.h \
-  script/standard.h \
+  script/solver.h \
   shutdown.h \
   signet.h \
   streams.h \
@@ -699,7 +699,7 @@ libbitcoin_common_a_SOURCES = \
   script/miniscript.cpp \
   script/sign.cpp \
   script/signingprovider.cpp \
-  script/standard.cpp \
+  script/solver.cpp \
   warnings.cpp \
   $(BITCOIN_CORE_H)
 
@@ -960,7 +960,7 @@ libbitcoinkernel_la_SOURCES = \
   script/script.cpp \
   script/script_error.cpp \
   script/sigcache.cpp \
-  script/standard.cpp \
+  script/solver.cpp \
   signet.cpp \
   streams.cpp \
   support/cleanse.cpp \
diff --git a/src/addresstype.cpp b/src/addresstype.cpp
index 96428df846e..d96b820bc7a 100644
--- a/src/addresstype.cpp
+++ b/src/addresstype.cpp
@@ -4,7 +4,7 @@
 
 #include <addresstype.h>
 #include <script/script.h>
-#include <script/standard.h>
+#include <script/solver.h>
 #include <hash.h>
 #include <pubkey.h>
 #include <uint256.h>
diff --git a/src/common/bloom.cpp b/src/common/bloom.cpp
index fd3276b5a7f..5c3ad882a1c 100644
--- a/src/common/bloom.cpp
+++ b/src/common/bloom.cpp
@@ -8,7 +8,7 @@
 #include <primitives/transaction.h>
 #include <random.h>
 #include <script/script.h>
-#include <script/standard.h>
+#include <script/solver.h>
 #include <span.h>
 #include <streams.h>
 #include <util/fastrange.h>
diff --git a/src/core_write.cpp b/src/core_write.cpp
index 54ca306f601..7cf019a42e7 100644
--- a/src/core_write.cpp
+++ b/src/core_write.cpp
@@ -11,7 +11,7 @@
 #include <key_io.h>
 #include <script/descriptor.h>
 #include <script/script.h>
-#include <script/standard.h>
+#include <script/solver.h>
 #include <serialize.h>
 #include <streams.h>
 #include <undo.h>
diff --git a/src/key_io.cpp b/src/key_io.cpp
index b7fe4d2423a..a0611656139 100644
--- a/src/key_io.cpp
+++ b/src/key_io.cpp
@@ -7,7 +7,7 @@
 #include <base58.h>
 #include <bech32.h>
 #include <script/interpreter.h>
-#include <script/standard.h>
+#include <script/solver.h>
 #include <util/strencodings.h>
 
 #include <algorithm>
diff --git a/src/policy/policy.cpp b/src/policy/policy.cpp
index 41b5b2d0f18..d08ec4fb7f7 100644
--- a/src/policy/policy.cpp
+++ b/src/policy/policy.cpp
@@ -15,7 +15,7 @@
 #include <primitives/transaction.h>
 #include <script/interpreter.h>
 #include <script/script.h>
-#include <script/standard.h>
+#include <script/solver.h>
 #include <serialize.h>
 #include <span.h>
 
diff --git a/src/policy/policy.h b/src/policy/policy.h
index 79e6725e73f..687d1881cba 100644
--- a/src/policy/policy.h
+++ b/src/policy/policy.h
@@ -10,7 +10,7 @@
 #include <consensus/consensus.h>
 #include <primitives/transaction.h>
 #include <script/interpreter.h>
-#include <script/standard.h>
+#include <script/solver.h>
 
 #include <cstdint>
 #include <string>
diff --git a/src/qt/test/wallettests.cpp b/src/qt/test/wallettests.cpp
index b3b0e85c94e..f5b86f44a61 100644
--- a/src/qt/test/wallettests.cpp
+++ b/src/qt/test/wallettests.cpp
@@ -24,7 +24,7 @@
 #include <qt/transactiontablemodel.h>
 #include <qt/transactionview.h>
 #include <qt/walletmodel.h>
-#include <script/standard.h>
+#include <script/solver.h>
 #include <test/util/setup_common.h>
 #include <validation.h>
 #include <wallet/test/util.h>
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
index eb0200ccf5f..9198529378d 100644
--- a/src/rpc/rawtransaction.cpp
+++ b/src/rpc/rawtransaction.cpp
@@ -30,7 +30,7 @@
 #include <script/script.h>
 #include <script/sign.h>
 #include <script/signingprovider.h>
-#include <script/standard.h>
+#include <script/solver.h>
 #include <uint256.h>
 #include <undo.h>
 #include <util/bip32.h>
diff --git a/src/rpc/util.cpp b/src/rpc/util.cpp
index 4c1aa9ee039..2732f1297ac 100644
--- a/src/rpc/util.cpp
+++ b/src/rpc/util.cpp
@@ -12,7 +12,7 @@
 #include <rpc/util.h>
 #include <script/descriptor.h>
 #include <script/signingprovider.h>
-#include <script/standard.h>
+#include <script/solver.h>
 #include <tinyformat.h>
 #include <util/check.h>
 #include <util/result.h>
diff --git a/src/script/descriptor.cpp b/src/script/descriptor.cpp
index 3d8497ef19d..436ea9c093a 100644
--- a/src/script/descriptor.cpp
+++ b/src/script/descriptor.cpp
@@ -10,7 +10,7 @@
 #include <script/miniscript.h>
 #include <script/script.h>
 #include <script/signingprovider.h>
-#include <script/standard.h>
+#include <script/solver.h>
 #include <uint256.h>
 
 #include <common/args.h>
diff --git a/src/script/sign.cpp b/src/script/sign.cpp
index c28773ed0eb..92b7ad50b57 100644
--- a/src/script/sign.cpp
+++ b/src/script/sign.cpp
@@ -13,7 +13,7 @@
 #include <script/miniscript.h>
 #include <script/script.h>
 #include <script/signingprovider.h>
-#include <script/standard.h>
+#include <script/solver.h>
 #include <uint256.h>
 #include <util/translation.h>
 #include <util/vector.h>
diff --git a/src/script/standard.cpp b/src/script/solver.cpp
similarity index 99%
rename from src/script/standard.cpp
rename to src/script/solver.cpp
index 40ae381f0fb..1cd388b061a 100644
--- a/src/script/standard.cpp
+++ b/src/script/solver.cpp
@@ -3,7 +3,7 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include <script/standard.h>
+#include <script/solver.h>
 #include <pubkey.h>
 #include <script/interpreter.h>
 #include <script/script.h>
diff --git a/src/script/standard.h b/src/script/solver.h
similarity index 92%
rename from src/script/standard.h
rename to src/script/solver.h
index 2b743776b41..dc8f4c357d5 100644
--- a/src/script/standard.h
+++ b/src/script/solver.h
@@ -3,8 +3,10 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#ifndef BITCOIN_SCRIPT_STANDARD_H
-#define BITCOIN_SCRIPT_STANDARD_H
+// The Solver functions are used by policy and the wallet, but not consensus.
+
+#ifndef BITCOIN_SCRIPT_SOLVER_H
+#define BITCOIN_SCRIPT_SOLVER_H
 
 #include <attributes.h>
 #include <script/script.h>
@@ -61,4 +63,4 @@ std::optional<std::pair<int, std::vector<Span<const unsigned char>>>> MatchMulti
 /** Generate a multisig script. */
 CScript GetScriptForMultisig(int nRequired, const std::vector<CPubKey>& keys);
 
-#endif // BITCOIN_SCRIPT_STANDARD_H
+#endif // BITCOIN_SCRIPT_SOLVER_H
diff --git a/src/test/blockmanager_tests.cpp b/src/test/blockmanager_tests.cpp
index 224a00ce466..553bb31ba1f 100644
--- a/src/test/blockmanager_tests.cpp
+++ b/src/test/blockmanager_tests.cpp
@@ -6,7 +6,7 @@
 #include <node/blockstorage.h>
 #include <node/context.h>
 #include <node/kernel_notifications.h>
-#include <script/standard.h>
+#include <script/solver.h>
 #include <util/chaintype.h>
 #include <validation.h>
 
diff --git a/src/test/fuzz/key.cpp b/src/test/fuzz/key.cpp
index 8faeb9e04fb..a5a579d9827 100644
--- a/src/test/fuzz/key.cpp
+++ b/src/test/fuzz/key.cpp
@@ -13,7 +13,7 @@
 #include <script/script.h>
 #include <script/sign.h>
 #include <script/signingprovider.h>
-#include <script/standard.h>
+#include <script/solver.h>
 #include <streams.h>
 #include <test/fuzz/FuzzedDataProvider.h>
 #include <test/fuzz/fuzz.h>
diff --git a/src/test/fuzz/script.cpp b/src/test/fuzz/script.cpp
index 1cb7d019061..acc82f55f6c 100644
--- a/src/test/fuzz/script.cpp
+++ b/src/test/fuzz/script.cpp
@@ -16,7 +16,7 @@
 #include <script/script_error.h>
 #include <script/sign.h>
 #include <script/signingprovider.h>
-#include <script/standard.h>
+#include <script/solver.h>
 #include <streams.h>
 #include <test/fuzz/FuzzedDataProvider.h>
 #include <test/fuzz/fuzz.h>
diff --git a/src/test/interfaces_tests.cpp b/src/test/interfaces_tests.cpp
index 07f6175debd..29f0aea3b16 100644
--- a/src/test/interfaces_tests.cpp
+++ b/src/test/interfaces_tests.cpp
@@ -6,7 +6,7 @@
 #include <consensus/validation.h>
 #include <interfaces/chain.h>
 #include <test/util/setup_common.h>
-#include <script/standard.h>
+#include <script/solver.h>
 #include <validation.h>
 
 #include <boost/test/unit_test.hpp>
diff --git a/src/test/script_standard_tests.cpp b/src/test/script_standard_tests.cpp
index 884e3d0634f..1a205728d6e 100644
--- a/src/test/script_standard_tests.cpp
+++ b/src/test/script_standard_tests.cpp
@@ -8,7 +8,7 @@
 #include <key_io.h>
 #include <script/script.h>
 #include <script/signingprovider.h>
-#include <script/standard.h>
+#include <script/solver.h>
 #include <test/util/setup_common.h>
 #include <util/strencodings.h>
 
diff --git a/src/test/script_tests.cpp b/src/test/script_tests.cpp
index 1cf179c8e58..d63bfb96032 100644
--- a/src/test/script_tests.cpp
+++ b/src/test/script_tests.cpp
@@ -14,7 +14,7 @@
 #include <script/sigcache.h>
 #include <script/sign.h>
 #include <script/signingprovider.h>
-#include <script/standard.h>
+#include <script/solver.h>
 #include <streams.h>
 #include <test/util/json.h>
 #include <test/util/random.h>
diff --git a/src/test/sigopcount_tests.cpp b/src/test/sigopcount_tests.cpp
index 825413e0235..ec9490d7456 100644
--- a/src/test/sigopcount_tests.cpp
+++ b/src/test/sigopcount_tests.cpp
@@ -10,7 +10,7 @@
 #include <pubkey.h>
 #include <script/interpreter.h>
 #include <script/script.h>
-#include <script/standard.h>
+#include <script/solver.h>
 #include <test/util/setup_common.h>
 #include <uint256.h>
 
diff --git a/src/test/transaction_tests.cpp b/src/test/transaction_tests.cpp
index 34dd2c3e9ff..a4c0db8aea5 100644
--- a/src/test/transaction_tests.cpp
+++ b/src/test/transaction_tests.cpp
@@ -19,7 +19,7 @@
 #include <script/script_error.h>
 #include <script/sign.h>
 #include <script/signingprovider.h>
-#include <script/standard.h>
+#include <script/solver.h>
 #include <streams.h>
 #include <test/util/json.h>
 #include <test/util/random.h>
diff --git a/src/wallet/rpc/addresses.cpp b/src/wallet/rpc/addresses.cpp
index d2d391daf40..c1b99a4f97e 100644
--- a/src/wallet/rpc/addresses.cpp
+++ b/src/wallet/rpc/addresses.cpp
@@ -6,7 +6,7 @@
 #include <key_io.h>
 #include <rpc/util.h>
 #include <script/script.h>
-#include <script/standard.h>
+#include <script/solver.h>
 #include <util/bip32.h>
 #include <util/translation.h>
 #include <wallet/receive.h>
diff --git a/src/wallet/rpc/backup.cpp b/src/wallet/rpc/backup.cpp
index af8043f158e..22c31436f13 100644
--- a/src/wallet/rpc/backup.cpp
+++ b/src/wallet/rpc/backup.cpp
@@ -12,7 +12,7 @@
 #include <rpc/util.h>
 #include <script/descriptor.h>
 #include <script/script.h>
-#include <script/standard.h>
+#include <script/solver.h>
 #include <sync.h>
 #include <uint256.h>
 #include <util/bip32.h>
diff --git a/src/wallet/scriptpubkeyman.cpp b/src/wallet/scriptpubkeyman.cpp
index 6ece0433a2f..1f510d1c58e 100644
--- a/src/wallet/scriptpubkeyman.cpp
+++ b/src/wallet/scriptpubkeyman.cpp
@@ -9,7 +9,7 @@
 #include <script/descriptor.h>
 #include <script/script.h>
 #include <script/sign.h>
-#include <script/standard.h>
+#include <script/solver.h>
 #include <util/bip32.h>
 #include <util/strencodings.h>
 #include <util/string.h>
diff --git a/src/wallet/spend.cpp b/src/wallet/spend.cpp
index 49857316417..c0ee00e0971 100644
--- a/src/wallet/spend.cpp
+++ b/src/wallet/spend.cpp
@@ -13,7 +13,7 @@
 #include <primitives/transaction.h>
 #include <script/script.h>
 #include <script/signingprovider.h>
-#include <script/standard.h>
+#include <script/solver.h>
 #include <util/check.h>
 #include <util/fees.h>
 #include <util/moneystr.h>
diff --git a/src/wallet/test/ismine_tests.cpp b/src/wallet/test/ismine_tests.cpp
index d06bcba6cf9..95d5c1b9ce8 100644
--- a/src/wallet/test/ismine_tests.cpp
+++ b/src/wallet/test/ismine_tests.cpp
@@ -6,7 +6,7 @@
 #include <key_io.h>
 #include <node/context.h>
 #include <script/script.h>
-#include <script/standard.h>
+#include <script/solver.h>
 #include <script/signingprovider.h>
 #include <test/util/setup_common.h>
 #include <wallet/types.h>
diff --git a/src/wallet/test/scriptpubkeyman_tests.cpp b/src/wallet/test/scriptpubkeyman_tests.cpp
index d3d5aa578cb..15bff04221d 100644
--- a/src/wallet/test/scriptpubkeyman_tests.cpp
+++ b/src/wallet/test/scriptpubkeyman_tests.cpp
@@ -4,7 +4,7 @@
 
 #include <key.h>
 #include <test/util/setup_common.h>
-#include <script/standard.h>
+#include <script/solver.h>
 #include <wallet/scriptpubkeyman.h>
 #include <wallet/wallet.h>
 #include <wallet/test/util.h>
diff --git a/src/wallet/test/spend_tests.cpp b/src/wallet/test/spend_tests.cpp
index 3dbb0a8c340..b5ea275bcb1 100644
--- a/src/wallet/test/spend_tests.cpp
+++ b/src/wallet/test/spend_tests.cpp
@@ -4,7 +4,7 @@
 
 #include <consensus/amount.h>
 #include <policy/fees.h>
-#include <script/standard.h>
+#include <script/solver.h>
 #include <validation.h>
 #include <wallet/coincontrol.h>
 #include <wallet/spend.h>
diff --git a/src/wallet/test/wallet_tests.cpp b/src/wallet/test/wallet_tests.cpp
index 26285b936d5..4abf6441d25 100644
--- a/src/wallet/test/wallet_tests.cpp
+++ b/src/wallet/test/wallet_tests.cpp
@@ -15,7 +15,7 @@
 #include <node/blockstorage.h>
 #include <policy/policy.h>
 #include <rpc/server.h>
-#include <script/standard.h>
+#include <script/solver.h>
 #include <test/util/logging.h>
 #include <test/util/random.h>
 #include <test/util/setup_common.h>
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
index 91fbd0c9bec..fd9a3e5a307 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -26,7 +26,7 @@
 #include <script/descriptor.h>
 #include <script/script.h>
 #include <script/signingprovider.h>
-#include <script/standard.h>
+#include <script/solver.h>
 #include <support/cleanse.h>
 #include <txmempool.h>
 #include <util/bip32.h>