diff --git a/doc/release-notes.md b/doc/release-notes.md
index 68d63ce7db..5b0bf0a0a6 100644
--- a/doc/release-notes.md
+++ b/doc/release-notes.md
@@ -1,9 +1,18 @@
 Bitcoin ABC version 0.20.11 is now available from:
 
   <https://download.bitcoinabc.org/0.20.11/>
 
 This release includes the following features and fixes:
  - The `prioritisetransaction` RPC no longer takes a `priority_delta` argument,
    which is replaced by a `dummy` argument for backwards compatibility with
    clients using positional arguments. The RPC is still used to change the
    apparent fee-rate of the transaction by using the `fee_delta` argument.
+ - Bare multisig outputs to our keys are no longer automatically treated as
+   incoming payments. As this feature was only available for multisig outputs for
+   which you had all private keys in your wallet, there was generally no use for
+   them compared to single-key schemes. Furthermore, no address format for such
+   outputs is defined, and wallet software can't easily send to it. These outputs
+   will no longer show up in `listtransactions`, `listunspent`, or contribute to
+   your balance, unless they are explicitly watched (using `importaddress` or
+   `importmulti` with hex script argument). `signrawtransaction*` also still
+   works for them.
diff --git a/src/script/ismine.cpp b/src/script/ismine.cpp
index 53715c03b8..611e1dad5b 100644
--- a/src/script/ismine.cpp
+++ b/src/script/ismine.cpp
@@ -1,105 +1,126 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <script/ismine.h>
 
 #include <key.h>
 #include <keystore.h>
 #include <script/script.h>
 #include <script/sign.h>
 #include <script/standard.h>
 
 typedef std::vector<uint8_t> valtype;
 
-static bool HaveKeys(const std::vector<valtype> &pubkeys,
-                     const CKeyStore &keystore) {
+namespace {
+
+/**
+ * This is an enum that tracks the execution context of a script, similar to
+ * SigVersion in script/interpreter. It is separate however because we want to
+ * distinguish between top-level scriptPubKey execution and P2SH redeemScript
+ * execution (a distinction that has no impact on consensus rules).
+ */
+enum class IsMineSigVersion {
+    TOP = 0,  //! scriptPubKey execution
+    P2SH = 1, //! P2SH redeemScript
+};
+
+bool HaveKeys(const std::vector<valtype> &pubkeys, const CKeyStore &keystore) {
     for (const valtype &pubkey : pubkeys) {
         CKeyID keyID = CPubKey(pubkey).GetID();
         if (!keystore.HaveKey(keyID)) {
             return false;
         }
     }
     return true;
 }
 
-isminetype IsMine(const CKeyStore &keystore, const CScript &scriptPubKey) {
-    bool isInvalid = false;
-    return IsMine(keystore, scriptPubKey, isInvalid);
-}
-
-isminetype IsMine(const CKeyStore &keystore, const CTxDestination &dest) {
-    bool isInvalid = false;
-    return IsMine(keystore, dest, isInvalid);
-}
-
-isminetype IsMine(const CKeyStore &keystore, const CTxDestination &dest,
-                  bool &isInvalid) {
-    CScript script = GetScriptForDestination(dest);
-    return IsMine(keystore, script, isInvalid);
-}
-
-isminetype IsMine(const CKeyStore &keystore, const CScript &scriptPubKey,
-                  bool &isInvalid) {
+isminetype IsMineInner(const CKeyStore &keystore, const CScript &scriptPubKey,
+                       bool &isInvalid, IsMineSigVersion sigversion) {
     isInvalid = false;
 
     std::vector<valtype> vSolutions;
     txnouttype whichType;
     if (!Solver(scriptPubKey, whichType, vSolutions)) {
         if (keystore.HaveWatchOnly(scriptPubKey))
             return ISMINE_WATCH_UNSOLVABLE;
         return ISMINE_NO;
     }
 
     CKeyID keyID;
     switch (whichType) {
         case TX_NONSTANDARD:
         case TX_NULL_DATA:
             break;
         case TX_PUBKEY:
             keyID = CPubKey(vSolutions[0]).GetID();
             if (keystore.HaveKey(keyID)) return ISMINE_SPENDABLE;
             break;
         case TX_PUBKEYHASH:
             keyID = CKeyID(uint160(vSolutions[0]));
             if (keystore.HaveKey(keyID)) return ISMINE_SPENDABLE;
             break;
         case TX_SCRIPTHASH: {
             CScriptID scriptID = CScriptID(uint160(vSolutions[0]));
             CScript subscript;
             if (keystore.GetCScript(scriptID, subscript)) {
-                isminetype ret = IsMine(keystore, subscript, isInvalid);
+                isminetype ret = IsMineInner(keystore, subscript, isInvalid,
+                                             IsMineSigVersion::P2SH);
                 if (ret == ISMINE_SPENDABLE || ret == ISMINE_WATCH_SOLVABLE ||
                     (ret == ISMINE_NO && isInvalid))
                     return ret;
             }
             break;
         }
         case TX_MULTISIG: {
+            // Never treat bare multisig outputs as ours (they can still be made
+            // watchonly-though)
+            if (sigversion == IsMineSigVersion::TOP) {
+                break;
+            }
+
             // Only consider transactions "mine" if we own ALL the keys
             // involved. Multi-signature transactions that are partially owned
             // (somebody else has a key that can spend them) enable
             // spend-out-from-under-you attacks, especially in shared-wallet
             // situations.
             std::vector<valtype> keys(vSolutions.begin() + 1,
                                       vSolutions.begin() + vSolutions.size() -
                                           1);
             if (HaveKeys(keys, keystore)) {
                 return ISMINE_SPENDABLE;
             }
             break;
         }
     }
 
     if (keystore.HaveWatchOnly(scriptPubKey)) {
         // TODO: This could be optimized some by doing some work after the above
         // solver
         SignatureData sigs;
         return ProduceSignature(keystore, DUMMY_SIGNATURE_CREATOR, scriptPubKey,
                                 sigs)
                    ? ISMINE_WATCH_SOLVABLE
                    : ISMINE_WATCH_UNSOLVABLE;
     }
     return ISMINE_NO;
 }
+
+} // namespace
+
+isminetype IsMine(const CKeyStore &keystore, const CScript &scriptPubKey,
+                  bool &isInvalid) {
+    return IsMineInner(keystore, scriptPubKey, isInvalid,
+                       IsMineSigVersion::TOP);
+}
+
+isminetype IsMine(const CKeyStore &keystore, const CScript &scriptPubKey) {
+    bool isInvalid = false;
+    return IsMine(keystore, scriptPubKey, isInvalid);
+}
+
+isminetype IsMine(const CKeyStore &keystore, const CTxDestination &dest) {
+    CScript script = GetScriptForDestination(dest);
+    return IsMine(keystore, script);
+}
diff --git a/src/script/ismine.h b/src/script/ismine.h
index 9c52832edb..28a9f113ce 100644
--- a/src/script/ismine.h
+++ b/src/script/ismine.h
@@ -1,48 +1,46 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_SCRIPT_ISMINE_H
 #define BITCOIN_SCRIPT_ISMINE_H
 
 #include <script/standard.h>
 
 #include <cstdint>
 
 class CKeyStore;
 class CScript;
 
 /** IsMine() return codes */
 enum isminetype {
     ISMINE_NO = 0,
     //! Indicates that we don't know how to create a scriptSig that would solve
     //! this if we were given the appropriate private keys
     ISMINE_WATCH_UNSOLVABLE = 1,
     //! Indicates that we know how to create a scriptSig that would solve this
     //! if we were given the appropriate private keys
     ISMINE_WATCH_SOLVABLE = 2,
     ISMINE_WATCH_ONLY = ISMINE_WATCH_SOLVABLE | ISMINE_WATCH_UNSOLVABLE,
     ISMINE_SPENDABLE = 4,
     ISMINE_ALL = ISMINE_WATCH_ONLY | ISMINE_SPENDABLE
 };
 
 /** used for bitflags of isminetype */
 typedef uint8_t isminefilter;
 
 /**
  * isInvalid becomes true when the script is found invalid by consensus or
  * policy. This will terminate the recursion and return ISMINE_NO immediately,
  * as an invalid script should never be considered as "mine". Currently the only
  * use of isInvalid is indicate uncompressed keys when
  * SCRIPT_VERIFY_COMPRESSED_PUBKEYTYPE is specified, but could also be used in
  * similar cases in the future.
  */
 isminetype IsMine(const CKeyStore &keystore, const CScript &scriptPubKey,
                   bool &isInvalid);
 isminetype IsMine(const CKeyStore &keystore, const CScript &scriptPubKey);
-isminetype IsMine(const CKeyStore &keystore, const CTxDestination &dest,
-                  bool &isInvalid);
 isminetype IsMine(const CKeyStore &keystore, const CTxDestination &dest);
 
 #endif // BITCOIN_SCRIPT_ISMINE_H
diff --git a/src/script/standard.h b/src/script/standard.h
index 7e01ee4a1c..7cefb98d70 100644
--- a/src/script/standard.h
+++ b/src/script/standard.h
@@ -1,142 +1,142 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // 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
 
 #include <amount.h>
 #include <pubkey.h>
 #include <script/script_flags.h>
 #include <uint256.h>
 
 #include <boost/variant.hpp>
 
 #include <cstdint>
 
 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 uint160 {
 public:
     CScriptID() : uint160() {}
-    CScriptID(const CScript &in);
+    explicit CScriptID(const CScript &in);
     CScriptID(const uint160 &in) : uint160(in) {}
 };
 
 /**
  * Default setting for nMaxDatacarrierBytes. 220 bytes of data, +1 for
  * OP_RETURN, +2 for the pushdata opcodes.
  */
 static const unsigned int MAX_OP_RETURN_RELAY = 223;
 
 /**
  * A data carrying output is an unspendable output containing data. The script
  * type is designated as TX_NULL_DATA.
  */
 extern bool fAcceptDatacarrier;
 
 /**
  * When transactions fail script evaluations under standard flags, this flagset
  * influences the decision of whether to drop them or to also ban the originator
  * (see CheckInputs).
  */
 static const uint32_t MANDATORY_SCRIPT_VERIFY_FLAGS =
     SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC |
     SCRIPT_ENABLE_SIGHASH_FORKID | SCRIPT_VERIFY_LOW_S |
     SCRIPT_VERIFY_NULLFAIL | SCRIPT_VERIFY_MINIMALDATA |
     SCRIPT_ENABLE_SCHNORR_MULTISIG;
 
 enum txnouttype {
     TX_NONSTANDARD,
     // 'standard' transaction types:
     TX_PUBKEY,
     TX_PUBKEYHASH,
     TX_SCRIPTHASH,
     TX_MULTISIG,
     // unspendable OP_RETURN script that carries data
     TX_NULL_DATA,
 };
 
 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;
     }
 };
 
 /**
  * A txout script template with a specific destination. It is either:
  *  * CNoDestination: no destination set
  *  * CKeyID: TX_PUBKEYHASH destination
  *  * CScriptID: TX_SCRIPTHASH destination
  *  A CTxDestination is the internal data type encoded in a bitcoin address
  */
 typedef boost::variant<CNoDestination, CKeyID, CScriptID> CTxDestination;
 
 /** Check whether a CTxDestination is a CNoDestination. */
 bool IsValidDestination(const CTxDestination &dest);
 
 /** Get the name of a txnouttype as a C string, or nullptr if unknown. */
 const char *GetTxnOutputType(txnouttype t);
 
 /**
  * Parse a scriptPubKey and identify script type for standard scripts. If
  * successful, returns script type and parsed pubkeys or hashes, depending on
  * the type. For example, for a P2SH script, vSolutionsRet will contain the
  * script hash, for P2PKH it will contain the key hash, etc.
  *
  * @param[in]   scriptPubKey   Script to parse
  * @param[out]  typeRet        The script type
  * @param[out]  vSolutionsRet  Vector of parsed pubkeys and hashes
  * @return                     True if script matches standard template
  */
 bool Solver(const CScript &scriptPubKey, txnouttype &typeRet,
             std::vector<std::vector<uint8_t>> &vSolutionsRet);
 
 /**
  * Parse a standard scriptPubKey for the destination address. Assigns result to
  * the addressRet parameter and returns true if successful. For multisig
  * scripts, instead use ExtractDestinations. Currently only works for P2PK,
  * P2PKH, and P2SH scripts.
  */
 bool ExtractDestination(const CScript &scriptPubKey,
                         CTxDestination &addressRet);
 
 /**
  * Parse a standard scriptPubKey with one or more destination addresses. For
  * multisig scripts, this populates the addressRet vector with the pubkey IDs
  * and nRequiredRet with the n required to spend. For other destinations,
  * addressRet is populated with a single value and nRequiredRet is set to 1.
  * Returns true if successful. Currently does not extract address from
  * pay-to-witness scripts.
  *
  * Note: this function confuses destinations (a subset of CScripts that are
  * encodable as an address) with key identifiers (of keys involved in a
  * CScript), and its use should be phased out.
  */
 bool ExtractDestinations(const CScript &scriptPubKey, txnouttype &typeRet,
                          std::vector<CTxDestination> &addressRet,
                          int &nRequiredRet);
 
 /**
  * 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);
 
 /** Generate a multisig script. */
 CScript GetScriptForMultisig(int nRequired, const std::vector<CPubKey> &keys);
 
 #endif // BITCOIN_SCRIPT_STANDARD_H
diff --git a/src/test/script_standard_tests.cpp b/src/test/script_standard_tests.cpp
index ba606267a4..cadc4ed865 100644
--- a/src/test/script_standard_tests.cpp
+++ b/src/test/script_standard_tests.cpp
@@ -1,657 +1,664 @@
 // Copyright (c) 2017 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <key.h>
 #include <keystore.h>
 #include <script/ismine.h>
 #include <script/script.h>
 #include <script/script_error.h>
 #include <script/standard.h>
 #include <test/test_bitcoin.h>
 
 #include <boost/test/unit_test.hpp>
 
 // Append given push onto a script, using specific opcode (not necessarily
 // the minimal one, but must be able to contain the given data.)
 void AppendPush(CScript &script, opcodetype opcode,
                 const std::vector<uint8_t> &b) {
     assert(opcode <= OP_PUSHDATA4);
     script.push_back(opcode);
     if (opcode < OP_PUSHDATA1) {
         assert(b.size() == opcode);
     } else if (opcode == OP_PUSHDATA1) {
         assert(b.size() <= 0xff);
         script.push_back(uint8_t(b.size()));
     } else if (opcode == OP_PUSHDATA2) {
         assert(b.size() <= 0xffff);
         uint8_t _data[2];
         WriteLE16(_data, b.size());
         script.insert(script.end(), _data, _data + sizeof(_data));
     } else if (opcode == OP_PUSHDATA4) {
         uint8_t _data[4];
         WriteLE32(_data, b.size());
         script.insert(script.end(), _data, _data + sizeof(_data));
     }
     script.insert(script.end(), b.begin(), b.end());
 }
 
 BOOST_FIXTURE_TEST_SUITE(script_standard_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(script_standard_Solver_success) {
     CKey keys[3];
     CPubKey pubkeys[3];
     for (int i = 0; i < 3; i++) {
         keys[i].MakeNewKey(true);
         pubkeys[i] = keys[i].GetPubKey();
     }
 
     CScript s;
     txnouttype whichType;
     std::vector<std::vector<uint8_t>> solutions;
 
     // TX_PUBKEY
     s.clear();
     s << ToByteVector(pubkeys[0]) << OP_CHECKSIG;
     BOOST_CHECK(Solver(s, whichType, solutions));
     BOOST_CHECK_EQUAL(whichType, TX_PUBKEY);
     BOOST_CHECK_EQUAL(solutions.size(), 1U);
     BOOST_CHECK(solutions[0] == ToByteVector(pubkeys[0]));
 
     // TX_PUBKEYHASH
     s.clear();
     s << OP_DUP << OP_HASH160 << ToByteVector(pubkeys[0].GetID())
       << OP_EQUALVERIFY << OP_CHECKSIG;
     BOOST_CHECK(Solver(s, whichType, solutions));
     BOOST_CHECK_EQUAL(whichType, TX_PUBKEYHASH);
     BOOST_CHECK_EQUAL(solutions.size(), 1U);
     BOOST_CHECK(solutions[0] == ToByteVector(pubkeys[0].GetID()));
 
     // TX_SCRIPTHASH
     CScript redeemScript(s); // initialize with leftover P2PKH script
     s.clear();
     s << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
     BOOST_CHECK(Solver(s, whichType, solutions));
     BOOST_CHECK_EQUAL(whichType, TX_SCRIPTHASH);
     BOOST_CHECK_EQUAL(solutions.size(), 1U);
     BOOST_CHECK(solutions[0] == ToByteVector(CScriptID(redeemScript)));
 
     // TX_MULTISIG
     s.clear();
     s << OP_1 << ToByteVector(pubkeys[0]) << ToByteVector(pubkeys[1]) << OP_2
       << OP_CHECKMULTISIG;
     BOOST_CHECK(Solver(s, whichType, solutions));
     BOOST_CHECK_EQUAL(whichType, TX_MULTISIG);
     BOOST_CHECK_EQUAL(solutions.size(), 4U);
     BOOST_CHECK(solutions[0] == std::vector<uint8_t>({1}));
     BOOST_CHECK(solutions[1] == ToByteVector(pubkeys[0]));
     BOOST_CHECK(solutions[2] == ToByteVector(pubkeys[1]));
     BOOST_CHECK(solutions[3] == std::vector<uint8_t>({2}));
 
     s.clear();
     s << OP_2 << ToByteVector(pubkeys[0]) << ToByteVector(pubkeys[1])
       << ToByteVector(pubkeys[2]) << OP_3 << OP_CHECKMULTISIG;
     BOOST_CHECK(Solver(s, whichType, solutions));
     BOOST_CHECK_EQUAL(whichType, TX_MULTISIG);
     BOOST_CHECK_EQUAL(solutions.size(), 5U);
     BOOST_CHECK(solutions[0] == std::vector<uint8_t>({2}));
     BOOST_CHECK(solutions[1] == ToByteVector(pubkeys[0]));
     BOOST_CHECK(solutions[2] == ToByteVector(pubkeys[1]));
     BOOST_CHECK(solutions[3] == ToByteVector(pubkeys[2]));
     BOOST_CHECK(solutions[4] == std::vector<uint8_t>({3}));
 
     // TX_NULL_DATA
     s.clear();
     s << OP_RETURN << std::vector<uint8_t>({0}) << std::vector<uint8_t>({75})
       << std::vector<uint8_t>({255});
     BOOST_CHECK(Solver(s, whichType, solutions));
     BOOST_CHECK_EQUAL(whichType, TX_NULL_DATA);
     BOOST_CHECK_EQUAL(solutions.size(), 0U);
 
     // TX_WITNESS_V0_KEYHASH
     s.clear();
     s << OP_0 << ToByteVector(pubkeys[0].GetID());
     BOOST_CHECK(!Solver(s, whichType, solutions));
     BOOST_CHECK_EQUAL(whichType, TX_NONSTANDARD);
     BOOST_CHECK_EQUAL(solutions.size(), 0U);
 
     // TX_WITNESS_V0_SCRIPTHASH
     uint256 scriptHash;
     CSHA256()
         .Write(&redeemScript[0], redeemScript.size())
         .Finalize(scriptHash.begin());
 
     s.clear();
     s << OP_0 << ToByteVector(scriptHash);
     BOOST_CHECK(!Solver(s, whichType, solutions));
     BOOST_CHECK_EQUAL(whichType, TX_NONSTANDARD);
     BOOST_CHECK_EQUAL(solutions.size(), 0U);
 
     // TX_NONSTANDARD
     s.clear();
     s << OP_9 << OP_ADD << OP_11 << OP_EQUAL;
     BOOST_CHECK(!Solver(s, whichType, solutions));
     BOOST_CHECK_EQUAL(whichType, TX_NONSTANDARD);
     BOOST_CHECK_EQUAL(solutions.size(), 0);
 
     // Try some non-minimal PUSHDATA pushes in various standard scripts
     for (auto pushdataop : {OP_PUSHDATA1, OP_PUSHDATA2, OP_PUSHDATA4}) {
         // mutated TX_PUBKEY
         s.clear();
         AppendPush(s, pushdataop, ToByteVector(pubkeys[0]));
         s << OP_CHECKSIG;
         BOOST_CHECK(!Solver(s, whichType, solutions));
         BOOST_CHECK_EQUAL(whichType, TX_NONSTANDARD);
         BOOST_CHECK_EQUAL(solutions.size(), 0);
 
         // mutated TX_PUBKEYHASH
         s.clear();
         s << OP_DUP << OP_HASH160;
         AppendPush(s, pushdataop, ToByteVector(pubkeys[0].GetID()));
         s << OP_EQUALVERIFY << OP_CHECKSIG;
         BOOST_CHECK(!Solver(s, whichType, solutions));
         BOOST_CHECK_EQUAL(whichType, TX_NONSTANDARD);
         BOOST_CHECK_EQUAL(solutions.size(), 0);
 
         // mutated TX_SCRIPTHASH
         s.clear();
         s << OP_HASH160;
         AppendPush(s, pushdataop, ToByteVector(CScriptID(redeemScript)));
         s << OP_EQUAL;
         BOOST_CHECK(!Solver(s, whichType, solutions));
         BOOST_CHECK_EQUAL(whichType, TX_NONSTANDARD);
         BOOST_CHECK_EQUAL(solutions.size(), 0);
 
         // mutated TX_MULTISIG -- pubkey
         s.clear();
         s << OP_1;
         AppendPush(s, pushdataop, ToByteVector(pubkeys[0]));
         s << ToByteVector(pubkeys[1]) << OP_2 << OP_CHECKMULTISIG;
         BOOST_CHECK(!Solver(s, whichType, solutions));
         BOOST_CHECK_EQUAL(whichType, TX_NONSTANDARD);
         BOOST_CHECK_EQUAL(solutions.size(), 0);
 
         // mutated TX_MULTISIG -- num_signatures
         s.clear();
         AppendPush(s, pushdataop, {1});
         s << ToByteVector(pubkeys[0]) << ToByteVector(pubkeys[1]) << OP_2
           << OP_CHECKMULTISIG;
         BOOST_CHECK(!Solver(s, whichType, solutions));
         BOOST_CHECK_EQUAL(whichType, TX_NONSTANDARD);
         BOOST_CHECK_EQUAL(solutions.size(), 0);
 
         // mutated TX_MULTISIG -- num_pubkeys
         s.clear();
         s << OP_1 << ToByteVector(pubkeys[0]) << ToByteVector(pubkeys[1]);
         AppendPush(s, pushdataop, {2});
         s << OP_CHECKMULTISIG;
         BOOST_CHECK(!Solver(s, whichType, solutions));
         BOOST_CHECK_EQUAL(whichType, TX_NONSTANDARD);
         BOOST_CHECK_EQUAL(solutions.size(), 0);
     }
 
     // also try pushing the num_signatures and num_pubkeys using PUSH_N opcode
     // instead of OP_N opcode:
     s.clear();
     s << std::vector<uint8_t>{1} << ToByteVector(pubkeys[0])
       << ToByteVector(pubkeys[1]) << OP_2 << OP_CHECKMULTISIG;
     BOOST_CHECK(!Solver(s, whichType, solutions));
     BOOST_CHECK_EQUAL(whichType, TX_NONSTANDARD);
     BOOST_CHECK_EQUAL(solutions.size(), 0);
     s.clear();
     s << OP_1 << ToByteVector(pubkeys[0]) << ToByteVector(pubkeys[1])
       << std::vector<uint8_t>{2} << OP_CHECKMULTISIG;
     BOOST_CHECK(!Solver(s, whichType, solutions));
     BOOST_CHECK_EQUAL(whichType, TX_NONSTANDARD);
     BOOST_CHECK_EQUAL(solutions.size(), 0);
 
     // Non-minimal pushes in OP_RETURN scripts are standard (some OP_RETURN
     // protocols like SLP rely on this). Also it turns out OP_RESERVED gets past
     // IsPushOnly and thus is standard here.
     std::vector<uint8_t> op_return_nonminimal{
         OP_RETURN,    OP_RESERVED, OP_PUSHDATA1, 0x00, 0x01, 0x01,
         OP_PUSHDATA4, 0x01,        0x00,         0x00, 0x00, 0xaa};
     s.assign(op_return_nonminimal.begin(), op_return_nonminimal.end());
     BOOST_CHECK(Solver(s, whichType, solutions));
     BOOST_CHECK_EQUAL(whichType, TX_NULL_DATA);
     BOOST_CHECK_EQUAL(solutions.size(), 0);
 }
 
 BOOST_AUTO_TEST_CASE(script_standard_Solver_failure) {
     CKey key;
     CPubKey pubkey;
     key.MakeNewKey(true);
     pubkey = key.GetPubKey();
 
     CScript s;
     txnouttype whichType;
     std::vector<std::vector<uint8_t>> solutions;
 
     // TX_PUBKEY with incorrectly sized pubkey
     s.clear();
     s << std::vector<uint8_t>(30, 0x01) << OP_CHECKSIG;
     BOOST_CHECK(!Solver(s, whichType, solutions));
 
     // TX_PUBKEYHASH with incorrectly sized key hash
     s.clear();
     s << OP_DUP << OP_HASH160 << ToByteVector(pubkey) << OP_EQUALVERIFY
       << OP_CHECKSIG;
     BOOST_CHECK(!Solver(s, whichType, solutions));
 
     // TX_SCRIPTHASH with incorrectly sized script hash
     s.clear();
     s << OP_HASH160 << std::vector<uint8_t>(21, 0x01) << OP_EQUAL;
     BOOST_CHECK(!Solver(s, whichType, solutions));
 
     // TX_MULTISIG 0/2
     s.clear();
     s << OP_0 << ToByteVector(pubkey) << OP_1 << OP_CHECKMULTISIG;
     BOOST_CHECK(!Solver(s, whichType, solutions));
 
     // TX_MULTISIG 2/1
     s.clear();
     s << OP_2 << ToByteVector(pubkey) << OP_1 << OP_CHECKMULTISIG;
     BOOST_CHECK(!Solver(s, whichType, solutions));
 
     // TX_MULTISIG n = 2 with 1 pubkey
     s.clear();
     s << OP_1 << ToByteVector(pubkey) << OP_2 << OP_CHECKMULTISIG;
     BOOST_CHECK(!Solver(s, whichType, solutions));
 
     // TX_MULTISIG n = 1 with 0 pubkeys
     s.clear();
     s << OP_1 << OP_1 << OP_CHECKMULTISIG;
     BOOST_CHECK(!Solver(s, whichType, solutions));
 
     // TX_NULL_DATA with other opcodes
     s.clear();
     s << OP_RETURN << std::vector<uint8_t>({75}) << OP_ADD;
     BOOST_CHECK(!Solver(s, whichType, solutions));
 
     // TX_WITNESS with unknown version
     s.clear();
     s << OP_1 << ToByteVector(pubkey);
     BOOST_CHECK(!Solver(s, whichType, solutions));
 
     // TX_WITNESS with incorrect program size
     s.clear();
     s << OP_0 << std::vector<uint8_t>(19, 0x01);
     BOOST_CHECK(!Solver(s, whichType, solutions));
 }
 
 BOOST_AUTO_TEST_CASE(script_standard_ExtractDestination) {
     CKey key;
     CPubKey pubkey;
     key.MakeNewKey(true);
     pubkey = key.GetPubKey();
 
     CScript s;
     CTxDestination address;
 
     // TX_PUBKEY
     s.clear();
     s << ToByteVector(pubkey) << OP_CHECKSIG;
     BOOST_CHECK(ExtractDestination(s, address));
     BOOST_CHECK(boost::get<CKeyID>(&address) &&
                 *boost::get<CKeyID>(&address) == pubkey.GetID());
 
     // TX_PUBKEYHASH
     s.clear();
     s << OP_DUP << OP_HASH160 << ToByteVector(pubkey.GetID()) << OP_EQUALVERIFY
       << OP_CHECKSIG;
     BOOST_CHECK(ExtractDestination(s, address));
     BOOST_CHECK(boost::get<CKeyID>(&address) &&
                 *boost::get<CKeyID>(&address) == pubkey.GetID());
 
     // TX_SCRIPTHASH
     CScript redeemScript(s); // initialize with leftover P2PKH script
     s.clear();
     s << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
     BOOST_CHECK(ExtractDestination(s, address));
     BOOST_CHECK(boost::get<CScriptID>(&address) &&
                 *boost::get<CScriptID>(&address) == CScriptID(redeemScript));
 
     // TX_MULTISIG
     s.clear();
     s << OP_1 << ToByteVector(pubkey) << OP_1 << OP_CHECKMULTISIG;
     BOOST_CHECK(!ExtractDestination(s, address));
 
     // TX_NULL_DATA
     s.clear();
     s << OP_RETURN << std::vector<uint8_t>({75});
     BOOST_CHECK(!ExtractDestination(s, address));
 
     // TX_WITNESS_V0_KEYHASH
     s.clear();
     s << OP_0 << ToByteVector(pubkey);
     BOOST_CHECK(!ExtractDestination(s, address));
 
     // TX_WITNESS_V0_SCRIPTHASH
     s.clear();
     s << OP_0 << ToByteVector(CScriptID(redeemScript));
     BOOST_CHECK(!ExtractDestination(s, address));
 }
 
 BOOST_AUTO_TEST_CASE(script_standard_ExtractDestinations) {
     CKey keys[3];
     CPubKey pubkeys[3];
     for (int i = 0; i < 3; i++) {
         keys[i].MakeNewKey(true);
         pubkeys[i] = keys[i].GetPubKey();
     }
 
     CScript s;
     txnouttype whichType;
     std::vector<CTxDestination> addresses;
     int nRequired;
 
     // TX_PUBKEY
     s.clear();
     s << ToByteVector(pubkeys[0]) << OP_CHECKSIG;
     BOOST_CHECK(ExtractDestinations(s, whichType, addresses, nRequired));
     BOOST_CHECK_EQUAL(whichType, TX_PUBKEY);
     BOOST_CHECK_EQUAL(addresses.size(), 1U);
     BOOST_CHECK_EQUAL(nRequired, 1);
     BOOST_CHECK(boost::get<CKeyID>(&addresses[0]) &&
                 *boost::get<CKeyID>(&addresses[0]) == pubkeys[0].GetID());
 
     // TX_PUBKEYHASH
     s.clear();
     s << OP_DUP << OP_HASH160 << ToByteVector(pubkeys[0].GetID())
       << OP_EQUALVERIFY << OP_CHECKSIG;
     BOOST_CHECK(ExtractDestinations(s, whichType, addresses, nRequired));
     BOOST_CHECK_EQUAL(whichType, TX_PUBKEYHASH);
     BOOST_CHECK_EQUAL(addresses.size(), 1U);
     BOOST_CHECK_EQUAL(nRequired, 1);
     BOOST_CHECK(boost::get<CKeyID>(&addresses[0]) &&
                 *boost::get<CKeyID>(&addresses[0]) == pubkeys[0].GetID());
 
     // TX_SCRIPTHASH
     // initialize with leftover P2PKH script
     CScript redeemScript(s);
     s.clear();
     s << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
     BOOST_CHECK(ExtractDestinations(s, whichType, addresses, nRequired));
     BOOST_CHECK_EQUAL(whichType, TX_SCRIPTHASH);
     BOOST_CHECK_EQUAL(addresses.size(), 1U);
     BOOST_CHECK_EQUAL(nRequired, 1);
     BOOST_CHECK(boost::get<CScriptID>(&addresses[0]) &&
                 *boost::get<CScriptID>(&addresses[0]) ==
                     CScriptID(redeemScript));
 
     // TX_MULTISIG
     s.clear();
     s << OP_2 << ToByteVector(pubkeys[0]) << ToByteVector(pubkeys[1]) << OP_2
       << OP_CHECKMULTISIG;
     BOOST_CHECK(ExtractDestinations(s, whichType, addresses, nRequired));
     BOOST_CHECK_EQUAL(whichType, TX_MULTISIG);
     BOOST_CHECK_EQUAL(addresses.size(), 2U);
     BOOST_CHECK_EQUAL(nRequired, 2);
     BOOST_CHECK(boost::get<CKeyID>(&addresses[0]) &&
                 *boost::get<CKeyID>(&addresses[0]) == pubkeys[0].GetID());
     BOOST_CHECK(boost::get<CKeyID>(&addresses[1]) &&
                 *boost::get<CKeyID>(&addresses[1]) == pubkeys[1].GetID());
 
     // TX_NULL_DATA
     s.clear();
     s << OP_RETURN << std::vector<uint8_t>({75});
     BOOST_CHECK(!ExtractDestinations(s, whichType, addresses, nRequired));
 
     // TX_WITNESS_V0_KEYHASH
     s.clear();
     s << OP_0 << ToByteVector(pubkeys[0].GetID());
     BOOST_CHECK(!ExtractDestinations(s, whichType, addresses, nRequired));
 
     // TX_WITNESS_V0_SCRIPTHASH
     s.clear();
     s << OP_0 << ToByteVector(CScriptID(redeemScript));
     BOOST_CHECK(!ExtractDestinations(s, whichType, addresses, nRequired));
 }
 
 BOOST_AUTO_TEST_CASE(script_standard_GetScriptFor_) {
     CKey keys[3];
     CPubKey pubkeys[3];
     for (int i = 0; i < 3; i++) {
         keys[i].MakeNewKey(true);
         pubkeys[i] = keys[i].GetPubKey();
     }
 
     CScript expected, result;
 
     // CKeyID
     expected.clear();
     expected << OP_DUP << OP_HASH160 << ToByteVector(pubkeys[0].GetID())
              << OP_EQUALVERIFY << OP_CHECKSIG;
     result = GetScriptForDestination(pubkeys[0].GetID());
     BOOST_CHECK(result == expected);
 
     // CScriptID
     CScript redeemScript(result);
     expected.clear();
     expected << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
     result = GetScriptForDestination(CScriptID(redeemScript));
     BOOST_CHECK(result == expected);
 
     // CNoDestination
     expected.clear();
     result = GetScriptForDestination(CNoDestination());
     BOOST_CHECK(result == expected);
 
     // GetScriptForRawPubKey
     expected.clear();
     expected << ToByteVector(pubkeys[0]) << OP_CHECKSIG;
     result = GetScriptForRawPubKey(pubkeys[0]);
     BOOST_CHECK(result == expected);
 
     // GetScriptForMultisig
     expected.clear();
     expected << OP_2 << ToByteVector(pubkeys[0]) << ToByteVector(pubkeys[1])
              << ToByteVector(pubkeys[2]) << OP_3 << OP_CHECKMULTISIG;
     result =
         GetScriptForMultisig(2, std::vector<CPubKey>(pubkeys, pubkeys + 3));
     BOOST_CHECK(result == expected);
 }
 
 BOOST_AUTO_TEST_CASE(script_standard_IsMine) {
     CKey keys[2];
     CPubKey pubkeys[2];
     for (int i = 0; i < 2; i++) {
         keys[i].MakeNewKey(true);
         pubkeys[i] = keys[i].GetPubKey();
     }
 
     CKey uncompressedKey;
     uncompressedKey.MakeNewKey(false);
     CPubKey uncompressedPubkey = uncompressedKey.GetPubKey();
 
     CScript scriptPubKey;
     isminetype result;
     bool isInvalid;
 
     // P2PK compressed
     {
         CBasicKeyStore keystore;
         scriptPubKey.clear();
         scriptPubKey << ToByteVector(pubkeys[0]) << OP_CHECKSIG;
 
         // Keystore does not have key
         result = IsMine(keystore, scriptPubKey, isInvalid);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
         BOOST_CHECK(!isInvalid);
 
         // Keystore has key
         keystore.AddKey(keys[0]);
         result = IsMine(keystore, scriptPubKey, isInvalid);
         BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
         BOOST_CHECK(!isInvalid);
     }
 
     // P2PK uncompressed
     {
         CBasicKeyStore keystore;
         scriptPubKey.clear();
         scriptPubKey << ToByteVector(uncompressedPubkey) << OP_CHECKSIG;
 
         // Keystore does not have key
         result = IsMine(keystore, scriptPubKey, isInvalid);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
         BOOST_CHECK(!isInvalid);
 
         // Keystore has key
         keystore.AddKey(uncompressedKey);
         result = IsMine(keystore, scriptPubKey, isInvalid);
         BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
         BOOST_CHECK(!isInvalid);
     }
 
     // P2PKH compressed
     {
         CBasicKeyStore keystore;
         scriptPubKey.clear();
         scriptPubKey << OP_DUP << OP_HASH160 << ToByteVector(pubkeys[0].GetID())
                      << OP_EQUALVERIFY << OP_CHECKSIG;
 
         // Keystore does not have key
         result = IsMine(keystore, scriptPubKey, isInvalid);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
         BOOST_CHECK(!isInvalid);
 
         // Keystore has key
         keystore.AddKey(keys[0]);
         result = IsMine(keystore, scriptPubKey, isInvalid);
         BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
         BOOST_CHECK(!isInvalid);
     }
 
     // P2PKH uncompressed
     {
         CBasicKeyStore keystore;
         scriptPubKey.clear();
         scriptPubKey << OP_DUP << OP_HASH160
                      << ToByteVector(uncompressedPubkey.GetID())
                      << OP_EQUALVERIFY << OP_CHECKSIG;
 
         // Keystore does not have key
         result = IsMine(keystore, scriptPubKey, isInvalid);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
         BOOST_CHECK(!isInvalid);
 
         // Keystore has key
         keystore.AddKey(uncompressedKey);
         result = IsMine(keystore, scriptPubKey, isInvalid);
         BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
         BOOST_CHECK(!isInvalid);
     }
 
     // P2SH
     {
         CBasicKeyStore keystore;
 
         CScript redeemScript;
         redeemScript << OP_DUP << OP_HASH160 << ToByteVector(pubkeys[0].GetID())
                      << OP_EQUALVERIFY << OP_CHECKSIG;
 
         scriptPubKey.clear();
         scriptPubKey << OP_HASH160 << ToByteVector(CScriptID(redeemScript))
                      << OP_EQUAL;
 
         // Keystore does not have redeemScript or key
         result = IsMine(keystore, scriptPubKey, isInvalid);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
         BOOST_CHECK(!isInvalid);
 
         // Keystore has redeemScript but no key
         keystore.AddCScript(redeemScript);
         result = IsMine(keystore, scriptPubKey, isInvalid);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
         BOOST_CHECK(!isInvalid);
 
         // Keystore has redeemScript and key
         keystore.AddKey(keys[0]);
         result = IsMine(keystore, scriptPubKey, isInvalid);
         BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
         BOOST_CHECK(!isInvalid);
     }
 
     // scriptPubKey multisig
     {
         CBasicKeyStore keystore;
 
         scriptPubKey.clear();
         scriptPubKey << OP_2 << ToByteVector(uncompressedPubkey)
                      << ToByteVector(pubkeys[1]) << OP_2 << OP_CHECKMULTISIG;
 
         // Keystore does not have any keys
         result = IsMine(keystore, scriptPubKey, isInvalid);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
         BOOST_CHECK(!isInvalid);
 
         // Keystore has 1/2 keys
         keystore.AddKey(uncompressedKey);
 
         result = IsMine(keystore, scriptPubKey, isInvalid);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
         BOOST_CHECK(!isInvalid);
 
         // Keystore has 2/2 keys
         keystore.AddKey(keys[1]);
 
         result = IsMine(keystore, scriptPubKey, isInvalid);
-        BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
+        BOOST_CHECK(!isInvalid);
+
+        // Keystore has 2/2 keys and the script
+        keystore.AddCScript(scriptPubKey);
+
+        result = IsMine(keystore, scriptPubKey, isInvalid);
+        BOOST_CHECK_EQUAL(result, ISMINE_NO);
         BOOST_CHECK(!isInvalid);
     }
 
     // P2SH multisig
     {
         CBasicKeyStore keystore;
         keystore.AddKey(uncompressedKey);
         keystore.AddKey(keys[1]);
 
         CScript redeemScript;
         redeemScript << OP_2 << ToByteVector(uncompressedPubkey)
                      << ToByteVector(pubkeys[1]) << OP_2 << OP_CHECKMULTISIG;
 
         scriptPubKey.clear();
         scriptPubKey << OP_HASH160 << ToByteVector(CScriptID(redeemScript))
                      << OP_EQUAL;
 
         // Keystore has no redeemScript
         result = IsMine(keystore, scriptPubKey, isInvalid);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
         BOOST_CHECK(!isInvalid);
 
         // Keystore has redeemScript
         keystore.AddCScript(redeemScript);
         result = IsMine(keystore, scriptPubKey, isInvalid);
         BOOST_CHECK_EQUAL(result, ISMINE_SPENDABLE);
         BOOST_CHECK(!isInvalid);
     }
 
     // OP_RETURN
     {
         CBasicKeyStore keystore;
         keystore.AddKey(keys[0]);
 
         scriptPubKey.clear();
         scriptPubKey << OP_RETURN << ToByteVector(pubkeys[0]);
 
         result = IsMine(keystore, scriptPubKey, isInvalid);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
         BOOST_CHECK(!isInvalid);
     }
 
     // Nonstandard
     {
         CBasicKeyStore keystore;
         keystore.AddKey(keys[0]);
 
         scriptPubKey.clear();
         scriptPubKey << OP_9 << OP_ADD << OP_11 << OP_EQUAL;
 
         result = IsMine(keystore, scriptPubKey, isInvalid);
         BOOST_CHECK_EQUAL(result, ISMINE_NO);
         BOOST_CHECK(!isInvalid);
     }
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/wallet/rpcdump.cpp b/src/wallet/rpcdump.cpp
index 65e29645e7..ece81b0fd9 100644
--- a/src/wallet/rpcdump.cpp
+++ b/src/wallet/rpcdump.cpp
@@ -1,1579 +1,1580 @@
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <chain.h>
 #include <config.h>
 #include <core_io.h>
 #include <key_io.h>
 #include <merkleblock.h>
 #include <rpc/server.h>
 #include <script/script.h>
 #include <script/standard.h>
 #include <sync.h>
 #include <util/system.h>
 #include <util/time.h>
 #include <validation.h>
 #include <wallet/rpcwallet.h>
 #include <wallet/wallet.h>
 
 #include <boost/algorithm/string.hpp>
 #include <boost/date_time/posix_time/posix_time.hpp>
 
 #include <univalue.h>
 
 #include <cstdint>
 #include <fstream>
 #include <iostream>
 
 static int64_t DecodeDumpTime(const std::string &str) {
     static const boost::posix_time::ptime epoch =
         boost::posix_time::from_time_t(0);
     static const std::locale loc(
         std::locale::classic(),
         new boost::posix_time::time_input_facet("%Y-%m-%dT%H:%M:%SZ"));
     std::istringstream iss(str);
     iss.imbue(loc);
     boost::posix_time::ptime ptime(boost::date_time::not_a_date_time);
     iss >> ptime;
     if (ptime.is_not_a_date_time()) return 0;
     return (ptime - epoch).total_seconds();
 }
 
 static std::string EncodeDumpString(const std::string &str) {
     std::stringstream ret;
     for (const uint8_t c : str) {
         if (c <= 32 || c >= 128 || c == '%') {
             ret << '%' << HexStr(&c, &c + 1);
         } else {
             ret << c;
         }
     }
     return ret.str();
 }
 
 static std::string DecodeDumpString(const std::string &str) {
     std::stringstream ret;
     for (unsigned int pos = 0; pos < str.length(); pos++) {
         uint8_t c = str[pos];
         if (c == '%' && pos + 2 < str.length()) {
             c = (((str[pos + 1] >> 6) * 9 + ((str[pos + 1] - '0') & 15)) << 4) |
                 ((str[pos + 2] >> 6) * 9 + ((str[pos + 2] - '0') & 15));
             pos += 2;
         }
         ret << c;
     }
     return ret.str();
 }
 
 bool GetWalletAddressesForKey(const Config &config, CWallet *const pwallet,
                               const CKeyID &keyid, std::string &strAddr,
                               std::string &strLabel) {
     bool fLabelFound = false;
     CKey key;
     pwallet->GetKey(keyid, key);
     for (const auto &dest : GetAllDestinationsForKey(key.GetPubKey())) {
         if (pwallet->mapAddressBook.count(dest)) {
             if (!strAddr.empty()) {
                 strAddr += ",";
             }
             strAddr += EncodeDestination(dest, config);
             strLabel = EncodeDumpString(pwallet->mapAddressBook[dest].name);
             fLabelFound = true;
         }
     }
     if (!fLabelFound) {
         strAddr = EncodeDestination(
             GetDestinationForKey(key.GetPubKey(),
                                  pwallet->m_default_address_type),
             config);
     }
     return fLabelFound;
 }
 
 static const int64_t TIMESTAMP_MIN = 0;
 
 static void RescanWallet(CWallet &wallet, const WalletRescanReserver &reserver,
                          int64_t time_begin = TIMESTAMP_MIN,
                          bool update = true) {
     int64_t scanned_time = wallet.RescanFromTime(time_begin, reserver, update);
     if (wallet.IsAbortingRescan()) {
         throw JSONRPCError(RPC_MISC_ERROR, "Rescan aborted by user.");
     } else if (scanned_time > time_begin) {
         throw JSONRPCError(RPC_WALLET_ERROR,
                            "Rescan was unable to fully rescan the blockchain. "
                            "Some transactions may be missing.");
     }
 }
 
 UniValue importprivkey(const Config &config, const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 3) {
         throw std::runtime_error(
             "importprivkey \"privkey\" ( \"label\" ) ( rescan )\n"
             "\nAdds a private key (as returned by dumpprivkey) to your wallet. "
             "Requires a new wallet backup.\n"
             "Hint: use importmulti to import more than one private key.\n"
             "\nArguments:\n"
             "1. \"privkey\"   (string, required) The private key (see "
             "dumpprivkey)\n"
             "2. \"label\"            (string, optional, default=\"\") An "
             "optional label\n"
             "3. rescan               (boolean, optional, default=true) Rescan "
             "the wallet for transactions\n"
             "\nNote: This call can take minutes to complete if rescan is true, "
             "during that time, other rpc calls\n"
             "may report that the imported key exists but related transactions "
             "are still missing, leading to temporarily incorrect/bogus "
             "balances and unspent outputs until rescan completes.\n"
             "\nExamples:\n"
             "\nDump a private key\n" +
             HelpExampleCli("dumpprivkey", "\"myaddress\"") +
             "\nImport the private key with rescan\n" +
             HelpExampleCli("importprivkey", "\"mykey\"") +
             "\nImport using a label and without rescan\n" +
             HelpExampleCli("importprivkey", "\"mykey\" \"testing\" false") +
             "\nImport using default blank label and without rescan\n" +
             HelpExampleCli("importprivkey", "\"mykey\" \"\" false") +
             "\nAs a JSON-RPC call\n" +
             HelpExampleRpc("importprivkey", "\"mykey\", \"testing\", false"));
     }
 
     if (pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
         throw JSONRPCError(RPC_WALLET_ERROR,
                            "Cannot import private keys to a wallet with "
                            "private keys disabled");
     }
 
     WalletRescanReserver reserver(pwallet);
     bool fRescan = true;
     {
         LOCK2(cs_main, pwallet->cs_wallet);
 
         EnsureWalletIsUnlocked(pwallet);
 
         std::string strSecret = request.params[0].get_str();
         std::string strLabel = "";
         if (!request.params[1].isNull()) {
             strLabel = request.params[1].get_str();
         }
 
         // Whether to perform rescan after import
         if (!request.params[2].isNull()) {
             fRescan = request.params[2].get_bool();
         }
 
         if (fRescan && fPruneMode) {
             throw JSONRPCError(RPC_WALLET_ERROR,
                                "Rescan is disabled in pruned mode");
         }
 
         if (fRescan && !reserver.reserve()) {
             throw JSONRPCError(RPC_WALLET_ERROR,
                                "Wallet is currently rescanning. Abort existing "
                                "rescan or wait.");
         }
 
         CKey key = DecodeSecret(strSecret);
         if (!key.IsValid()) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Invalid private key encoding");
         }
 
         CPubKey pubkey = key.GetPubKey();
         assert(key.VerifyPubKey(pubkey));
         CKeyID vchAddress = pubkey.GetID();
         {
             pwallet->MarkDirty();
             // We don't know which corresponding address will be used; label
             // them all
             for (const auto &dest : GetAllDestinationsForKey(pubkey)) {
                 pwallet->SetAddressBook(dest, strLabel, "receive");
             }
 
             // Don't throw error in case a key is already there
             if (pwallet->HaveKey(vchAddress)) {
                 return NullUniValue;
             }
 
             pwallet->LearnAllRelatedScripts(pubkey);
 
             // whenever a key is imported, we need to scan the whole chain
             pwallet->UpdateTimeFirstKey(1);
             pwallet->mapKeyMetadata[vchAddress].nCreateTime = 1;
 
             if (!pwallet->AddKeyPubKey(key, pubkey)) {
                 throw JSONRPCError(RPC_WALLET_ERROR,
                                    "Error adding key to wallet");
             }
         }
     }
     if (fRescan) {
         RescanWallet(*pwallet, reserver);
     }
 
     return NullUniValue;
 }
 
 UniValue abortrescan(const Config &config, const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() > 0) {
         throw std::runtime_error("abortrescan\n"
                                  "\nStops current wallet rescan triggered by "
                                  "an RPC call, e.g. by an importprivkey call.\n"
                                  "\nExamples:\n"
                                  "\nImport a private key\n" +
                                  HelpExampleCli("importprivkey", "\"mykey\"") +
                                  "\nAbort the running wallet rescan\n" +
                                  HelpExampleCli("abortrescan", "") +
                                  "\nAs a JSON-RPC call\n" +
                                  HelpExampleRpc("abortrescan", ""));
     }
 
     if (!pwallet->IsScanning() || pwallet->IsAbortingRescan()) {
         return false;
     }
     pwallet->AbortRescan();
     return true;
 }
 
 static void ImportAddress(CWallet *, const CTxDestination &dest,
                           const std::string &strLabel);
 static void ImportScript(CWallet *const pwallet, const CScript &script,
                          const std::string &strLabel, bool isRedeemScript)
     EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet) {
     if (!isRedeemScript && ::IsMine(*pwallet, script) == ISMINE_SPENDABLE) {
         throw JSONRPCError(RPC_WALLET_ERROR, "The wallet already contains the "
                                              "private key for this address or "
                                              "script");
     }
 
     pwallet->MarkDirty();
 
     if (!pwallet->HaveWatchOnly(script) &&
         !pwallet->AddWatchOnly(script, 0 /* nCreateTime */)) {
         throw JSONRPCError(RPC_WALLET_ERROR, "Error adding address to wallet");
     }
 
     if (isRedeemScript) {
-        if (!pwallet->HaveCScript(script) && !pwallet->AddCScript(script)) {
+        const CScriptID id(script);
+        if (!pwallet->HaveCScript(id) && !pwallet->AddCScript(script)) {
             throw JSONRPCError(RPC_WALLET_ERROR,
                                "Error adding p2sh redeemScript to wallet");
         }
-        ImportAddress(pwallet, CScriptID(script), strLabel);
+        ImportAddress(pwallet, id, strLabel);
     } else {
         CTxDestination destination;
         if (ExtractDestination(script, destination)) {
             pwallet->SetAddressBook(destination, strLabel, "receive");
         }
     }
 }
 
 static void ImportAddress(CWallet *const pwallet, const CTxDestination &dest,
                           const std::string &strLabel)
     EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet) {
     CScript script = GetScriptForDestination(dest);
     ImportScript(pwallet, script, strLabel, false);
     // add to address book or update label
     if (IsValidDestination(dest)) {
         pwallet->SetAddressBook(dest, strLabel, "receive");
     }
 }
 
 UniValue importaddress(const Config &config, const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 4) {
         throw std::runtime_error(
             "importaddress \"address\" ( \"label\" rescan p2sh )\n"
             "\nAdds an address or script (in hex) that can be watched as if it "
             "were in your wallet but cannot be used to spend. Requires a new "
             "wallet backup.\n"
             "\nArguments:\n"
             "1. \"address\"          (string, required) The Bitcoin address "
             "(or hex-encoded script)\n"
             "2. \"label\"            (string, optional, default=\"\") An "
             "optional label\n"
             "3. rescan               (boolean, optional, default=true) Rescan "
             "the wallet for transactions\n"
             "4. p2sh                 (boolean, optional, default=false) Add "
             "the P2SH version of the script as well\n"
             "\nNote: This call can take minutes to complete if rescan is true, "
             "during that time, other rpc calls\n"
             "may report that the imported address exists but related "
             "transactions are still missing, leading to temporarily "
             "incorrect/bogus balances and unspent outputs until rescan "
             "completes.\n"
             "If you have the full public key, you should call importpubkey "
             "instead of this.\n"
             "\nNote: If you import a non-standard raw script in hex form, "
             "outputs sending to it will be treated\n"
             "as change, and not show up in many RPCs.\n"
             "\nExamples:\n"
             "\nImport an address with rescan\n" +
             HelpExampleCli("importaddress", "\"myaddress\"") +
             "\nImport using a label without rescan\n" +
             HelpExampleCli("importaddress", "\"myaddress\" \"testing\" false") +
             "\nAs a JSON-RPC call\n" +
             HelpExampleRpc("importaddress",
                            "\"myaddress\", \"testing\", false"));
     }
 
     std::string strLabel;
     if (!request.params[1].isNull()) {
         strLabel = request.params[1].get_str();
     }
 
     // Whether to perform rescan after import
     bool fRescan = true;
     if (!request.params[2].isNull()) {
         fRescan = request.params[2].get_bool();
     }
 
     if (fRescan && fPruneMode) {
         throw JSONRPCError(RPC_WALLET_ERROR,
                            "Rescan is disabled in pruned mode");
     }
 
     WalletRescanReserver reserver(pwallet);
     if (fRescan && !reserver.reserve()) {
         throw JSONRPCError(
             RPC_WALLET_ERROR,
             "Wallet is currently rescanning. Abort existing rescan or wait.");
     }
 
     // Whether to import a p2sh version, too
     bool fP2SH = false;
     if (!request.params[3].isNull()) {
         fP2SH = request.params[3].get_bool();
     }
 
     {
         LOCK2(cs_main, pwallet->cs_wallet);
 
         CTxDestination dest = DecodeDestination(request.params[0].get_str(),
                                                 config.GetChainParams());
         if (IsValidDestination(dest)) {
             if (fP2SH) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                    "Cannot use the p2sh flag with an address - "
                                    "use a script instead");
             }
             ImportAddress(pwallet, dest, strLabel);
         } else if (IsHex(request.params[0].get_str())) {
             std::vector<uint8_t> data(ParseHex(request.params[0].get_str()));
             ImportScript(pwallet, CScript(data.begin(), data.end()), strLabel,
                          fP2SH);
         } else {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Invalid Bitcoin address or script");
         }
     }
     if (fRescan) {
         RescanWallet(*pwallet, reserver);
         pwallet->ReacceptWalletTransactions();
     }
 
     return NullUniValue;
 }
 
 UniValue importprunedfunds(const Config &config,
                            const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() != 2) {
         throw std::runtime_error(
             "importprunedfunds\n"
             "\nImports funds without rescan. Corresponding address or script "
             "must previously be included in wallet. Aimed towards pruned "
             "wallets. The end-user is responsible to import additional "
             "transactions that subsequently spend the imported outputs or "
             "rescan after the point in the blockchain the transaction is "
             "included.\n"
             "\nArguments:\n"
             "1. \"rawtransaction\" (string, required) A raw transaction in hex "
             "funding an already-existing address in wallet\n"
             "2. \"txoutproof\"     (string, required) The hex output from "
             "gettxoutproof that contains the transaction\n");
     }
 
     CMutableTransaction tx;
     if (!DecodeHexTx(tx, request.params[0].get_str())) {
         throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
     }
     uint256 txid = tx.GetId();
     CWalletTx wtx(pwallet, MakeTransactionRef(std::move(tx)));
 
     CDataStream ssMB(ParseHexV(request.params[1], "proof"), SER_NETWORK,
                      PROTOCOL_VERSION);
     CMerkleBlock merkleBlock;
     ssMB >> merkleBlock;
 
     // Search partial merkle tree in proof for our transaction and index in
     // valid block
     std::vector<uint256> vMatch;
     std::vector<size_t> vIndex;
     size_t txnIndex = 0;
     if (merkleBlock.txn.ExtractMatches(vMatch, vIndex) ==
         merkleBlock.header.hashMerkleRoot) {
         LOCK(cs_main);
         const CBlockIndex *pindex =
             LookupBlockIndex(merkleBlock.header.GetHash());
         if (!pindex || !chainActive.Contains(pindex)) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Block not found in chain");
         }
 
         std::vector<uint256>::const_iterator it;
         if ((it = std::find(vMatch.begin(), vMatch.end(), txid)) ==
             vMatch.end()) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Transaction given doesn't exist in proof");
         }
 
         txnIndex = vIndex[it - vMatch.begin()];
     } else {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "Something wrong with merkleblock");
     }
 
     wtx.nIndex = txnIndex;
     wtx.hashBlock = merkleBlock.header.GetHash();
 
     LOCK2(cs_main, pwallet->cs_wallet);
 
     if (pwallet->IsMine(*wtx.tx)) {
         pwallet->AddToWallet(wtx, false);
         return NullUniValue;
     }
 
     throw JSONRPCError(
         RPC_INVALID_ADDRESS_OR_KEY,
         "No addresses in wallet correspond to included transaction");
 }
 
 UniValue removeprunedfunds(const Config &config,
                            const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(
             "removeprunedfunds \"txid\"\n"
             "\nDeletes the specified transaction from the wallet. Meant for "
             "use with pruned wallets and as a companion to importprunedfunds. "
             "This will affect wallet balances.\n"
             "\nArguments:\n"
             "1. \"txid\"           (string, required) The hex-encoded id of "
             "the transaction you are deleting\n"
             "\nExamples:\n" +
             HelpExampleCli("removeprunedfunds", "\"a8d0c0184dde994a09ec054286f1"
                                                 "ce581bebf46446a512166eae762873"
                                                 "4ea0a5\"") +
             "\nAs a JSON-RPC call\n" +
             HelpExampleRpc("removeprunedfunds",
                            "\"a8d0c0184dde994a09ec054286f1ce581bebf46446a512166"
                            "eae7628734ea0a5\""));
     }
 
     LOCK2(cs_main, pwallet->cs_wallet);
 
     TxId txid;
     txid.SetHex(request.params[0].get_str());
     std::vector<TxId> txIds;
     txIds.push_back(txid);
     std::vector<TxId> txIdsOut;
 
     if (pwallet->ZapSelectTx(txIds, txIdsOut) != DBErrors::LOAD_OK) {
         throw JSONRPCError(RPC_WALLET_ERROR,
                            "Could not properly delete the transaction.");
     }
 
     if (txIdsOut.empty()) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "Transaction does not exist in wallet.");
     }
 
     return NullUniValue;
 }
 
 UniValue importpubkey(const Config &config, const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 4) {
         throw std::runtime_error(
             "importpubkey \"pubkey\" ( \"label\" rescan )\n"
             "\nAdds a public key (in hex) that can be watched as if it were in "
             "your wallet but cannot be used to spend. Requires a new wallet "
             "backup.\n"
             "\nArguments:\n"
             "1. \"pubkey\"           (string, required) The hex-encoded public "
             "key\n"
             "2. \"label\"            (string, optional, default=\"\") An "
             "optional label\n"
             "3. rescan               (boolean, optional, default=true) Rescan "
             "the wallet for transactions\n"
             "\nNote: This call can take minutes to complete if rescan is true, "
             "during that time, other rpc calls\n"
             "may report that the imported pubkey exists but related "
             "transactions are still missing, leading to temporarily "
             "incorrect/bogus balances and unspent outputs until rescan "
             "completes.\n"
             "\nExamples:\n"
             "\nImport a public key with rescan\n" +
             HelpExampleCli("importpubkey", "\"mypubkey\"") +
             "\nImport using a label without rescan\n" +
             HelpExampleCli("importpubkey", "\"mypubkey\" \"testing\" false") +
             "\nAs a JSON-RPC call\n" +
             HelpExampleRpc("importpubkey", "\"mypubkey\", \"testing\", false"));
     }
 
     std::string strLabel;
     if (!request.params[1].isNull()) {
         strLabel = request.params[1].get_str();
     }
 
     // Whether to perform rescan after import
     bool fRescan = true;
     if (!request.params[2].isNull()) {
         fRescan = request.params[2].get_bool();
     }
 
     if (fRescan && fPruneMode) {
         throw JSONRPCError(RPC_WALLET_ERROR,
                            "Rescan is disabled in pruned mode");
     }
 
     WalletRescanReserver reserver(pwallet);
     if (fRescan && !reserver.reserve()) {
         throw JSONRPCError(
             RPC_WALLET_ERROR,
             "Wallet is currently rescanning. Abort existing rescan or wait.");
     }
 
     if (!IsHex(request.params[0].get_str())) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "Pubkey must be a hex string");
     }
     std::vector<uint8_t> data(ParseHex(request.params[0].get_str()));
     CPubKey pubKey(data.begin(), data.end());
     if (!pubKey.IsFullyValid()) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "Pubkey is not a valid public key");
     }
 
     {
         LOCK2(cs_main, pwallet->cs_wallet);
 
         for (const auto &dest : GetAllDestinationsForKey(pubKey)) {
             ImportAddress(pwallet, dest, strLabel);
         }
         ImportScript(pwallet, GetScriptForRawPubKey(pubKey), strLabel, false);
         pwallet->LearnAllRelatedScripts(pubKey);
     }
     if (fRescan) {
         RescanWallet(*pwallet, reserver);
         pwallet->ReacceptWalletTransactions();
     }
 
     return NullUniValue;
 }
 
 UniValue importwallet(const Config &config, const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(
             "importwallet \"filename\"\n"
             "\nImports keys from a wallet dump file (see dumpwallet). Requires "
             "a new wallet backup to include imported keys.\n"
             "\nArguments:\n"
             "1. \"filename\"    (string, required) The wallet file\n"
             "\nExamples:\n"
             "\nDump the wallet\n" +
             HelpExampleCli("dumpwallet", "\"test\"") + "\nImport the wallet\n" +
             HelpExampleCli("importwallet", "\"test\"") +
             "\nImport using the json rpc call\n" +
             HelpExampleRpc("importwallet", "\"test\""));
     }
 
     if (fPruneMode) {
         throw JSONRPCError(RPC_WALLET_ERROR,
                            "Importing wallets is disabled in pruned mode");
     }
 
     WalletRescanReserver reserver(pwallet);
     if (!reserver.reserve()) {
         throw JSONRPCError(
             RPC_WALLET_ERROR,
             "Wallet is currently rescanning. Abort existing rescan or wait.");
     }
 
     int64_t nTimeBegin = 0;
     bool fGood = true;
     {
         LOCK2(cs_main, pwallet->cs_wallet);
 
         EnsureWalletIsUnlocked(pwallet);
 
         std::ifstream file;
         file.open(request.params[0].get_str().c_str(),
                   std::ios::in | std::ios::ate);
         if (!file.is_open()) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Cannot open wallet dump file");
         }
         nTimeBegin = chainActive.Tip()->GetBlockTime();
 
         int64_t nFilesize = std::max<int64_t>(1, file.tellg());
         file.seekg(0, file.beg);
 
         // Use uiInterface.ShowProgress instead of pwallet.ShowProgress because
         // pwallet.ShowProgress has a cancel button tied to AbortRescan which we
         // don't want for this progress bar showing the import progress.
         // uiInterface.ShowProgress does not have a cancel button.
 
         // show progress dialog in GUI
         uiInterface.ShowProgress(
             strprintf("%s " + _("Importing..."), pwallet->GetDisplayName()), 0,
             false);
         std::vector<std::tuple<CKey, int64_t, bool, std::string>> keys;
         std::vector<std::pair<CScript, int64_t>> scripts;
         while (file.good()) {
             uiInterface.ShowProgress(
                 "",
                 std::max(1, std::min<int>(50, 100 * double(file.tellg()) /
                                                   double(nFilesize))),
                 false);
             std::string line;
             std::getline(file, line);
             if (line.empty() || line[0] == '#') {
                 continue;
             }
 
             std::vector<std::string> vstr;
             boost::split(vstr, line, boost::is_any_of(" "));
             if (vstr.size() < 2) {
                 continue;
             }
             CKey key = DecodeSecret(vstr[0]);
             if (key.IsValid()) {
                 int64_t nTime = DecodeDumpTime(vstr[1]);
                 std::string strLabel;
                 bool fLabel = true;
                 for (size_t nStr = 2; nStr < vstr.size(); nStr++) {
                     if (vstr[nStr].front() == '#') {
                         break;
                     }
                     if (vstr[nStr] == "change=1") {
                         fLabel = false;
                     }
                     if (vstr[nStr] == "reserve=1") {
                         fLabel = false;
                     }
                     if (vstr[nStr].substr(0, 6) == "label=") {
                         strLabel = DecodeDumpString(vstr[nStr].substr(6));
                         fLabel = true;
                     }
                 }
                 keys.push_back(std::make_tuple(key, nTime, fLabel, strLabel));
             } else if (IsHex(vstr[0])) {
                 std::vector<uint8_t> vData(ParseHex(vstr[0]));
                 CScript script = CScript(vData.begin(), vData.end());
                 int64_t birth_time = DecodeDumpTime(vstr[1]);
                 scripts.push_back(
                     std::pair<CScript, int64_t>(script, birth_time));
             }
         }
         file.close();
         // We now know whether we are importing private keys, so we can error if
         // private keys are disabled
         if (keys.size() > 0 &&
             pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
             // hide progress dialog in GUI
             uiInterface.ShowProgress("", 100, false);
             throw JSONRPCError(
                 RPC_WALLET_ERROR,
                 "Importing wallets is disabled when private keys are disabled");
         }
         double total = double(keys.size() + scripts.size());
         double progress = 0;
         for (const auto &key_tuple : keys) {
             uiInterface.ShowProgress(
                 "",
                 std::max(50, std::min<int>(75, 100 * progress / total) + 50),
                 false);
             const CKey &key = std::get<0>(key_tuple);
             int64_t time = std::get<1>(key_tuple);
             bool has_label = std::get<2>(key_tuple);
             std::string label = std::get<3>(key_tuple);
 
             CPubKey pubkey = key.GetPubKey();
             assert(key.VerifyPubKey(pubkey));
             CKeyID keyid = pubkey.GetID();
             if (pwallet->HaveKey(keyid)) {
                 pwallet->WalletLogPrintf(
                     "Skipping import of %s (key already present)\n",
                     EncodeDestination(keyid, config));
                 continue;
             }
             pwallet->WalletLogPrintf("Importing %s...\n",
                                      EncodeDestination(keyid, config));
             if (!pwallet->AddKeyPubKey(key, pubkey)) {
                 fGood = false;
                 continue;
             }
             pwallet->mapKeyMetadata[keyid].nCreateTime = time;
             if (has_label) {
                 pwallet->SetAddressBook(keyid, label, "receive");
             }
             nTimeBegin = std::min(nTimeBegin, time);
             progress++;
         }
         for (const auto &script_pair : scripts) {
             uiInterface.ShowProgress(
                 "",
                 std::max(50, std::min<int>(75, 100 * progress / total) + 50),
                 false);
             const CScript &script = script_pair.first;
             int64_t time = script_pair.second;
             CScriptID id(script);
             if (pwallet->HaveCScript(id)) {
                 pwallet->WalletLogPrintf(
                     "Skipping import of %s (script already present)\n",
                     HexStr(script));
                 continue;
             }
             if (!pwallet->AddCScript(script)) {
                 pwallet->WalletLogPrintf("Error importing script %s\n",
                                          HexStr(script));
                 fGood = false;
                 continue;
             }
             if (time > 0) {
                 pwallet->m_script_metadata[id].nCreateTime = time;
                 nTimeBegin = std::min(nTimeBegin, time);
             }
             progress++;
         }
         // hide progress dialog in GUI
         uiInterface.ShowProgress("", 100, false);
         pwallet->UpdateTimeFirstKey(nTimeBegin);
     }
     // hide progress dialog in GUI
     uiInterface.ShowProgress("", 100, false);
     RescanWallet(*pwallet, reserver, nTimeBegin, false /* update */);
     pwallet->MarkDirty();
 
     if (!fGood) {
         throw JSONRPCError(RPC_WALLET_ERROR,
                            "Error adding some keys/scripts to wallet");
     }
 
     return NullUniValue;
 }
 
 UniValue dumpprivkey(const Config &config, const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(
             "dumpprivkey \"address\"\n"
             "\nReveals the private key corresponding to 'address'.\n"
             "Then the importprivkey can be used with this output\n"
             "\nArguments:\n"
             "1. \"address\"   (string, required) The bitcoin address for the "
             "private key\n"
             "\nResult:\n"
             "\"key\"                (string) The private key\n"
             "\nExamples:\n" +
             HelpExampleCli("dumpprivkey", "\"myaddress\"") +
             HelpExampleCli("importprivkey", "\"mykey\"") +
             HelpExampleRpc("dumpprivkey", "\"myaddress\""));
     }
 
     LOCK2(cs_main, pwallet->cs_wallet);
 
     EnsureWalletIsUnlocked(pwallet);
 
     std::string strAddress = request.params[0].get_str();
     CTxDestination dest =
         DecodeDestination(strAddress, config.GetChainParams());
     if (!IsValidDestination(dest)) {
         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                            "Invalid Bitcoin address");
     }
     auto keyid = GetKeyForDestination(*pwallet, dest);
     if (keyid.IsNull()) {
         throw JSONRPCError(RPC_TYPE_ERROR, "Address does not refer to a key");
     }
     CKey vchSecret;
     if (!pwallet->GetKey(keyid, vchSecret)) {
         throw JSONRPCError(RPC_WALLET_ERROR, "Private key for address " +
                                                  strAddress + " is not known");
     }
     return EncodeSecret(vchSecret);
 }
 
 UniValue dumpwallet(const Config &config, const JSONRPCRequest &request) {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet *const pwallet = wallet.get();
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
         return NullUniValue;
     }
 
     if (request.fHelp || request.params.size() != 1)
         throw std::runtime_error(
             "dumpwallet \"filename\"\n"
             "\nDumps all wallet keys in a human-readable format to a "
             "server-side file. This does not allow overwriting existing "
             "files.\n"
             "Imported scripts are included in the dumpsfile, but corresponding "
             "addresses may not be added automatically by importwallet.\n"
             "Note that if your wallet contains keys which are not derived from "
             "your HD seed (e.g. imported keys), these are not covered by\n"
             "only backing up the seed itself, and must be backed up too (e.g. "
             "ensure you back up the whole dumpfile).\n"
             "\nArguments:\n"
             "1. \"filename\"    (string, required) The filename with path "
             "(either absolute or relative to bitcoind)\n"
             "\nResult:\n"
             "{                           (json object)\n"
             "  \"filename\" : {        (string) The filename with full "
             "absolute path\n"
             "}\n"
             "\nExamples:\n" +
             HelpExampleCli("dumpwallet", "\"test\"") +
             HelpExampleRpc("dumpwallet", "\"test\""));
 
     LOCK2(cs_main, pwallet->cs_wallet);
 
     EnsureWalletIsUnlocked(pwallet);
 
     fs::path filepath = request.params[0].get_str();
     filepath = fs::absolute(filepath);
 
     /**
      * Prevent arbitrary files from being overwritten. There have been reports
      * that users have overwritten wallet files this way:
      * https://github.com/bitcoin/bitcoin/issues/9934
      * It may also avoid other security issues.
      */
     if (fs::exists(filepath)) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            filepath.string() + " already exists. If you are "
                                                "sure this is what you want, "
                                                "move it out of the way first");
     }
 
     std::ofstream file;
     file.open(filepath.string().c_str());
     if (!file.is_open()) {
         throw JSONRPCError(RPC_INVALID_PARAMETER,
                            "Cannot open wallet dump file");
     }
 
     std::map<CTxDestination, int64_t> mapKeyBirth;
     const std::map<CKeyID, int64_t> &mapKeyPool = pwallet->GetAllReserveKeys();
     pwallet->GetKeyBirthTimes(mapKeyBirth);
 
     std::set<CScriptID> scripts = pwallet->GetCScripts();
     // TODO: include scripts in GetKeyBirthTimes() output instead of separate
 
     // sort time/key pairs
     std::vector<std::pair<int64_t, CKeyID>> vKeyBirth;
     for (const auto &entry : mapKeyBirth) {
         if (const CKeyID *keyID = boost::get<CKeyID>(&entry.first)) {
             // set and test
             vKeyBirth.push_back(std::make_pair(entry.second, *keyID));
         }
     }
     mapKeyBirth.clear();
     std::sort(vKeyBirth.begin(), vKeyBirth.end());
 
     // produce output
     file << strprintf("# Wallet dump created by Bitcoin %s\n", CLIENT_BUILD);
     file << strprintf("# * Created on %s\n", FormatISO8601DateTime(GetTime()));
     file << strprintf("# * Best block at time of backup was %i (%s),\n",
                       chainActive.Height(),
                       chainActive.Tip()->GetBlockHash().ToString());
     file << strprintf("#   mined on %s\n",
                       FormatISO8601DateTime(chainActive.Tip()->GetBlockTime()));
     file << "\n";
 
     // add the base58check encoded extended master if the wallet uses HD
     CKeyID seed_id = pwallet->GetHDChain().seed_id;
     if (!seed_id.IsNull()) {
         CKey seed;
         if (pwallet->GetKey(seed_id, seed)) {
             CExtKey masterKey;
             masterKey.SetSeed(seed.begin(), seed.size());
 
             file << "# extended private masterkey: " << EncodeExtKey(masterKey)
                  << "\n\n";
         }
     }
     for (std::vector<std::pair<int64_t, CKeyID>>::const_iterator it =
              vKeyBirth.begin();
          it != vKeyBirth.end(); it++) {
         const CKeyID &keyid = it->second;
         std::string strTime = FormatISO8601DateTime(it->first);
         std::string strAddr;
         std::string strLabel;
         CKey key;
         if (pwallet->GetKey(keyid, key)) {
             file << strprintf("%s %s ", EncodeSecret(key), strTime);
             if (GetWalletAddressesForKey(config, pwallet, keyid, strAddr,
                                          strLabel)) {
                 file << strprintf("label=%s", strLabel);
             } else if (keyid == seed_id) {
                 file << "hdseed=1";
             } else if (mapKeyPool.count(keyid)) {
                 file << "reserve=1";
             } else if (pwallet->mapKeyMetadata[keyid].hdKeypath == "s") {
                 file << "inactivehdseed=1";
             } else {
                 file << "change=1";
             }
             file << strprintf(
                 " # addr=%s%s\n", strAddr,
                 (pwallet->mapKeyMetadata[keyid].hdKeypath.size() > 0
                      ? " hdkeypath=" + pwallet->mapKeyMetadata[keyid].hdKeypath
                      : ""));
         }
     }
     file << "\n";
     for (const CScriptID &scriptid : scripts) {
         CScript script;
         std::string create_time = "0";
         std::string address = EncodeDestination(scriptid, config);
         // get birth times for scripts with metadata
         auto it = pwallet->m_script_metadata.find(scriptid);
         if (it != pwallet->m_script_metadata.end()) {
             create_time = FormatISO8601DateTime(it->second.nCreateTime);
         }
         if (pwallet->GetCScript(scriptid, script)) {
             file << strprintf("%s %s script=1",
                               HexStr(script.begin(), script.end()),
                               create_time);
             file << strprintf(" # addr=%s\n", address);
         }
     }
     file << "\n";
     file << "# End of dump\n";
     file.close();
 
     UniValue reply(UniValue::VOBJ);
     reply.pushKV("filename", filepath.string());
 
     return reply;
 }
 
 static UniValue ProcessImport(CWallet *const pwallet, const UniValue &data,
                               const int64_t timestamp)
     EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet) {
     try {
         bool success = false;
 
         // Required fields.
         const UniValue &scriptPubKey = data["scriptPubKey"];
 
         // Should have script or JSON with "address".
         if (!(scriptPubKey.getType() == UniValue::VOBJ &&
               scriptPubKey.exists("address")) &&
             !(scriptPubKey.getType() == UniValue::VSTR)) {
             throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid scriptPubKey");
         }
 
         // Optional fields.
         const std::string &strRedeemScript =
             data.exists("redeemscript") ? data["redeemscript"].get_str() : "";
         const UniValue &pubKeys =
             data.exists("pubkeys") ? data["pubkeys"].get_array() : UniValue();
         const UniValue &keys =
             data.exists("keys") ? data["keys"].get_array() : UniValue();
         const bool internal =
             data.exists("internal") ? data["internal"].get_bool() : false;
         const bool watchOnly =
             data.exists("watchonly") ? data["watchonly"].get_bool() : false;
         const std::string &label =
             data.exists("label") && !internal ? data["label"].get_str() : "";
 
         // If private keys are disabled, abort if private keys are being
         // imported
         if (pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS) &&
             !keys.isNull()) {
             throw JSONRPCError(RPC_WALLET_ERROR,
                                "Cannot import private keys to a wallet with "
                                "private keys disabled");
         }
 
         bool isScript = scriptPubKey.getType() == UniValue::VSTR;
         bool isP2SH = strRedeemScript.length() > 0;
         const std::string &output = isScript
                                         ? scriptPubKey.get_str()
                                         : scriptPubKey["address"].get_str();
 
         // Parse the output.
         CScript script;
         CTxDestination dest;
 
         if (!isScript) {
             dest = DecodeDestination(output, pwallet->chainParams);
             if (!IsValidDestination(dest)) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                    "Invalid address");
             }
             script = GetScriptForDestination(dest);
         } else {
             if (!IsHex(output)) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                    "Invalid scriptPubKey");
             }
 
             std::vector<uint8_t> vData(ParseHex(output));
             script = CScript(vData.begin(), vData.end());
         }
 
         // Watchonly and private keys
         if (watchOnly && keys.size()) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 "Incompatibility found between watchonly and keys");
         }
 
         // Internal + Label
         if (internal && data.exists("label")) {
             throw JSONRPCError(
                 RPC_INVALID_PARAMETER,
                 "Incompatibility found between internal and label");
         }
 
         // Not having Internal + Script
         if (!internal && isScript) {
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "Internal must be set for hex scriptPubKey");
         }
 
         // Keys / PubKeys size check.
         if (!isP2SH &&
             (keys.size() > 1 || pubKeys.size() > 1)) { // Address / scriptPubKey
             throw JSONRPCError(RPC_INVALID_PARAMETER,
                                "More than private key given for one address");
         }
 
         // Invalid P2SH redeemScript
         if (isP2SH && !IsHex(strRedeemScript)) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                "Invalid redeem script");
         }
 
         // Process. //
 
         // P2SH
         if (isP2SH) {
             // Import redeem script.
             std::vector<uint8_t> vData(ParseHex(strRedeemScript));
             CScript redeemScript = CScript(vData.begin(), vData.end());
 
             // Invalid P2SH address
             if (!script.IsPayToScriptHash()) {
                 throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                    "Invalid P2SH address / script");
             }
 
             pwallet->MarkDirty();
 
             if (!pwallet->AddWatchOnly(redeemScript, timestamp)) {
                 throw JSONRPCError(RPC_WALLET_ERROR,
                                    "Error adding address to wallet");
             }
 
-            if (!pwallet->HaveCScript(redeemScript) &&
+            CScriptID redeem_id(redeemScript);
+            if (!pwallet->HaveCScript(redeem_id) &&
                 !pwallet->AddCScript(redeemScript)) {
                 throw JSONRPCError(RPC_WALLET_ERROR,
                                    "Error adding p2sh redeemScript to wallet");
             }
 
-            CTxDestination redeem_dest = CScriptID(redeemScript);
-            CScript redeemDestination = GetScriptForDestination(redeem_dest);
+            CScript redeemDestination = GetScriptForDestination(redeem_id);
 
             if (::IsMine(*pwallet, redeemDestination) == ISMINE_SPENDABLE) {
                 throw JSONRPCError(RPC_WALLET_ERROR,
                                    "The wallet already contains the private "
                                    "key for this address or script");
             }
 
             pwallet->MarkDirty();
 
             if (!pwallet->AddWatchOnly(redeemDestination, timestamp)) {
                 throw JSONRPCError(RPC_WALLET_ERROR,
                                    "Error adding address to wallet");
             }
 
             // add to address book or update label
             if (IsValidDestination(dest)) {
                 pwallet->SetAddressBook(dest, label, "receive");
             }
 
             // Import private keys.
             if (keys.size()) {
                 for (size_t i = 0; i < keys.size(); i++) {
                     const std::string &privkey = keys[i].get_str();
 
                     CKey key = DecodeSecret(privkey);
 
                     if (!key.IsValid()) {
                         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                            "Invalid private key encoding");
                     }
 
                     CPubKey pubkey = key.GetPubKey();
                     assert(key.VerifyPubKey(pubkey));
 
                     CKeyID vchAddress = pubkey.GetID();
                     pwallet->MarkDirty();
                     pwallet->SetAddressBook(vchAddress, label, "receive");
 
                     if (pwallet->HaveKey(vchAddress)) {
                         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                            "Already have this key");
                     }
 
                     pwallet->mapKeyMetadata[vchAddress].nCreateTime = timestamp;
 
                     if (!pwallet->AddKeyPubKey(key, pubkey)) {
                         throw JSONRPCError(RPC_WALLET_ERROR,
                                            "Error adding key to wallet");
                     }
 
                     pwallet->UpdateTimeFirstKey(timestamp);
                 }
             }
 
             success = true;
         } else {
             // Import public keys.
             if (pubKeys.size() && keys.size() == 0) {
                 const std::string &strPubKey = pubKeys[0].get_str();
 
                 if (!IsHex(strPubKey)) {
                     throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                        "Pubkey must be a hex string");
                 }
 
                 std::vector<uint8_t> vData(ParseHex(strPubKey));
                 CPubKey pubKey(vData.begin(), vData.end());
 
                 if (!pubKey.IsFullyValid()) {
                     throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                        "Pubkey is not a valid public key");
                 }
 
                 CTxDestination pubkey_dest = pubKey.GetID();
 
                 // Consistency check.
                 if (!isScript && !(pubkey_dest == dest)) {
                     throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                        "Consistency check failed");
                 }
 
                 // Consistency check.
                 if (isScript) {
                     CTxDestination destination;
 
                     if (ExtractDestination(script, destination)) {
                         if (!(destination == pubkey_dest)) {
                             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                                "Consistency check failed");
                         }
                     }
                 }
 
                 CScript pubKeyScript = GetScriptForDestination(pubkey_dest);
 
                 if (::IsMine(*pwallet, pubKeyScript) == ISMINE_SPENDABLE) {
                     throw JSONRPCError(RPC_WALLET_ERROR, "The wallet already "
                                                          "contains the private "
                                                          "key for this address "
                                                          "or script");
                 }
 
                 pwallet->MarkDirty();
 
                 if (!pwallet->AddWatchOnly(pubKeyScript, timestamp)) {
                     throw JSONRPCError(RPC_WALLET_ERROR,
                                        "Error adding address to wallet");
                 }
 
                 // add to address book or update label
                 if (IsValidDestination(pubkey_dest)) {
                     pwallet->SetAddressBook(pubkey_dest, label, "receive");
                 }
 
                 // TODO Is this necessary?
                 CScript scriptRawPubKey = GetScriptForRawPubKey(pubKey);
 
                 if (::IsMine(*pwallet, scriptRawPubKey) == ISMINE_SPENDABLE) {
                     throw JSONRPCError(RPC_WALLET_ERROR, "The wallet already "
                                                          "contains the private "
                                                          "key for this address "
                                                          "or script");
                 }
 
                 pwallet->MarkDirty();
 
                 if (!pwallet->AddWatchOnly(scriptRawPubKey, timestamp)) {
                     throw JSONRPCError(RPC_WALLET_ERROR,
                                        "Error adding address to wallet");
                 }
 
                 success = true;
             }
 
             // Import private keys.
             if (keys.size()) {
                 const std::string &strPrivkey = keys[0].get_str();
 
                 // Checks.
                 CKey key = DecodeSecret(strPrivkey);
 
                 if (!key.IsValid()) {
                     throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                        "Invalid private key encoding");
                 }
 
                 CPubKey pubKey = key.GetPubKey();
                 assert(key.VerifyPubKey(pubKey));
 
                 CTxDestination pubkey_dest = pubKey.GetID();
 
                 // Consistency check.
                 if (!isScript && !(pubkey_dest == dest)) {
                     throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                        "Consistency check failed");
                 }
 
                 // Consistency check.
                 if (isScript) {
                     CTxDestination destination;
 
                     if (ExtractDestination(script, destination)) {
                         if (!(destination == pubkey_dest)) {
                             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY,
                                                "Consistency check failed");
                         }
                     }
                 }
 
                 CKeyID vchAddress = pubKey.GetID();
                 pwallet->MarkDirty();
                 pwallet->SetAddressBook(vchAddress, label, "receive");
 
                 if (pwallet->HaveKey(vchAddress)) {
                     throw JSONRPCError(RPC_WALLET_ERROR, "The wallet already "
                                                          "contains the private "
                                                          "key for this address "
                                                          "or script");
                 }
 
                 pwallet->mapKeyMetadata[vchAddress].nCreateTime = timestamp;
 
                 if (!pwallet->AddKeyPubKey(key, pubKey)) {
                     throw JSONRPCError(RPC_WALLET_ERROR,
                                        "Error adding key to wallet");
                 }
 
                 pwallet->UpdateTimeFirstKey(timestamp);
 
                 success = true;
             }
 
             // Import scriptPubKey only.
             if (pubKeys.size() == 0 && keys.size() == 0) {
                 if (::IsMine(*pwallet, script) == ISMINE_SPENDABLE) {
                     throw JSONRPCError(RPC_WALLET_ERROR, "The wallet already "
                                                          "contains the private "
                                                          "key for this address "
                                                          "or script");
                 }
 
                 pwallet->MarkDirty();
 
                 if (!pwallet->AddWatchOnly(script, timestamp)) {
                     throw JSONRPCError(RPC_WALLET_ERROR,
                                        "Error adding address to wallet");
                 }
 
                 if (scriptPubKey.getType() == UniValue::VOBJ) {
                     // add to address book or update label
                     if (IsValidDestination(dest)) {
                         pwallet->SetAddressBook(dest, label, "receive");
                     }
                 }
 
                 success = true;
             }
         }
 
         UniValue result = UniValue(UniValue::VOBJ);
         result.pushKV("success", UniValue(success));
         return result;
     } catch (const UniValue &e) {
         UniValue result = UniValue(UniValue::VOBJ);
         result.pushKV("success", UniValue(false));
         result.pushKV("error", e);
         return result;
     } catch (...) {
         UniValue result = UniValue(UniValue::VOBJ);
         result.pushKV("success", UniValue(false));
         result.pushKV("error",
                       JSONRPCError(RPC_MISC_ERROR, "Missing required fields"));
         return result;
     }
 }
 
 static int64_t GetImportTimestamp(const UniValue &data, int64_t now) {
     if (data.exists("timestamp")) {
         const UniValue &timestamp = data["timestamp"];
         if (timestamp.isNum()) {
             return timestamp.get_int64();
         } else if (timestamp.isStr() && timestamp.get_str() == "now") {
             return now;
         }
         throw JSONRPCError(RPC_TYPE_ERROR,
                            strprintf("Expected number or \"now\" timestamp "
                                      "value for key. got type %s",
                                      uvTypeName(timestamp.type())));
     }
     throw JSONRPCError(RPC_TYPE_ERROR,
                        "Missing required timestamp field for key");
 }
 
 UniValue importmulti(const Config &config, const JSONRPCRequest &mainRequest) {
     std::shared_ptr<CWallet> const wallet =
         GetWalletForJSONRPCRequest(mainRequest);
     CWallet *const pwallet = wallet.get();
     if (!EnsureWalletIsAvailable(pwallet, mainRequest.fHelp)) {
         return NullUniValue;
     }
 
     // clang-format off
     if (mainRequest.fHelp || mainRequest.params.size() < 1 || mainRequest.params.size() > 2) {
         throw std::runtime_error(
             "importmulti \"requests\" ( \"options\" )\n\n"
             "Import addresses/scripts (with private or public keys, redeem script (P2SH)), rescanning all addresses in one-shot-only (rescan can be disabled via options). Requires a new wallet backup.\n\n"
             "Arguments:\n"
             "1. requests     (array, required) Data to be imported\n"
             "  [     (array of json objects)\n"
             "    {\n"
             "      \"scriptPubKey\": \"<script>\" | { \"address\":\"<address>\" }, (string / json, required) Type of scriptPubKey (string for script, json for address)\n"
             "      \"timestamp\": timestamp | \"now\"                        , (integer / string, required) Creation time of the key in seconds since epoch (Jan 1 1970 GMT),\n"
             "                                                              or the string \"now\" to substitute the current synced blockchain time. The timestamp of the oldest\n"
             "                                                              key will determine how far back blockchain rescans need to begin for missing wallet transactions.\n"
             "                                                              \"now\" can be specified to bypass scanning, for keys which are known to never have been used, and\n"
             "                                                              0 can be specified to scan the entire blockchain. Blocks up to 2 hours before the earliest key\n"
             "                                                              creation time of all keys being imported by the importmulti call will be scanned.\n"
             "      \"redeemscript\": \"<script>\"                            , (string, optional) Allowed only if the scriptPubKey is a P2SH address or a P2SH scriptPubKey\n"
             "      \"pubkeys\": [\"<pubKey>\", ... ]                         , (array, optional) Array of strings giving pubkeys that must occur in the output or redeemscript\n"
             "      \"keys\": [\"<key>\", ... ]                               , (array, optional) Array of strings giving private keys whose corresponding public keys must occur in the output or redeemscript\n"
             "      \"internal\": <true>                                    , (boolean, optional, default: false) Stating whether matching outputs should be treated as not incoming payments\n"
             "      \"watchonly\": <true>                                   , (boolean, optional, default: false) Stating whether matching outputs should be considered watched even when they're not spendable, only allowed if keys are empty\n"
             "      \"label\": <label>                                      , (string, optional, default: '') Label to assign to the address (aka account name, for now), only allowed with internal=false\n"
             "    }\n"
             "  ,...\n"
             "  ]\n"
             "2. options                 (json, optional)\n"
             "  {\n"
             "     \"rescan\": <false>,         (boolean, optional, default: true) Stating if should rescan the blockchain after all imports\n"
             "  }\n"
             "\nNote: This call can take minutes to complete if rescan is true, during that time, other rpc calls\n"
             "may report that the imported keys, addresses or scripts exists but related transactions are still missing.\n"
             "\nExamples:\n" +
             HelpExampleCli("importmulti", "'[{ \"scriptPubKey\": { \"address\": \"<my address>\" }, \"timestamp\":1455191478 }, "
                                           "{ \"scriptPubKey\": { \"address\": \"<my 2nd address>\" }, \"label\": \"example 2\", \"timestamp\": 1455191480 }]'") +
             HelpExampleCli("importmulti", "'[{ \"scriptPubKey\": { \"address\": \"<my address>\" }, \"timestamp\":1455191478 }]' '{ \"rescan\": false}'") +
 
             "\nResponse is an array with the same size as the input that has the execution result :\n"
             "  [{ \"success\": true } , { \"success\": false, \"error\": { \"code\": -1, \"message\": \"Internal Server Error\"} }, ... ]\n");
     }
 
     // clang-format on
 
     RPCTypeCheck(mainRequest.params, {UniValue::VARR, UniValue::VOBJ});
 
     const UniValue &requests = mainRequest.params[0];
 
     // Default options
     bool fRescan = true;
 
     if (!mainRequest.params[1].isNull()) {
         const UniValue &options = mainRequest.params[1];
 
         if (options.exists("rescan")) {
             fRescan = options["rescan"].get_bool();
         }
     }
 
     WalletRescanReserver reserver(pwallet);
     if (fRescan && !reserver.reserve()) {
         throw JSONRPCError(
             RPC_WALLET_ERROR,
             "Wallet is currently rescanning. Abort existing rescan or wait.");
     }
 
     int64_t now = 0;
     bool fRunScan = false;
     int64_t nLowestTimestamp = 0;
     UniValue response(UniValue::VARR);
     {
         LOCK2(cs_main, pwallet->cs_wallet);
         EnsureWalletIsUnlocked(pwallet);
 
         // Verify all timestamps are present before importing any keys.
         now = chainActive.Tip() ? chainActive.Tip()->GetMedianTimePast() : 0;
         for (const UniValue &data : requests.getValues()) {
             GetImportTimestamp(data, now);
         }
 
         const int64_t minimumTimestamp = 1;
 
         if (fRescan && chainActive.Tip()) {
             nLowestTimestamp = chainActive.Tip()->GetBlockTime();
         } else {
             fRescan = false;
         }
 
         for (const UniValue &data : requests.getValues()) {
             const int64_t timestamp =
                 std::max(GetImportTimestamp(data, now), minimumTimestamp);
             const UniValue result = ProcessImport(pwallet, data, timestamp);
             response.push_back(result);
 
             if (!fRescan) {
                 continue;
             }
 
             // If at least one request was successful then allow rescan.
             if (result["success"].get_bool()) {
                 fRunScan = true;
             }
 
             // Get the lowest timestamp.
             if (timestamp < nLowestTimestamp) {
                 nLowestTimestamp = timestamp;
             }
         }
     }
     if (fRescan && fRunScan && requests.size()) {
         int64_t scannedTime = pwallet->RescanFromTime(
             nLowestTimestamp, reserver, true /* update */);
         pwallet->ReacceptWalletTransactions();
 
         if (pwallet->IsAbortingRescan()) {
             throw JSONRPCError(RPC_MISC_ERROR, "Rescan aborted by user.");
         }
         if (scannedTime > nLowestTimestamp) {
             std::vector<UniValue> results = response.getValues();
             response.clear();
             response.setArray();
             size_t i = 0;
             for (const UniValue &request : requests.getValues()) {
                 // If key creation date is within the successfully scanned
                 // range, or if the import result already has an error set, let
                 // the result stand unmodified. Otherwise replace the result
                 // with an error message.
                 if (scannedTime <= GetImportTimestamp(request, now) ||
                     results.at(i).exists("error")) {
                     response.push_back(results.at(i));
                 } else {
                     UniValue result = UniValue(UniValue::VOBJ);
                     result.pushKV("success", UniValue(false));
                     result.pushKV(
                         "error",
                         JSONRPCError(
                             RPC_MISC_ERROR,
                             strprintf(
                                 "Rescan failed for key with creation timestamp "
                                 "%d. There was an error reading a block from "
                                 "time %d, which is after or within %d seconds "
                                 "of key creation, and could contain "
                                 "transactions pertaining to the key. As a "
                                 "result, transactions and coins using this key "
                                 "may not appear in the wallet. This error "
                                 "could be caused by pruning or data corruption "
                                 "(see bitcoind log for details) and could be "
                                 "dealt with by downloading and rescanning the "
                                 "relevant blocks (see -reindex and -rescan "
                                 "options).",
                                 GetImportTimestamp(request, now),
                                 scannedTime - TIMESTAMP_WINDOW - 1,
                                 TIMESTAMP_WINDOW)));
                     response.push_back(std::move(result));
                 }
                 ++i;
             }
         }
     }
 
     return response;
 }
 
 // clang-format off
 static const ContextFreeRPCCommand commands[] = {
     //  category            name                        actor (function)          argNames
     //  ------------------- ------------------------    ----------------------    ----------
     { "wallet",             "abortrescan",              abortrescan,              {} },
     { "wallet",             "dumpprivkey",              dumpprivkey,              {"address"}  },
     { "wallet",             "dumpwallet",               dumpwallet,               {"filename"} },
     { "wallet",             "importmulti",              importmulti,              {"requests","options"} },
     { "wallet",             "importprivkey",            importprivkey,            {"privkey","label","rescan"} },
     { "wallet",             "importwallet",             importwallet,             {"filename"} },
     { "wallet",             "importaddress",            importaddress,            {"address","label","rescan","p2sh"} },
     { "wallet",             "importprunedfunds",        importprunedfunds,        {"rawtransaction","txoutproof"} },
     { "wallet",             "importpubkey",             importpubkey,             {"pubkey","label","rescan"} },
     { "wallet",             "removeprunedfunds",        removeprunedfunds,        {"txid"} },
 };
 // clang-format on
 
 void RegisterDumpRPCCommands(CRPCTable &t) {
     for (unsigned int vcidx = 0; vcidx < ARRAYLEN(commands); vcidx++) {
         t.appendCommand(commands[vcidx].name, &commands[vcidx]);
     }
 }
diff --git a/test/functional/abc-wallet-standardness.py b/test/functional/abc-wallet-standardness.py
index bcb05f0f5e..e49df70de4 100755
--- a/test/functional/abc-wallet-standardness.py
+++ b/test/functional/abc-wallet-standardness.py
@@ -1,180 +1,186 @@
 #!/usr/bin/env python3
 # Copyright (c) 2019 The Bitcoin developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test the response of wallet to a variety of weird / nonstandard coins
 that it might try to spend."""
 
 from decimal import Decimal
 from test_framework.script import (
     CScript,
     OP_1,
     OP_5,
     OP_CHECKSIG,
     OP_CHECKMULTISIG,
     OP_DUP,
     OP_EQUALVERIFY,
     OP_HASH160,
     OP_PUSHDATA1,
     hash160,
 )
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_raises_rpc_error,
     assert_equal,
     sync_blocks,
 )
 from test_framework.messages import (
     CTransaction,
     CTxOut,
     FromHex,
     ToHex,
 )
 
 SATOSHI = Decimal('0.00000001')
 
 
 class WalletStandardnessTest(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 2
         self.extra_args = [['-acceptnonstdtxn=0'], ['-acceptnonstdtxn=1']]
 
     def run_test(self):
         std_node, nonstd_node = self.nodes
 
         address_nonstd = nonstd_node.getnewaddress()
 
         # make and mature some coins for the nonstandard node
         nonstd_node.generate(120)
         sync_blocks(self.nodes)
 
-        def fund_and_test_wallet(scriptPubKey, shouldBeStandard, shouldBeInWallet, amount=10000, spendfee=500, nonstd_error="scriptpubkey (code 64)"):
+        def fund_and_test_wallet(scriptPubKey, shouldBeStandard, shouldBeInWallet,
+                                 amount=10000, spendfee=500, nonstd_error="scriptpubkey (code 64)", canSign=None):
             """ Get the nonstandard node to fund a transaction, test its
             standardness by trying to broadcast on the standard node, then
             mine it and see if it ended up in the standard node's wallet.
             Finally, it attempts to spend the coin.
             """
 
+            if canSign is None:
+                canSign = shouldBeInWallet
+
             self.log.info("Trying script {}".format(scriptPubKey.hex(),))
 
             # get nonstandard node to fund the script
             tx = CTransaction()
             tx.vout.append(CTxOut(max(amount, 10000), scriptPubKey))
             rawtx = nonstd_node.fundrawtransaction(
                 ToHex(tx), {'lockUnspents': True, 'changePosition': 1})['hex']
             # fundrawtransaction doesn't like to fund dust outputs, so we
             # have to manually override the amount.
             FromHex(tx, rawtx)
             tx.vout[0].nValue = min(amount, 10000)
             rawtx = nonstd_node.signrawtransactionwithwallet(ToHex(tx))['hex']
 
             # ensure signing process did not disturb scriptPubKey
             signedtx = FromHex(CTransaction(), rawtx)
             assert_equal(scriptPubKey, signedtx.vout[0].scriptPubKey)
             txid = signedtx.rehash()
 
             balance_initial = std_node.getbalance()
 
             # try broadcasting it on the standard node
             if shouldBeStandard:
                 std_node.sendrawtransaction(rawtx)
                 assert txid in std_node.getrawmempool()
             else:
                 assert_raises_rpc_error(-26, nonstd_error,
                                         std_node.sendrawtransaction, rawtx)
                 assert txid not in std_node.getrawmempool()
 
             # make sure it's in nonstandard node's mempool, then mine it
             nonstd_node.sendrawtransaction(rawtx)
             assert txid in nonstd_node.getrawmempool()
             [blockhash] = nonstd_node.generate(1)
             # make sure it was mined
             assert txid in nonstd_node.getblock(blockhash)["tx"]
 
             sync_blocks(self.nodes)
 
             wallet_outpoints = {(entry['txid'], entry['vout'])
                                 for entry in std_node.listunspent()}
 
             # calculate wallet balance change just as a double check
             balance_change = std_node.getbalance() - balance_initial
+            if shouldBeInWallet:
+                assert (txid, 0) in wallet_outpoints
+                assert balance_change == amount * SATOSHI
+            else:
+                assert (txid, 0) not in wallet_outpoints
+                assert balance_change == 0
 
             # try spending the funds using the wallet.
             outamount = (amount - spendfee) * SATOSHI
             if outamount < 546 * SATOSHI:
                 # If the final amount would be too small, then just donate
                 # to miner fees.
                 outputs = [{"data": b"to miner, with love".hex()}]
             else:
                 outputs = [{address_nonstd: outamount}]
             spendtx = std_node.createrawtransaction(
                 [{'txid': txid, 'vout': 0}], outputs)
             signresult = std_node.signrawtransactionwithwallet(spendtx)
 
-            if shouldBeInWallet:
-                assert (txid, 0) in wallet_outpoints
-                assert balance_change == amount * SATOSHI
+            if canSign:
                 assert_equal(signresult['complete'], True)
                 txid = std_node.sendrawtransaction(signresult['hex'])
                 [blockhash] = std_node.generate(1)
                 # make sure it was mined
                 assert txid in std_node.getblock(blockhash)["tx"]
                 sync_blocks(self.nodes)
             else:
-                assert (txid, 0) not in wallet_outpoints
-                assert balance_change == 0
                 # signresult['errors'] will vary depending on input script. What
                 # occurs is that in sign.cpp, ProduceSignature gets back
                 # solved=false since SignStep sees a nonstandard input. Then,
                 # an empty SignatureData results. Back in rawtransaction.cpp's
                 # SignTransaction, it will then attempt to execute the
                 # scriptPubKey with an empty scriptSig. A P2PKH script will thus
                 # fail at OP_DUP with stack error, and P2PK/Multisig will fail
                 # once they hit a nonminimal push. The error message is just an
                 # artifact of the script type, basically.
                 assert_equal(signresult['complete'], False)
 
         # we start with an empty wallet
         assert_equal(std_node.getbalance(), 0)
 
         address = std_node.getnewaddress()
         pubkey = bytes.fromhex(std_node.getaddressinfo(address)['pubkey'])
         pubkeyhash = hash160(pubkey)
 
         # P2PK
         fund_and_test_wallet(CScript([pubkey, OP_CHECKSIG]), True, True)
         fund_and_test_wallet(
             CScript([OP_PUSHDATA1, pubkey, OP_CHECKSIG]), False, False)
 
         # P2PKH
         fund_and_test_wallet(CScript(
             [OP_DUP, OP_HASH160, pubkeyhash, OP_EQUALVERIFY, OP_CHECKSIG]), True, True)
         fund_and_test_wallet(CScript(
             [OP_DUP, OP_HASH160, OP_PUSHDATA1, pubkeyhash, OP_EQUALVERIFY, OP_CHECKSIG]), False, False)
 
         # Bare multisig
         fund_and_test_wallet(
-            CScript([OP_1, pubkey, OP_1, OP_CHECKMULTISIG]), True, True)
+            CScript([OP_1, pubkey, OP_1, OP_CHECKMULTISIG]), True, False, canSign=True)
         fund_and_test_wallet(
             CScript([OP_1, OP_PUSHDATA1, pubkey, OP_1, OP_CHECKMULTISIG]), False, False)
         fund_and_test_wallet(
             CScript([OP_1, pubkey, b'\x01', OP_CHECKMULTISIG]), False, False)
         fund_and_test_wallet(
             CScript([b'\x01', pubkey, OP_1, OP_CHECKMULTISIG]), False, False)
         # Note: 1-of-5 is nonstandard to fund but standard to spend.
         fund_and_test_wallet(
-            CScript([OP_1, pubkey, pubkey, pubkey, pubkey, pubkey, OP_5, OP_CHECKMULTISIG]), False, True)
+            CScript([OP_1, pubkey, pubkey, pubkey, pubkey, pubkey, OP_5, OP_CHECKMULTISIG]), False, False, canSign=True)
         fund_and_test_wallet(
             CScript([OP_1, pubkey, pubkey, pubkey, OP_PUSHDATA1, pubkey, pubkey, OP_5, OP_CHECKMULTISIG]), False, False)
 
         # Dust also is nonstandard to fund but standard to spend.
         fund_and_test_wallet(
             CScript([pubkey, OP_CHECKSIG]), False, True, amount=200, nonstd_error="dust (code 64)")
 
         # and we end with an empty wallet
         assert_equal(std_node.getbalance(), 0)
 
 
 if __name__ == '__main__':
     WalletStandardnessTest().main()