diff --git a/Makefile.am b/Makefile.am
index 570791a64b6c6..291e09c535160 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -269,6 +269,8 @@ EXTRA_DIST += \
     test/util/data/txcreatesignv1.hex \
     test/util/data/txcreatesignv1.json \
     test/util/data/txcreatesignv2.hex \
+    test/util/data/txcreatemultisig4_elements.hex \
+    test/util/data/txcreatemultisig4_elements.json \
     test/util/rpcauth-test.py
 
 CLEANFILES = $(OSX_DMG) $(BITCOIN_WIN_INSTALLER)
diff --git a/README.md b/README.md
index 55b85da977abb..a5ebc8441476b 100644
--- a/README.md
+++ b/README.md
@@ -74,3 +74,7 @@ Translations are periodically pulled from Transifex and merged into the git repo
 pull from Transifex would automatically overwrite them again.
 
 Translators should also subscribe to the [mailing list](https://groups.google.com/forum/#!forum/bitcoin-translators).
+
+Secure Reporting
+------------------
+See [our vulnerability reporting guide](SECURITY.md)
\ No newline at end of file
diff --git a/SECURITY.md b/SECURITY.md
new file mode 100644
index 0000000000000..b183d770c64df
--- /dev/null
+++ b/SECURITY.md
@@ -0,0 +1,894 @@
+# Security
+
+The maintainers of Elements take security very seriously and are committed to addressing any disclosed security vulnerabilities quickly and carefully. If you find a security vulnerability, please report it to us following the steps described here.
+
+## Reporting a Vulnerability
+
+Privately and confidentially send us a description of the vulnerability that you have discovered using an encrypted and authenticated channel. PGP encrypted email is preferred. Our contact information is given below.
+
+In your report, please include as much information as you can, including:
+
+* a description of the vulnerability and how it could be exploited
+* its potential impact (e.g. privacy leak, denial of service, theft of funds)
+* steps or code for reproducing it
+* a proposed patch for remedying it
+
+Also, provide us with a secure means to contact you with any follow up questions we might have.
+
+## Considerations
+
+Please take care not to violate the privacy of users in your report. For example, stack traces or exploit scripts sent to us should never contain private keys or personally identifiable information.
+
+Give us at least one week to investigate the vulnerability you found and up to 90 days to fix it. Also, please give us reasonable advanced notice if at any point you intend to disclose the vulnerability to anyone else.
+
+In general, please investigate and report bugs in a way that makes a reasonable, good faith effort not to be disruptive or harmful to us, this software's users, or the users of dependent projects.
+
+We will take care to inform the maintainers of dependent projects.
+
+## How to Contact Us
+
+Greg Sanders
+gsanders@blockstream.com
+
+
+```
+-----BEGIN PGP PUBLIC KEY BLOCK-----
+Version: GnuPG v1
+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bKfQ
+-----END PGP PUBLIC KEY BLOCK-----
+```
+
+## Escalation
+
+If there is no response from the authors within 3 days, please escalate your vulnerability report by emailing security@blockstream.com using this PGP key:
+
+
+```
+-----BEGIN PGP PUBLIC KEY BLOCK-----
+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+=8mAH
+-----END PGP PUBLIC KEY BLOCK-----
+```
+
+## Acknowledgement
+
+Your help in maintaining and improving the security of this software is deeply appreciated. When the vulnerability you have reported is patched here and in downstream dependencies, we will publicly disclose it. Let us know if you would like to remain anonymous or would like to be acknowledged. We would be happy to acknowledge your contributions to closing the vulnerability you found in the release notes, source code and/or documentation in this repository.
diff --git a/configure.ac b/configure.ac
index 6d48bed030135..491d17284a0b3 100644
--- a/configure.ac
+++ b/configure.ac
@@ -256,7 +256,7 @@ if test "x$enable_debug" = xyes; then
   # Prefer -Og, fall back to -O0 if that is unavailable.
   AX_CHECK_COMPILE_FLAG(
     [-Og],
-    [[DEBUG_CXXFLAGS="$DEBUG_CXXFLAGS -Og"]],
+    [[DEBUG_CXXFLAGS="$DEBUG_CXXFLAGS -O0"]],
     [AX_CHECK_COMPILE_FLAG([-O0],[[DEBUG_CXXFLAGS="$DEBUG_CXXFLAGS -O0"]],,[[$CXXFLAG_WERROR]])],
     [[$CXXFLAG_WERROR]])
 
@@ -1459,7 +1459,7 @@ if test x$need_bundled_univalue = xyes; then
   AC_CONFIG_SUBDIRS([src/univalue])
 fi
 
-ac_configure_args="${ac_configure_args} --disable-shared --with-pic --with-bignum=no --enable-module-recovery --disable-jni --enable-experimental --enable-module-whitelist --enable-module-rangeproof --enable-module-generator"
+ac_configure_args="${ac_configure_args} --disable-shared --with-pic --with-bignum=no --enable-module-recovery --disable-jni --enable-experimental --enable-module-whitelist --enable-module-rangeproof --enable-module-generator --enable-module-surjectionproof --enable-module-ecdh"
 AC_CONFIG_SUBDIRS([src/secp256k1])
 
 AC_OUTPUT
diff --git a/src/Makefile.am b/src/Makefile.am
index a2d67258c9b5c..e9470bdbbc1ef 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -92,8 +92,12 @@ endif
 BITCOIN_CORE_H = \
   addrdb.h \
   addrman.h \
+  asset.h \
+  assetsdir.h \
   base58.h \
   bech32.h \
+  blech32.h \
+  blind.h \
   bloom.h \
   blockencodings.h \
   blockfilter.h \
@@ -111,6 +115,7 @@ BITCOIN_CORE_H = \
   compat/endian.h \
   compat/sanity.h \
   compressor.h \
+  confidential_validation.h \
   consensus/consensus.h \
   consensus/tx_verify.h \
   core_io.h \
@@ -126,6 +131,7 @@ BITCOIN_CORE_H = \
   interfaces/handler.h \
   interfaces/node.h \
   interfaces/wallet.h \
+  issuance.h \
   key.h \
   key_io.h \
   keystore.h \
@@ -223,12 +229,14 @@ libbitcoin_server_a_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
 libbitcoin_server_a_SOURCES = \
   addrdb.cpp \
   addrman.cpp \
+  assetsdir.cpp \
   bloom.cpp \
   blockencodings.cpp \
   blockfilter.cpp \
   block_proof.cpp \
   chain.cpp \
   checkpoints.cpp \
+  confidential_validation.cpp \
   consensus/tx_verify.cpp \
   httprpc.cpp \
   httpserver.cpp \
@@ -290,6 +298,7 @@ endif
 libbitcoin_wallet_a_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES)
 libbitcoin_wallet_a_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
 libbitcoin_wallet_a_SOURCES = \
+  assetsdir.cpp \
   interfaces/wallet.cpp \
   wallet/coincontrol.cpp \
   wallet/crypter.cpp \
@@ -358,6 +367,7 @@ libbitcoin_consensus_a_SOURCES = \
   amount.h \
   arith_uint256.cpp \
   arith_uint256.h \
+  asset.cpp \
   consensus/merkle.cpp \
   consensus/merkle.h \
   consensus/params.h \
@@ -367,6 +377,8 @@ libbitcoin_consensus_a_SOURCES = \
   prevector.h \
   primitives/block.cpp \
   primitives/block.h \
+  primitives/confidential.cpp \
+  primitives/confidential.h \
   primitives/txwitness.cpp \
   primitives/txwitness.h \
   primitives/transaction.cpp \
@@ -403,11 +415,14 @@ libbitcoin_common_a_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
 libbitcoin_common_a_SOURCES = \
   base58.cpp \
   bech32.cpp \
+  blech32.cpp \
+  blind.cpp \
   chainparams.cpp \
   coins.cpp \
   compressor.cpp \
   core_read.cpp \
   core_write.cpp \
+  issuance.cpp \
   key.cpp \
   key_io.cpp \
   keystore.cpp \
diff --git a/src/Makefile.test.include b/src/Makefile.test.include
index 0f6895768f8e8..f7668d804be7a 100644
--- a/src/Makefile.test.include
+++ b/src/Makefile.test.include
@@ -96,7 +96,8 @@ BITCOIN_TESTS =\
   test/util_tests.cpp \
   test/validation_block_tests.cpp \
   test/versionbits_tests.cpp \
-  test/pegin_spent_tests.cpp
+  test/pegin_spent_tests.cpp \
+  test/blind_tests.cpp
 # ELEMENTS IN THE END
 
 if ENABLE_PROPERTY_TESTS
diff --git a/src/asset.cpp b/src/asset.cpp
new file mode 100644
index 0000000000000..9831c7ea5c040
--- /dev/null
+++ b/src/asset.cpp
@@ -0,0 +1,149 @@
+
+#include <asset.h>
+
+CAmountMap& operator+=(CAmountMap& a, const CAmountMap& b)
+{
+    for(std::map<CAsset, CAmount>::const_iterator it = b.begin(); it != b.end(); ++it)
+        a[it->first] += it->second;
+    return a;
+}
+
+CAmountMap& operator-=(CAmountMap& a, const CAmountMap& b)
+{
+    for(std::map<CAsset, CAmount>::const_iterator it = b.begin(); it != b.end(); ++it)
+        a[it->first] -= it->second;
+    return a;
+}
+
+CAmountMap operator+(const CAmountMap& a, const CAmountMap& b)
+{
+    CAmountMap c;
+    for(std::map<CAsset, CAmount>::const_iterator it = a.begin(); it != a.end(); ++it)
+        c[it->first] += it->second;
+    for(std::map<CAsset, CAmount>::const_iterator it = b.begin(); it != b.end(); ++it)
+        c[it->first] += it->second;
+    return c;
+}
+
+CAmountMap operator-(const CAmountMap& a, const CAmountMap& b)
+{
+    CAmountMap c;
+    for(std::map<CAsset, CAmount>::const_iterator it = a.begin(); it != a.end(); ++it)
+        c[it->first] += it->second;
+    for(std::map<CAsset, CAmount>::const_iterator it = b.begin(); it != b.end(); ++it)
+        c[it->first] -= it->second;
+    return c;
+}
+
+bool operator<(const CAmountMap& a, const CAmountMap& b)
+{
+    bool smallerElement = false;
+    for(std::map<CAsset, CAmount>::const_iterator it = b.begin(); it != b.end(); ++it) {
+        CAmount aValue = a.count(it->first) ? a.find(it->first)->second : 0;
+        if (aValue > it->second)
+            return false;
+        if (aValue < it->second)
+            smallerElement = true;
+    }
+    for(std::map<CAsset, CAmount>::const_iterator it = a.begin(); it != a.end(); ++it) {
+        CAmount bValue = b.count(it->first) ? b.find(it->first)->second : 0;
+        if (it->second > bValue)
+            return false;
+        if (it->second < bValue)
+            smallerElement = true;
+    }
+    return smallerElement;
+}
+
+bool operator<=(const CAmountMap& a, const CAmountMap& b)
+{
+    for(std::map<CAsset, CAmount>::const_iterator it = b.begin(); it != b.end(); ++it) {
+        CAmount aValue = a.count(it->first) ? a.find(it->first)->second : 0;
+        if (aValue > it->second)
+            return false;
+    }
+    for(std::map<CAsset, CAmount>::const_iterator it = a.begin(); it != a.end(); ++it) {
+        CAmount bValue = b.count(it->first) ? b.find(it->first)->second : 0;
+        if (it->second > bValue)
+            return false;
+    }
+    return true;
+}
+
+bool operator>(const CAmountMap& a, const CAmountMap& b)
+{
+    bool largerElement = false;
+    for(std::map<CAsset, CAmount>::const_iterator it = b.begin(); it != b.end(); ++it) {
+        CAmount aValue = a.count(it->first) ? a.find(it->first)->second : 0;
+        if (aValue < it->second)
+            return false;
+        if (aValue > it->second)
+            largerElement = true;
+    }
+    for(std::map<CAsset, CAmount>::const_iterator it = a.begin(); it != a.end(); ++it) {
+        CAmount bValue = b.count(it->first) ? b.find(it->first)->second : 0;
+        if (it->second < bValue)
+            return false;
+        if (it->second > bValue)
+            largerElement = true;
+    }
+    return largerElement;
+}
+
+bool operator>=(const CAmountMap& a, const CAmountMap& b)
+{
+    for(std::map<CAsset, CAmount>::const_iterator it = b.begin(); it != b.end(); ++it) {
+        if ((a.count(it->first) ? a.find(it->first)->second : 0) < it->second)
+            return false;
+    }
+    for(std::map<CAsset, CAmount>::const_iterator it = a.begin(); it != a.end(); ++it) {
+        if (it->second < (b.count(it->first) ? b.find(it->first)->second : 0))
+            return false;
+    }
+    return true;
+}
+
+bool operator==(const CAmountMap& a, const CAmountMap& b)
+{
+    for(std::map<CAsset, CAmount>::const_iterator it = a.begin(); it != a.end(); ++it) {
+        if ((b.count(it->first) ? b.find(it->first)->second : 0) != it->second)
+            return false;
+    }
+    for(std::map<CAsset, CAmount>::const_iterator it = b.begin(); it != b.end(); ++it) {
+        if ((a.count(it->first) ? a.find(it->first)->second : 0) != it->second)
+            return false;
+    }
+    return true;
+}
+
+bool operator!=(const CAmountMap& a, const CAmountMap& b)
+{
+    return !(a == b);
+}
+
+bool hasNegativeValue(const CAmountMap& amount)
+{
+    for(std::map<CAsset, CAmount>::const_iterator it = amount.begin(); it != amount.end(); ++it) {
+        if (it->second < 0)
+            return true;
+    }
+    return false;
+}
+
+bool hasNonPostiveValue(const CAmountMap& amount)
+{
+    for(std::map<CAsset, CAmount>::const_iterator it = amount.begin(); it != amount.end(); ++it) {
+        if (it->second <= 0)
+            return true;
+    }
+    return false;
+}
+
+CAmount valueFor(const CAmountMap& mapValue, const CAsset& asset) {
+    CAmountMap::const_iterator it = mapValue.find(asset);
+    if (it != mapValue.end()) {
+        return it->second;
+    } else {
+        return CAmount(0);
+    }
+}
diff --git a/src/asset.h b/src/asset.h
new file mode 100644
index 0000000000000..381df84c4f11a
--- /dev/null
+++ b/src/asset.h
@@ -0,0 +1,108 @@
+
+#ifndef BITCOIN_ASSET_H
+#define BITCOIN_ASSET_H
+
+#include <uint256.h>
+
+#include <amount.h>
+#include <serialize.h>
+
+/**
+ *  Native Asset Issuance
+ *
+ *  An asset identifier tag, a 256 bits serialized hash (sha256) defined
+ *  by the issuance transaction from which the output’s coins are derived.
+ *  Each output contains coins from a single asset/currency.
+ *  For the host currency, the similarly-calculated hash of the chain’s genesis
+ *  block is used instead.
+**/
+struct CAsset {
+    uint256 id;
+
+    CAsset() { }
+    explicit CAsset(const uint256& idIn) : id(idIn) { }
+    explicit CAsset(const std::vector<unsigned char>& vchIDIn) : id(vchIDIn) { }
+
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action) {
+        READWRITE(id);
+    }
+
+    bool IsNull() const { return id.IsNull(); }
+    void SetNull() { id.SetNull(); }
+
+    unsigned char* begin() { return id.begin(); }
+    unsigned char* end() { return id.end(); }
+    const unsigned char* begin() const { return id.begin(); }
+    const unsigned char* end() const { return id.end(); }
+
+    std::string GetHex() const { return id.GetHex(); }
+    void SetHex(const std::string& str) { id.SetHex(str); }
+
+    friend bool operator==(const CAsset& a, const CAsset& b)
+    {
+        return a.id == b.id;
+    }
+
+    friend bool operator!=(const CAsset& a, const CAsset& b)
+    {
+        return !(a == b);
+    }
+
+    friend bool operator<(const CAsset& a, const CAsset& b)
+    {
+        return a.id < b.id;
+    }
+};
+
+/** Used for consensus fee and general wallet accounting*/
+typedef std::map<CAsset, CAmount> CAmountMap;
+
+CAmountMap& operator+=(CAmountMap& a, const CAmountMap& b);
+CAmountMap& operator-=(CAmountMap& a, const CAmountMap& b);
+CAmountMap operator+(const CAmountMap& a, const CAmountMap& b);
+CAmountMap operator-(const CAmountMap& a, const CAmountMap& b);
+
+// WARNING: Comparisons are only looking for *complete* ordering.
+// For strict inequality checks, if any entry would fail the non-strict
+// inequality, the comparison will fail. Therefore it is possible
+// that all inequality comparison checks may fail.
+// Therefore if >/< fails against a CAmountMap(), this means there
+// are all zeroes or one or more negative values.
+//
+// Examples: 1A + 2B <= 1A + 2B + 1C
+//      and  1A + 2B <  1A + 2B + 1C
+//                   but
+//           !(1A + 2B == 1A + 2B + 1C)
+//-------------------------------------
+//           1A + 2B == 1A + 2B
+//      and  1A + 2B <= 1A + 2B
+//                   but
+//           !(1A + 2B < 1A + 2B)
+//-------------------------------------
+//           !(1A + 2B == 2B - 1C)
+//           !(1A + 2B >= 2B - 1C)
+//                     ...
+//           !(1A + 2B < 2B - 1C)
+//      and   1A + 2B != 2B - 1C
+bool operator<(const CAmountMap& a, const CAmountMap& b);
+bool operator<=(const CAmountMap& a, const CAmountMap& b);
+bool operator>(const CAmountMap& a, const CAmountMap& b);
+bool operator>=(const CAmountMap& a, const CAmountMap& b);
+bool operator==(const CAmountMap& a, const CAmountMap& b);
+bool operator!=(const CAmountMap& a, const CAmountMap& b);
+
+inline bool MoneyRange(const CAmountMap& mapValue) {
+    for(CAmountMap::const_iterator it = mapValue.begin(); it != mapValue.end(); it++) {
+        if (it->second < 0 || it->second > MAX_MONEY) {
+            return false;
+        }
+    }
+   return true;
+}
+
+CAmount valueFor(const CAmountMap& mapValue, const CAsset& asset);
+
+#endif //  BITCOIN_AMOUNT_H
diff --git a/src/assetsdir.cpp b/src/assetsdir.cpp
new file mode 100644
index 0000000000000..0b897828a3542
--- /dev/null
+++ b/src/assetsdir.cpp
@@ -0,0 +1,99 @@
+// Copyright (c) 2017-2017 The Elements Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <assetsdir.h>
+#include <chainparams.h>
+
+#include <tinyformat.h>
+#include <utilstrencodings.h>
+
+#include <boost/algorithm/string/classification.hpp>
+#include <boost/algorithm/string/split.hpp>
+
+void CAssetsDir::Set(const CAsset& asset, const AssetMetadata& metadata)
+{
+    // No asset or label repetition
+    if (GetLabel(asset) != "")
+        throw std::runtime_error(strprintf("duplicated asset '%s'", asset.GetHex()));
+    if (GetAsset(metadata.GetLabel()) != CAsset())
+        throw std::runtime_error(strprintf("duplicated label '%s'", metadata.GetLabel()));
+
+    mapAssetMetadata[asset] = metadata;
+    mapAssets[metadata.GetLabel()] = asset;
+}
+
+void CAssetsDir::SetHex(const std::string& assetHex, const std::string& label)
+{
+    if (!IsHex(assetHex) || assetHex.size() != 64)
+        throw std::runtime_error("The asset must be hex string of length 64");
+
+    const std::vector<std::string> protectedLabels = {"", "*", "bitcoin", "Bitcoin", "btc"};
+    for (std::string proLabel : protectedLabels) {
+        if (label == proLabel) {
+            throw std::runtime_error(strprintf("'%s' label is protected", proLabel));
+        }
+    }
+    Set(CAsset(uint256S(assetHex)), AssetMetadata(label));
+}
+
+void CAssetsDir::InitFromStrings(const std::vector<std::string>& assetsToInit, const std::string& pegged_asset_name)
+{
+    for (std::string strToSplit : assetsToInit) {
+        std::vector<std::string> vAssets;
+        boost::split(vAssets, strToSplit, boost::is_any_of(":"));
+        if (vAssets.size() != 2) {
+            throw std::runtime_error("-assetdir parameters malformed, expecting asset:label");
+        }
+        SetHex(vAssets[0], vAssets[1]);
+    }
+    // Set "bitcoin" to the pegged asset for tests
+    Set(Params().GetConsensus().pegged_asset, AssetMetadata(pegged_asset_name));
+}
+
+CAsset CAssetsDir::GetAsset(const std::string& label) const
+{
+    auto it = mapAssets.find(label);
+    if (it != mapAssets.end())
+        return it->second;
+    return CAsset();
+}
+
+AssetMetadata CAssetsDir::GetMetadata(const CAsset& asset) const
+{
+    auto it = mapAssetMetadata.find(asset);
+    if (it != mapAssetMetadata.end())
+        return it->second;
+    return AssetMetadata("");
+}
+
+std::string CAssetsDir::GetLabel(const CAsset& asset) const
+{
+    return GetMetadata(asset).GetLabel();
+}
+
+std::vector<CAsset> CAssetsDir::GetKnownAssets() const
+{
+    std::vector<CAsset> knownAssets;
+    for (auto it = mapAssets.begin(); it != mapAssets.end(); it++) {
+        knownAssets.push_back(it->second);
+    }
+    return knownAssets;
+}
+
+CAsset GetAssetFromString(const std::string& strasset) {
+    CAsset asset = gAssetsDir.GetAsset(strasset);
+    if (asset.IsNull() && strasset.size() == 64 && IsHex(strasset)) {
+        asset = CAsset(uint256S(strasset));
+    }
+    return asset;
+}
+
+// GLOBAL:
+CAssetsDir _gAssetsDir;
+const CAssetsDir& gAssetsDir = _gAssetsDir;
+
+void InitGlobalAssetDir(const std::vector<std::string>& assetsToInit, const std::string& pegged_asset_name)
+{
+    _gAssetsDir.InitFromStrings(assetsToInit, pegged_asset_name);
+}
diff --git a/src/assetsdir.h b/src/assetsdir.h
new file mode 100644
index 0000000000000..0c6e6814ca78b
--- /dev/null
+++ b/src/assetsdir.h
@@ -0,0 +1,60 @@
+
+#ifndef BITCOIN_ASSETSDIR_H
+#define BITCOIN_ASSETSDIR_H
+
+#include <asset.h>
+
+#include <map>
+
+class AssetMetadata
+{
+    std::string label;
+public:
+    AssetMetadata() : label("") {};
+    AssetMetadata(std::string _label) : label(_label) {};
+
+    const std::string& GetLabel() const
+    {
+        return label;
+    }
+};
+
+class CAssetsDir
+{
+    std::map<CAsset, AssetMetadata> mapAssetMetadata;
+    std::map<std::string, CAsset> mapAssets;
+
+    void Set(const CAsset& asset, const AssetMetadata& metadata);
+    void SetHex(const std::string& assetHex, const std::string& label);
+public:
+    void InitFromStrings(const std::vector<std::string>& assetsToInit, const std::string& pegged_asset_name);
+
+    /**
+     * @param  label A label string
+     * @return asset id corresponding to the asset label
+     */
+    CAsset GetAsset(const std::string& label) const;
+
+    AssetMetadata GetMetadata(const CAsset& asset) const;
+
+    /** @return the label associated to the asset id */
+    std::string GetLabel(const CAsset& asset) const;
+
+    std::vector<CAsset> GetKnownAssets() const;
+};
+
+/**
+ * Returns asset id corresponding to the given asset expression, which is either an asset label or a hex value.
+ * @param  strasset A label string or a hex value corresponding to an asset
+ * @return       The asset ID for the given expression
+ */
+CAsset GetAssetFromString(const std::string& strasset);
+
+// GLOBAL:
+class CAssetsDir;
+
+extern const CAssetsDir& gAssetsDir;
+
+void InitGlobalAssetDir(const std::vector<std::string>& assetsToInit, const std::string& pegged_asset_name);
+
+#endif // BITCOIN_ASSETSDIR_H
diff --git a/src/bench/block_assemble.cpp b/src/bench/block_assemble.cpp
index 46d2bb4642fa4..5b9acdbc0418a 100644
--- a/src/bench/block_assemble.cpp
+++ b/src/bench/block_assemble.cpp
@@ -95,7 +95,7 @@ static void AssembleBlock(benchmark::State& state)
         tx.vin.push_back(MineBlock(SCRIPT_PUB));
         tx.witness.vtxinwit.resize(1);
         tx.witness.vtxinwit.back().scriptWitness = witness;
-        tx.vout.emplace_back(1337, SCRIPT_PUB);
+        tx.vout.emplace_back(CTxOut(CAsset(), 1337, SCRIPT_PUB));
         if (NUM_BLOCKS - b >= COINBASE_MATURITY)
             txs.at(b) = MakeTransactionRef(tx);
     }
diff --git a/src/bench/ccoins_caching.cpp b/src/bench/ccoins_caching.cpp
index db303eeead065..a352cf61eca74 100644
--- a/src/bench/ccoins_caching.cpp
+++ b/src/bench/ccoins_caching.cpp
@@ -39,9 +39,9 @@ SetupDummyInputs(CBasicKeyStore& keystoreRet, CCoinsViewCache& coinsRet)
 
     dummyTransactions[1].vout.resize(2);
     dummyTransactions[1].vout[0].nValue = 21 * CENT;
-    dummyTransactions[1].vout[0].scriptPubKey = GetScriptForDestination(key[2].GetPubKey().GetID());
+    dummyTransactions[1].vout[0].scriptPubKey = GetScriptForDestination(PKHash(key[2].GetPubKey()));
     dummyTransactions[1].vout[1].nValue = 22 * CENT;
-    dummyTransactions[1].vout[1].scriptPubKey = GetScriptForDestination(key[3].GetPubKey().GetID());
+    dummyTransactions[1].vout[1].scriptPubKey = GetScriptForDestination(PKHash(key[3].GetPubKey()));
     AddCoins(coinsRet, dummyTransactions[1], 0);
 
     return dummyTransactions;
diff --git a/src/bench/checkqueue.cpp b/src/bench/checkqueue.cpp
index 79689f6e0bb7f..5daaead5498e4 100644
--- a/src/bench/checkqueue.cpp
+++ b/src/bench/checkqueue.cpp
@@ -45,11 +45,12 @@ static void CCheckQueueSpeedPrevectorJob(benchmark::State& state)
         // Make insecure_rand here so that each iteration is identical.
         FastRandomContext insecure_rand(true);
         CCheckQueueControl<PrevectorJob> control(&queue);
-        std::vector<std::vector<PrevectorJob>> vBatches(BATCHES);
+        std::vector<std::vector<PrevectorJob*>> vBatches(BATCHES);
         for (auto& vChecks : vBatches) {
             vChecks.reserve(BATCH_SIZE);
-            for (size_t x = 0; x < BATCH_SIZE; ++x)
-                vChecks.emplace_back(insecure_rand);
+            for (size_t x = 0; x < BATCH_SIZE; ++x) {
+                vChecks.emplace_back(new PrevectorJob(insecure_rand));
+            }
             control.Add(vChecks);
         }
         // control waits for completion by RAII, but
diff --git a/src/bench/coin_selection.cpp b/src/bench/coin_selection.cpp
index 0a6f5d85eaeec..884705a9aae5b 100644
--- a/src/bench/coin_selection.cpp
+++ b/src/bench/coin_selection.cpp
@@ -5,6 +5,8 @@
 #include <bench/bench.h>
 #include <wallet/wallet.h>
 #include <wallet/coinselection.h>
+#include <asset.h>
+#include <policy/policy.h>
 
 #include <set>
 
@@ -47,12 +49,23 @@ static void CoinSelection(benchmark::State& state)
     const CoinSelectionParams coin_selection_params(true, 34, 148, CFeeRate(0), 0);
     while (state.KeepRunning()) {
         std::set<CInputCoin> setCoinsRet;
-        CAmount nValueRet;
+        CAmountMap mapValueRet;
         bool bnb_used;
-        bool success = wallet.SelectCoinsMinConf(1003 * COIN, filter_standard, groups, setCoinsRet, nValueRet, coin_selection_params, bnb_used);
+        CAmountMap mapValue;
+        mapValue[::policyAsset] = 1003 * COIN;
+        bool success = wallet.SelectCoinsMinConf(mapValue, filter_standard, groups, setCoinsRet, mapValueRet, coin_selection_params, bnb_used);
         assert(success);
-        assert(nValueRet == 1003 * COIN);
+        assert(mapValueRet[::policyAsset] == 1003 * COIN);
         assert(setCoinsRet.size() == 2);
+
+/*        std::set<std::pair<const CWalletTx*, unsigned int> > setCoinsRet;
+        CAmountMap nValueRet;
+        CAmountMap mapValue;
+        mapValue[CAsset()] = 1003 * COIN;
+        bool success = wallet.SelectCoinsMinConf(mapValue, 1, 6, 0, vCoins, setCoinsRet, nValueRet);
+        assert(success);
+        assert(nValueRet[CAsset()] == 1003 * COIN);
+        assert(setCoinsRet.size() == 2);*/
     }
 }
 
diff --git a/src/bench/verify_script.cpp b/src/bench/verify_script.cpp
index 07810507fab56..cf8ef6b0d5adf 100644
--- a/src/bench/verify_script.cpp
+++ b/src/bench/verify_script.cpp
@@ -97,10 +97,12 @@ static void VerifyScriptBench(benchmark::State& state)
 #if defined(HAVE_CONSENSUS_LIB)
         CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
         stream << txSpend;
+        CDataStream streamVal(SER_NETWORK, PROTOCOL_VERSION);
+        streamVal << txCredit.vout[0].nValue;
         int csuccess = bitcoinconsensus_verify_script_with_amount(
             txCredit.vout[0].scriptPubKey.data(),
             txCredit.vout[0].scriptPubKey.size(),
-            txCredit.vout[0].nValue,
+            (const unsigned char*)&streamVal[0], streamVal.size(),
             (const unsigned char*)stream.data(), stream.size(), 0, flags, nullptr);
         assert(csuccess == 1);
 #endif
diff --git a/src/bitcoin-tx.cpp b/src/bitcoin-tx.cpp
index 0783303030119..8aebee768e13f 100644
--- a/src/bitcoin-tx.cpp
+++ b/src/bitcoin-tx.cpp
@@ -6,6 +6,7 @@
 #include <config/bitcoin-config.h>
 #endif
 
+#include <asset.h>
 #include <clientversion.h>
 #include <coins.h>
 #include <consensus/consensus.h>
@@ -46,7 +47,7 @@ static void SetupBitcoinTxArgs()
     gArgs.AddArg("in=TXID:VOUT(:SEQUENCE_NUMBER)", "Add input to TX", false, OptionsCategory::COMMANDS);
     gArgs.AddArg("locktime=N", "Set TX lock time to N", false, OptionsCategory::COMMANDS);
     gArgs.AddArg("nversion=N", "Set TX version to N", false, OptionsCategory::COMMANDS);
-    gArgs.AddArg("outaddr=VALUE:ADDRESS", "Add address-based output to TX", false, OptionsCategory::COMMANDS);
+    gArgs.AddArg("outaddr=VALUE:ADDRESS(:ASSET)", "Add address-based output to TX", false, OptionsCategory::COMMANDS);
     gArgs.AddArg("outdata=[VALUE:]DATA", "Add data-based output to TX", false, OptionsCategory::COMMANDS);
     gArgs.AddArg("outmultisig=VALUE:REQUIRED:PUBKEYS:PUBKEY1:PUBKEY2:....[:FLAGS]", "Add Pay To n-of-m Multi-sig output to TX. n = REQUIRED, m = PUBKEYS. "
         "Optionally add the \"W\" flag to produce a pay-to-witness-script-hash output. "
@@ -67,6 +68,8 @@ static void SetupBitcoinTxArgs()
     gArgs.AddArg("load=NAME:FILENAME", "Load JSON file FILENAME into register NAME", false, OptionsCategory::REGISTER_COMMANDS);
     gArgs.AddArg("set=NAME:JSON-STRING", "Set register NAME to given JSON-STRING", false, OptionsCategory::REGISTER_COMMANDS);
 
+    gArgs.AddArg("-serialization=TYPE", "Sets the serialization of transactions. ELEMENTS or BITCOIN are the two valid options.", false, OptionsCategory::REGISTER_COMMANDS);
+
     // Hidden
     gArgs.AddArg("-h", "", false, OptionsCategory::HIDDEN);
     gArgs.AddArg("-help", "", false, OptionsCategory::HIDDEN);
@@ -270,7 +273,7 @@ static void MutateTxAddOutAddr(CMutableTransaction& tx, const std::string& strIn
     std::vector<std::string> vStrInputParts;
     boost::split(vStrInputParts, strInput, boost::is_any_of(":"));
 
-    if (vStrInputParts.size() != 2)
+    if (vStrInputParts.size() < 2)
         throw std::runtime_error("TX output missing or too many separators");
 
     // Extract and validate VALUE
@@ -284,8 +287,22 @@ static void MutateTxAddOutAddr(CMutableTransaction& tx, const std::string& strIn
     }
     CScript scriptPubKey = GetScriptForDestination(destination);
 
+    // extract and validate ASSET
+    CAsset asset;
+    if (!g_con_elementsmode && vStrInputParts.size() == 3) {
+        throw std::runtime_error("TX output asset type invalid for BITCOIN serialization");
+    }
+    if (vStrInputParts.size() == 3) {
+        asset = CAsset(uint256S(vStrInputParts[2]));
+        if (asset.IsNull()) {
+            throw std::runtime_error("invalid TX output asset type");
+        }
+    } else {
+        asset = Params().GetConsensus().pegged_asset;
+    }
+
     // construct TxOut, append to transaction output list
-    CTxOut txout(value, scriptPubKey);
+    CTxOut txout(asset, CConfidentialValue(value), scriptPubKey);
     tx.vout.push_back(txout);
 }
 
@@ -325,11 +342,11 @@ static void MutateTxAddOutPubKey(CMutableTransaction& tx, const std::string& str
     }
     if (bScriptHash) {
         // Get the ID for the script, and then construct a P2SH destination for it.
-        scriptPubKey = GetScriptForDestination(CScriptID(scriptPubKey));
+        scriptPubKey = GetScriptForDestination(ScriptHash(scriptPubKey));
     }
 
     // construct TxOut, append to transaction output list
-    CTxOut txout(value, scriptPubKey);
+    CTxOut txout(Params().GetConsensus().pegged_asset, CConfidentialValue(value), scriptPubKey);
     tx.vout.push_back(txout);
 }
 
@@ -399,11 +416,11 @@ static void MutateTxAddOutMultiSig(CMutableTransaction& tx, const std::string& s
                         "redeemScript exceeds size limit: %d > %d", scriptPubKey.size(), MAX_SCRIPT_ELEMENT_SIZE));
         }
         // Get the ID for the script, and then construct a P2SH destination for it.
-        scriptPubKey = GetScriptForDestination(CScriptID(scriptPubKey));
+        scriptPubKey = GetScriptForDestination(ScriptHash(scriptPubKey));
     }
 
     // construct TxOut, append to transaction output list
-    CTxOut txout(value, scriptPubKey);
+    CTxOut txout(Params().GetConsensus().pegged_asset, CConfidentialValue(value), scriptPubKey);
     tx.vout.push_back(txout);
 }
 
@@ -411,26 +428,46 @@ static void MutateTxAddOutData(CMutableTransaction& tx, const std::string& strIn
 {
     CAmount value = 0;
 
-    // separate [VALUE:]DATA in string
-    size_t pos = strInput.find(':');
+    // separate [VALUE:]DATA[:ASSET] in string
+    std::vector<std::string> vStrInputParts;
+    boost::split(vStrInputParts, strInput, boost::is_any_of(":"));
 
-    if (pos==0)
+    // Check that there are enough parameters
+    if (vStrInputParts[0].empty())
         throw std::runtime_error("TX output value not specified");
 
-    if (pos != std::string::npos) {
-        // Extract and validate VALUE
-        value = ExtractAndValidateValue(strInput.substr(0, pos));
+    if (vStrInputParts.size()>3)
+        throw std::runtime_error("too many separators");
+
+    std::vector<unsigned char> data;
+    CAsset asset(Params().GetConsensus().pegged_asset);
+
+    if (vStrInputParts.size()==1) {
+        std::string strData = vStrInputParts[0];
+        if (!IsHex(strData))
+            throw std::runtime_error("invalid TX output data");
+        data = ParseHex(strData);
+
+    } else {
+        value = ExtractAndValidateValue(vStrInputParts[0]);
+        std::string strData = vStrInputParts[1];
+        if (!IsHex(strData))
+            throw std::runtime_error("invalid TX output data");
+        data = ParseHex(strData);
+
+        if (vStrInputParts.size()==3) {
+            std::string strAsset = vStrInputParts[2];
+            if (!IsHex(strAsset))
+                throw std::runtime_error("invalid TX output asset type");
+
+            asset.SetHex(strAsset);
+            if (asset.IsNull()) {
+                throw std::runtime_error("invalid TX output asset type");
+            }
+        }
     }
 
-    // extract and validate DATA
-    std::string strData = strInput.substr(pos + 1, std::string::npos);
-
-    if (!IsHex(strData))
-        throw std::runtime_error("invalid TX output data");
-
-    std::vector<unsigned char> data = ParseHex(strData);
-
-    CTxOut txout(value, CScript() << OP_RETURN << data);
+    CTxOut txout(asset, CConfidentialValue(value), CScript() << OP_RETURN << data);
     tx.vout.push_back(txout);
 }
 
@@ -471,11 +508,11 @@ static void MutateTxAddOutScript(CMutableTransaction& tx, const std::string& str
             throw std::runtime_error(strprintf(
                         "redeemScript exceeds size limit: %d > %d", scriptPubKey.size(), MAX_SCRIPT_ELEMENT_SIZE));
         }
-        scriptPubKey = GetScriptForDestination(CScriptID(scriptPubKey));
+        scriptPubKey = GetScriptForDestination(ScriptHash(scriptPubKey));
     }
 
     // construct TxOut, append to transaction output list
-    CTxOut txout(value, scriptPubKey);
+    CTxOut txout(Params().GetConsensus().pegged_asset, CConfidentialValue(value), scriptPubKey);
     tx.vout.push_back(txout);
 }
 
@@ -612,7 +649,7 @@ static void MutateTxSign(CMutableTransaction& tx, const std::string& flagStr)
                 newcoin.out.scriptPubKey = scriptPubKey;
                 newcoin.out.nValue = 0;
                 if (prevOut.exists("amount")) {
-                    newcoin.out.nValue = AmountFromValue(prevOut["amount"]);
+                    newcoin.out.nValue = CConfidentialValue(AmountFromValue(prevOut["amount"]));
                 }
                 newcoin.nHeight = 1;
                 view.AddCoin(out, std::move(newcoin), true);
@@ -642,7 +679,7 @@ static void MutateTxSign(CMutableTransaction& tx, const std::string& flagStr)
             continue;
         }
         const CScript& prevPubKey = coin.out.scriptPubKey;
-        const CAmount& amount = coin.out.nValue;
+        const CConfidentialValue& amount = coin.out.nValue;
 
         SignatureData sigdata = DataFromTransaction(mergedTx, i, coin.out);
         // Only sign SIGHASH_SINGLE if there's a corresponding output:
@@ -812,6 +849,16 @@ static int CommandLineRawTx(int argc, char* argv[])
                 value = arg.substr(eqpos + 1);
             }
 
+            std::string serialization = gArgs.GetArg("-serialization", "ELEMENTS");
+            if (serialization == "ELEMENTS") {
+                g_con_elementsmode = true;
+            } else if (serialization == "BITCOIN") {
+                g_con_elementsmode = false;
+            } else {
+                PrintExceptionContinue(nullptr, "Invalid serialization argument");
+                throw;
+            }
+
             MutateTx(tx, key, value);
         }
 
diff --git a/src/blech32.cpp b/src/blech32.cpp
new file mode 100644
index 0000000000000..8acd4f0a1f26a
--- /dev/null
+++ b/src/blech32.cpp
@@ -0,0 +1,199 @@
+// Copyright (c) 2017 Pieter Wuille
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <blech32.h>
+
+/*
+ * IMPORTANT NOTE: Comments below may largely pertain for bech32, not blech32.
+ * Some of these magic constants have changes.
+ * See liquid_addr.py for compact difference from bech32
+ * TODO: Update comments
+ */
+
+namespace
+{
+
+typedef std::vector<uint8_t> data;
+
+/** The Blech32 character set for encoding. */
+const char* CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
+
+/** The Blech32 character set for decoding. */
+const int8_t CHARSET_REV[128] = {
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    15, -1, 10, 17, 21, 20, 26, 30,  7,  5, -1, -1, -1, -1, -1, -1,
+    -1, 29, -1, 24, 13, 25,  9,  8, 23, -1, 18, 22, 31, 27, 19, -1,
+     1,  0,  3, 16, 11, 28, 12, 14,  6,  4,  2, -1, -1, -1, -1, -1,
+    -1, 29, -1, 24, 13, 25,  9,  8, 23, -1, 18, 22, 31, 27, 19, -1,
+     1,  0,  3, 16, 11, 28, 12, 14,  6,  4,  2, -1, -1, -1, -1, -1
+};
+
+/** Concatenate two byte arrays. */
+data Cat(data x, const data& y)
+{
+    x.insert(x.end(), y.begin(), y.end());
+    return x;
+}
+
+/** This function will compute what 6 5-bit values to XOR into the last 6 input values, in order to
+ *  make the checksum 0. These 6 values are packed together in a single 30-bit integer. The higher
+ *  bits correspond to earlier values. */
+uint32_t PolyMod(const data& v)
+{
+    // The input is interpreted as a list of coefficients of a polynomial over F = GF(32), with an
+    // implicit 1 in front. If the input is [v0,v1,v2,v3,v4], that polynomial is v(x) =
+    // 1*x^5 + v0*x^4 + v1*x^3 + v2*x^2 + v3*x + v4. The implicit 1 guarantees that
+    // [v0,v1,v2,...] has a distinct checksum from [0,v0,v1,v2,...].
+
+    // The output is a 30-bit integer whose 5-bit groups are the coefficients of the remainder of
+    // v(x) mod g(x), where g(x) is the Blech32 generator,
+    // x^6 + {29}x^5 + {22}x^4 + {20}x^3 + {21}x^2 + {29}x + {18}. g(x) is chosen in such a way
+    // that the resulting code is a BCH code, guaranteeing detection of up to 3 errors within a
+    // window of 1023 characters. Among the various possible BCH codes, one was selected to in
+    // fact guarantee detection of up to 4 errors within a window of 89 characters.
+
+    // Note that the coefficients are elements of GF(32), here represented as decimal numbers
+    // between {}. In this finite field, addition is just XOR of the corresponding numbers. For
+    // example, {27} + {13} = {27 ^ 13} = {22}. Multiplication is more complicated, and requires
+    // treating the bits of values themselves as coefficients of a polynomial over a smaller field,
+    // GF(2), and multiplying those polynomials mod a^5 + a^3 + 1. For example, {5} * {26} =
+    // (a^2 + 1) * (a^4 + a^3 + a) = (a^4 + a^3 + a) * a^2 + (a^4 + a^3 + a) = a^6 + a^5 + a^4 + a
+    // = a^3 + 1 (mod a^5 + a^3 + 1) = {9}.
+
+    // During the course of the loop below, `c` contains the bitpacked coefficients of the
+    // polynomial constructed from just the values of v that were processed so far, mod g(x). In
+    // the above example, `c` initially corresponds to 1 mod (x), and after processing 2 inputs of
+    // v, it corresponds to x^2 + v0*x + v1 mod g(x). As 1 mod g(x) = 1, that is the starting value
+    // for `c`.
+    uint64_t c = 1;
+    for (const auto v_i : v) {
+        // We want to update `c` to correspond to a polynomial with one extra term. If the initial
+        // value of `c` consists of the coefficients of c(x) = f(x) mod g(x), we modify it to
+        // correspond to c'(x) = (f(x) * x + v_i) mod g(x), where v_i is the next input to
+        // process. Simplifying:
+        // c'(x) = (f(x) * x + v_i) mod g(x)
+        //         ((f(x) mod g(x)) * x + v_i) mod g(x)
+        //         (c(x) * x + v_i) mod g(x)
+        // If c(x) = c0*x^5 + c1*x^4 + c2*x^3 + c3*x^2 + c4*x + c5, we want to compute
+        // c'(x) = (c0*x^5 + c1*x^4 + c2*x^3 + c3*x^2 + c4*x + c5) * x + v_i mod g(x)
+        //       = c0*x^6 + c1*x^5 + c2*x^4 + c3*x^3 + c4*x^2 + c5*x + v_i mod g(x)
+        //       = c0*(x^6 mod g(x)) + c1*x^5 + c2*x^4 + c3*x^3 + c4*x^2 + c5*x + v_i
+        // If we call (x^6 mod g(x)) = k(x), this can be written as
+        // c'(x) = (c1*x^5 + c2*x^4 + c3*x^3 + c4*x^2 + c5*x + v_i) + c0*k(x)
+
+        // First, determine the value of c0:
+        uint8_t c0 = c >> 55; // ELEMENTS: 25->55
+
+        // Then compute c1*x^5 + c2*x^4 + c3*x^3 + c4*x^2 + c5*x + v_i:
+        c = ((c & 0x7fffffffffffff) << 5) ^ v_i; // ELEMENTS 0x1ffffff->0x7fffffffffffff
+
+        // Finally, for each set bit n in c0, conditionally add {2^n}k(x):
+        if (c0 & 1)  c ^= 0x7d52fba40bd886; // ELEMENTS
+        if (c0 & 2)  c ^= 0x5e8dbf1a03950c; // ELEMENTS
+        if (c0 & 4)  c ^= 0x1c3a3c74072a18; // ELEMENTS
+        if (c0 & 8)  c ^= 0x385d72fa0e5139; // ELEMENTS
+        if (c0 & 16) c ^= 0x7093e5a608865b; // ELEMENTS
+    }
+    return c;
+}
+
+/** Convert to lower case. */
+inline unsigned char LowerCase(unsigned char c)
+{
+    return (c >= 'A' && c <= 'Z') ? (c - 'A') + 'a' : c;
+}
+
+/** Expand a HRP for use in checksum computation. */
+data ExpandHRP(const std::string& hrp)
+{
+    data ret;
+    ret.reserve(hrp.size() + 90);
+    ret.resize(hrp.size() * 2 + 1);
+    for (size_t i = 0; i < hrp.size(); ++i) {
+        unsigned char c = hrp[i];
+        ret[i] = c >> 5;
+        ret[i + hrp.size() + 1] = c & 0x1f;
+    }
+    ret[hrp.size()] = 0;
+    return ret;
+}
+
+/** Verify a checksum. */
+bool VerifyChecksum(const std::string& hrp, const data& values)
+{
+    // PolyMod computes what value to xor into the final values to make the checksum 0. However,
+    // if we required that the checksum was 0, it would be the case that appending a 0 to a valid
+    // list of values would result in a new valid list. For that reason, Blech32 requires the
+    // resulting checksum to be 1 instead.
+    return PolyMod(Cat(ExpandHRP(hrp), values)) == 1;
+}
+
+/** Create a checksum. */
+data CreateChecksum(const std::string& hrp, const data& values)
+{
+    data enc = Cat(ExpandHRP(hrp), values);
+    enc.resize(enc.size() + 12); // ELEMENTS: Append 6->12 zeroes
+    uint32_t mod = PolyMod(enc) ^ 1; // Determine what to XOR into those 6 zeroes.
+    data ret(12); // ELEMENTS: 6->12
+    for (size_t i = 0; i < 12; ++i) { // ELEMENTS: 6->12
+        // Convert the 5-bit groups in mod to checksum values.
+        ret[i] = (mod >> (5 * (11 - i))) & 31; // ELEMENTS: 5->11
+    }
+    return ret;
+}
+
+} // namespace
+
+namespace blech32
+{
+
+/** Encode a Blech32 string. */
+std::string Encode(const std::string& hrp, const data& values) {
+    data checksum = CreateChecksum(hrp, values);
+    data combined = Cat(values, checksum);
+    std::string ret = hrp + '1';
+    ret.reserve(ret.size() + combined.size());
+    for (const auto c : combined) {
+        ret += CHARSET[c];
+    }
+    return ret;
+}
+
+/** Decode a Blech32 string. */
+std::pair<std::string, data> Decode(const std::string& str) {
+    bool lower = false, upper = false;
+    for (size_t i = 0; i < str.size(); ++i) {
+        unsigned char c = str[i];
+        if (c >= 'a' && c <= 'z') lower = true;
+        else if (c >= 'A' && c <= 'Z') upper = true;
+        else if (c < 33 || c > 126) return {};
+    }
+    if (lower && upper) return {};
+    size_t pos = str.rfind('1');
+    if (str.size() > 1000 || pos == str.npos || pos == 0 || pos + 13 > str.size()) { // ELEMENTS: 90->1000, 7->13
+        return {};
+    }
+    data values(str.size() - 1 - pos);
+    for (size_t i = 0; i < str.size() - 1 - pos; ++i) {
+        unsigned char c = str[i + pos + 1];
+        int8_t rev = CHARSET_REV[c];
+
+        if (rev == -1) {
+            return {};
+        }
+        values[i] = rev;
+    }
+    std::string hrp;
+    for (size_t i = 0; i < pos; ++i) {
+        hrp += LowerCase(str[i]);
+    }
+    if (!VerifyChecksum(hrp, values)) {
+        return {};
+    }
+    return {hrp, data(values.begin(), values.end() - 12)};
+}
+
+} // namespace blech32
diff --git a/src/blech32.h b/src/blech32.h
new file mode 100644
index 0000000000000..cfe907581e7a6
--- /dev/null
+++ b/src/blech32.h
@@ -0,0 +1,30 @@
+// Copyright (c) 2017 Pieter Wuille
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+// Bech32 is a string encoding format used in newer address types.
+// The output consists of a human-readable part (alphanumeric), a
+// separator character (1), and a base32 data section, the last
+// 6 characters of which are a checksum.
+//
+// For more information, see BIP 173.
+
+#ifndef BITCOIN_BLECH32_H
+#define BITCOIN_BLECH32_H
+
+#include <stdint.h>
+#include <string>
+#include <vector>
+
+namespace blech32
+{
+
+/** Encode a Bech32 string. Returns the empty string in case of failure. */
+std::string Encode(const std::string& hrp, const std::vector<uint8_t>& values);
+
+/** Decode a Bech32 string. Returns (hrp, data). Empty hrp means failure. */
+std::pair<std::string, std::vector<uint8_t>> Decode(const std::string& str);
+
+} // namespace blech32
+
+#endif // BITCOIN_BLECH32_H
diff --git a/src/blind.cpp b/src/blind.cpp
new file mode 100644
index 0000000000000..c168b23e4b971
--- /dev/null
+++ b/src/blind.cpp
@@ -0,0 +1,579 @@
+// Copyright (c) 2017-2019 The Elements Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <blind.h>
+
+#include <hash.h>
+#include <primitives/transaction.h>
+#include <primitives/confidential.h>
+#include <issuance.h>
+#include <random.h>
+#include <util.h>
+
+static secp256k1_context* secp256k1_blind_context = NULL;
+
+class Blind_ECC_Init {
+public:
+    Blind_ECC_Init() {
+        assert(secp256k1_blind_context == NULL);
+
+        secp256k1_context *ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY);
+        assert(ctx != NULL);
+
+        secp256k1_blind_context = ctx;
+    }
+
+    ~Blind_ECC_Init() {
+        secp256k1_context *ctx = secp256k1_blind_context;
+        secp256k1_blind_context = NULL;
+
+        if (ctx) {
+            secp256k1_context_destroy(ctx);
+        }
+    }
+};
+
+static Blind_ECC_Init ecc_init_on_load;
+
+bool UnblindConfidentialPair(const CKey& blinding_key, const CConfidentialValue& conf_value, const CConfidentialAsset& conf_asset, const CConfidentialNonce& nonce_commitment, const CScript& committedScript, const std::vector<unsigned char>& vchRangeproof, CAmount& amount_out, uint256& blinding_factor_out, CAsset& asset_out, uint256& asset_blinding_factor_out)
+{
+    if (!blinding_key.IsValid() || vchRangeproof.size() == 0) {
+        return false;
+    }
+    CPubKey ephemeral_key(nonce_commitment.vchCommitment);
+    if (nonce_commitment.vchCommitment.size() > 0 && !ephemeral_key.IsFullyValid()) {
+        return false;
+    }
+
+    // ECDH or not depending on if nonce commitment is non-empty
+    uint256 nonce;
+    bool blank_nonce = false;
+    if (nonce_commitment.vchCommitment.size() > 0) {
+        nonce = blinding_key.ECDH(ephemeral_key);
+        CSHA256().Write(nonce.begin(), 32).Finalize(nonce.begin());
+    } else {
+        // Use blinding key directly, and don't commit to a scriptpubkey
+        // This is used for issuance inputs.
+        blank_nonce = true;
+        nonce = uint256(std::vector<unsigned char>(blinding_key.begin(), blinding_key.end()));
+    }
+
+    // API-prescribed sidechannel maximum size, though we only use 64 bytes
+    unsigned char msg[4096] = {0};
+    // 32 bytes of asset type, 32 bytes of asset blinding factor in sidechannel
+    size_t msg_size = 64;
+
+    // If value is unblinded, we don't support unblinding just the asset
+    if (!conf_value.IsCommitment()) {
+        return false;
+    }
+
+    // Valid asset commitment?
+    secp256k1_generator observed_gen;
+    if (conf_asset.IsCommitment()) {
+        if (secp256k1_generator_parse(secp256k1_blind_context, &observed_gen, &conf_asset.vchCommitment[0]) != 1)
+            return false;
+    } else if (conf_asset.IsExplicit()) {
+        if (secp256k1_generator_generate(secp256k1_blind_context, &observed_gen, conf_asset.GetAsset().begin()) != 1)
+            return false;
+    }
+
+    // Valid value commitment?
+    secp256k1_pedersen_commitment value_commit;
+    if (secp256k1_pedersen_commitment_parse(secp256k1_blind_context, &value_commit, conf_value.vchCommitment.data()) != 1) {
+        return false;
+    }
+
+    // Rewind rangeproof
+    uint64_t min_value, max_value, amount;
+    if (!secp256k1_rangeproof_rewind(secp256k1_blind_context, blinding_factor_out.begin(), &amount, msg, &msg_size, nonce.begin(), &min_value, &max_value, &value_commit, &vchRangeproof[0], vchRangeproof.size(), (committedScript.size() && !blank_nonce)? &committedScript.front(): NULL, blank_nonce ? 0 : committedScript.size(), &observed_gen)) {
+        return false;
+    }
+
+    // Value sidechannel must be a transaction-valid amount (should be belt-and-suspenders check)
+    if (amount > (uint64_t)MAX_MONEY || !MoneyRange((CAmount)amount)) {
+        return false;
+    }
+
+    // Convenience pointers to starting point of each recovered 32 byte message
+    unsigned char *asset_type = msg;
+    unsigned char *asset_blinder = msg+32;
+
+    // Asset sidechannel of asset type + asset blinder
+    secp256k1_generator recalculated_gen;
+    if (msg_size != 64 || secp256k1_generator_generate_blinded(secp256k1_blind_context, &recalculated_gen, asset_type, asset_blinder) != 1) {
+        return false;
+    }
+
+    // Serialize both generators then compare
+    unsigned char observed_generator[33];
+    unsigned char derived_generator[33];
+    secp256k1_generator_serialize(secp256k1_blind_context, observed_generator, &observed_gen);
+    secp256k1_generator_serialize(secp256k1_blind_context, derived_generator, &recalculated_gen);
+    if (memcmp(observed_generator, derived_generator, sizeof(observed_generator))) {
+        return false;
+    }
+
+    amount_out = (CAmount)amount;
+    asset_out = CAsset(std::vector<unsigned char>(asset_type, asset_type+32));
+    asset_blinding_factor_out = uint256(std::vector<unsigned char>(asset_blinder, asset_blinder+32));
+    return true;
+}
+
+// Create surjection proof
+bool SurjectOutput(CTxOutWitness& txoutwit, const std::vector<secp256k1_fixed_asset_tag>& surjection_targets, const std::vector<secp256k1_generator>& target_asset_generators, const std::vector<uint256 >& target_asset_blinders, const std::vector<const unsigned char*> asset_blindptrs, const secp256k1_generator& output_asset_gen, const CAsset& asset)
+{
+    int ret;
+    // 1 to 3 targets
+    size_t nInputsToSelect = std::min((size_t)3, surjection_targets.size());
+    unsigned char randseed[32];
+    GetStrongRandBytes(randseed, 32);
+    size_t input_index;
+    secp256k1_surjectionproof proof;
+    secp256k1_fixed_asset_tag tag;
+    memcpy(&tag, asset.begin(), 32);
+    // Find correlation between asset tag and listed input tags
+    if (secp256k1_surjectionproof_initialize(secp256k1_blind_context, &proof, &input_index, &surjection_targets[0], surjection_targets.size(), nInputsToSelect, &tag, 100, randseed) == 0) {
+        return false;
+    }
+    // Using the input chosen, build proof
+    ret = secp256k1_surjectionproof_generate(secp256k1_blind_context, &proof, target_asset_generators.data(), target_asset_generators.size(), &output_asset_gen, input_index, target_asset_blinders[input_index].begin(), asset_blindptrs[asset_blindptrs.size()-1]);
+    assert(ret == 1);
+    // Double-check answer
+    ret = secp256k1_surjectionproof_verify(secp256k1_blind_context, &proof, target_asset_generators.data(), target_asset_generators.size(), &output_asset_gen);
+    assert(ret != 0);
+
+    // Serialize into output witness structure
+    size_t output_len = secp256k1_surjectionproof_serialized_size(secp256k1_blind_context, &proof);
+    txoutwit.vchSurjectionproof.resize(output_len);
+    secp256k1_surjectionproof_serialize(secp256k1_blind_context, &txoutwit.vchSurjectionproof[0], &output_len, &proof);
+    assert(output_len == txoutwit.vchSurjectionproof.size());
+    return true;
+}
+
+// Creates ECDH nonce commitment using ephemeral key and output_pubkey
+uint256 GenerateOutputRangeproofNonce(CTxOut& out, const CPubKey output_pubkey)
+{
+    // Generate ephemeral key for ECDH nonce generation
+    CKey ephemeral_key;
+    ephemeral_key.MakeNewKey(true);
+    CPubKey ephemeral_pubkey = ephemeral_key.GetPubKey();
+    assert(ephemeral_pubkey.size() == CConfidentialNonce::nCommittedSize);
+    out.nNonce.vchCommitment.resize(ephemeral_pubkey.size());
+    memcpy(&out.nNonce.vchCommitment[0], &ephemeral_pubkey[0], ephemeral_pubkey.size());
+    // Generate nonce
+    uint256 nonce = ephemeral_key.ECDH(output_pubkey);
+    CSHA256().Write(nonce.begin(), 32).Finalize(nonce.begin());
+    return nonce;
+}
+
+bool GenerateRangeproof(std::vector<unsigned char>& rangeproof, const std::vector<unsigned char*>& value_blindptrs, const uint256& nonce, const CAmount amount, const CScript& scriptPubKey, const secp256k1_pedersen_commitment& value_commit, const secp256k1_generator& gen, const CAsset& asset, std::vector<const unsigned char*>& asset_blindptrs)
+{
+    // Prep range proof
+    size_t nRangeProofLen = 5134;
+    rangeproof.resize(nRangeProofLen);
+
+    // Compose sidechannel message to convey asset info (ID and asset blinds)
+    unsigned char asset_message[64];
+    memcpy(asset_message, asset.begin(), 32);
+    memcpy(asset_message+32, asset_blindptrs[asset_blindptrs.size()-1], 32);
+
+    // Sign rangeproof
+    // If min_value is 0, scriptPubKey must be unspendable
+    int res = secp256k1_rangeproof_sign(secp256k1_blind_context, rangeproof.data(), &nRangeProofLen, scriptPubKey.IsUnspendable() ? 0 : 1, &value_commit, value_blindptrs.back(), nonce.begin(), std::min(std::max((int)gArgs.GetArg("-ct_exponent", 0), -1),18), std::min(std::max((int)gArgs.GetArg("-ct_bits", 36), 1), 51), amount, asset_message, sizeof(asset_message), scriptPubKey.size() ? &scriptPubKey.front() : NULL, scriptPubKey.size(), &gen);
+    rangeproof.resize(nRangeProofLen);
+    return (res == 1);
+}
+
+void BlindAsset(CConfidentialAsset& conf_asset, secp256k1_generator& asset_gen, const CAsset& asset, const unsigned char* asset_blindptr)
+{
+    conf_asset.vchCommitment.resize(CConfidentialAsset::nCommittedSize);
+    int ret = secp256k1_generator_generate_blinded(secp256k1_blind_context, &asset_gen, asset.begin(), asset_blindptr);
+    assert(ret == 1);
+    ret = secp256k1_generator_serialize(secp256k1_blind_context, conf_asset.vchCommitment.data(), &asset_gen);
+    assert(ret != 0);
+}
+
+void CreateValueCommitment(CConfidentialValue& conf_value, secp256k1_pedersen_commitment& value_commit, const unsigned char* value_blindptr, const secp256k1_generator& asset_gen, const CAmount amount)
+{
+    int ret;
+    conf_value.vchCommitment.resize(CConfidentialValue::nCommittedSize);
+    ret = secp256k1_pedersen_commit(secp256k1_blind_context, &value_commit, value_blindptr, amount, &asset_gen);
+    assert(ret != 0);
+    secp256k1_pedersen_commitment_serialize(secp256k1_blind_context, conf_value.vchCommitment.data(), &value_commit);
+    assert(conf_value.IsValid());
+}
+
+size_t GetNumIssuances(const CTransaction& tx)
+{
+    unsigned int num_issuances = 0;
+    for (unsigned int i = 0; i < tx.vin.size(); i++) {
+        if (!tx.vin[i].assetIssuance.IsNull()) {
+            if (!tx.vin[i].assetIssuance.nAmount.IsNull()) {
+                num_issuances++;
+            }
+            if (!tx.vin[i].assetIssuance.nInflationKeys.IsNull()) {
+                num_issuances++;
+            }
+        }
+    }
+    return num_issuances;
+}
+
+int BlindTransaction(std::vector<uint256 >& input_value_blinding_factors, const std::vector<uint256 >& input_asset_blinding_factors, const std::vector<CAsset >& input_assets, const std::vector<CAmount >& input_amounts, std::vector<uint256 >& out_val_blind_factors, std::vector<uint256 >& out_asset_blind_factors, const std::vector<CPubKey>& output_pubkeys, const std::vector<CKey>& issuance_blinding_privkey, const std::vector<CKey>& token_blinding_privkey, CMutableTransaction& tx, std::vector<std::vector<unsigned char> >* auxiliary_generators)
+{
+    // Sanity check input data and output_pubkey size, clear other output data
+    assert(tx.vout.size() >= output_pubkeys.size());
+    assert(tx.vin.size()+GetNumIssuances(tx) >= issuance_blinding_privkey.size());
+    assert(tx.vin.size()+GetNumIssuances(tx) >= token_blinding_privkey.size());
+    out_val_blind_factors.clear();
+    out_val_blind_factors.resize(tx.vout.size());
+    out_asset_blind_factors.clear();
+    out_asset_blind_factors.resize(tx.vout.size());
+    assert(tx.vin.size() == input_value_blinding_factors.size());
+    assert(tx.vin.size() == input_asset_blinding_factors.size());
+    assert(tx.vin.size() == input_assets.size());
+    assert(tx.vin.size() == input_amounts.size());
+    if (auxiliary_generators) {
+        assert(auxiliary_generators->size() >= tx.vin.size());
+    }
+
+    std::vector<unsigned char*> value_blindptrs;
+    std::vector<const unsigned char*> asset_blindptrs;
+    std::vector<uint64_t> blinded_amounts;
+    value_blindptrs.reserve(tx.vout.size() + tx.vin.size());
+    asset_blindptrs.reserve(tx.vout.size() + tx.vin.size());
+
+    int ret;
+    int num_blind_attempts = 0, num_issuance_blind_attempts = 0, num_blinded = 0;
+
+    //Surjection proof prep
+
+    // Needed to surj init, only matches to output asset matters, rest can be garbage
+    std::vector<secp256k1_fixed_asset_tag> surjection_targets;
+
+    // Needed to construct the proof itself. Generators must match final transaction to be valid
+    std::vector<secp256k1_generator> target_asset_generators;
+    surjection_targets.resize(tx.vin.size()*3);
+    target_asset_generators.resize(tx.vin.size()*3);
+
+    // input_asset_blinding_factors is only for inputs, not for issuances(0 by def)
+    // but we need to create surjection proofs against this list so we copy and insert 0's
+    // where issuances occur.
+    std::vector<uint256> target_asset_blinders;
+
+    size_t totalTargets = 0;
+    for (size_t i = 0; i < tx.vin.size(); i++) {
+        // For each input we either need the asset/blinds or the generator
+        if (input_assets[i].IsNull()) {
+            // If non-empty generator exists, parse
+            if (auxiliary_generators) {
+                // Parse generator here
+                ret = secp256k1_generator_parse(secp256k1_blind_context, &target_asset_generators[totalTargets], &(*auxiliary_generators)[i][0]);
+                if (ret != 1) {
+                    return -1;
+                }
+            } else {
+                return -1;
+            }
+        } else {
+            ret = secp256k1_generator_generate_blinded(secp256k1_blind_context, &target_asset_generators[totalTargets], input_assets[i].begin(), input_asset_blinding_factors[i].begin());
+            assert(ret == 1);
+        }
+        memcpy(&surjection_targets[totalTargets], input_assets[i].begin(), 32);
+        target_asset_blinders.push_back(input_asset_blinding_factors[i]);
+        totalTargets++;
+
+        // Create target generators for issuances
+        CAssetIssuance& issuance = tx.vin[i].assetIssuance;
+        uint256 entropy;
+        CAsset asset;
+        CAsset token;
+        if (!issuance.IsNull()) {
+            if (issuance.nAmount.IsCommitment() || issuance.nInflationKeys.IsCommitment()) {
+                return -1;
+            }
+            // New Issuance
+            if (issuance.assetBlindingNonce.IsNull()) {
+                bool blind_issuance = (token_blinding_privkey.size() > i && token_blinding_privkey[i].IsValid()) ? true : false;
+                GenerateAssetEntropy(entropy, tx.vin[i].prevout, issuance.assetEntropy);
+                CalculateAsset(asset, entropy);
+                CalculateReissuanceToken(token, entropy, blind_issuance);
+            } else {
+                CalculateAsset(asset, issuance.assetEntropy);
+            }
+
+            if (!issuance.nAmount.IsNull()) {
+                memcpy(&surjection_targets[totalTargets], asset.begin(), 32);
+                ret = secp256k1_generator_generate(secp256k1_blind_context, &target_asset_generators[totalTargets], asset.begin());
+                assert(ret != 0);
+                // Issuance asset cannot be blinded by definition
+                target_asset_blinders.push_back(uint256());
+                totalTargets++;
+            }
+            if (!issuance.nInflationKeys.IsNull()) {
+                assert(!token.IsNull());
+                memcpy(&surjection_targets[totalTargets], token.begin(), 32);
+                ret = secp256k1_generator_generate(secp256k1_blind_context, &target_asset_generators[totalTargets], token.begin());
+                assert(ret != 0);
+                // Issuance asset cannot be blinded by definition
+                target_asset_blinders.push_back(uint256());
+                totalTargets++;
+            }
+        }
+    }
+
+    if (auxiliary_generators) {
+        // Process any additional targets from auxiliary_generators
+        // we know nothing about it other than the generator itself
+        for (size_t i = tx.vin.size(); i < auxiliary_generators->size(); i++) {
+            ret = secp256k1_generator_parse(secp256k1_blind_context, &target_asset_generators[totalTargets], &(*auxiliary_generators)[i][0]);
+            if (ret != 1) {
+                return -1;
+            }
+            memset(&surjection_targets[totalTargets], 0, 32);
+            target_asset_blinders.push_back(uint256());
+            totalTargets++;
+        }
+    }
+
+    // Resize the target surjection lists to how many actually exist
+    assert(totalTargets == target_asset_blinders.size());
+    surjection_targets.resize(totalTargets);
+    target_asset_generators.resize(totalTargets);
+
+    //Total blinded inputs that you own (that you are balancing against)
+    int num_known_input_blinds = 0;
+    //Number of outputs and issuances to blind
+    int num_to_blind = 0;
+
+    // Make sure witness lengths are correct
+    tx.witness.vtxoutwit.resize(tx.vout.size());
+    tx.witness.vtxinwit.resize(tx.vin.size());
+
+    size_t txoutwitsize = tx.witness.vtxoutwit.size();
+    for (size_t nIn = 0; nIn < tx.vin.size(); nIn++) {
+        if (!input_value_blinding_factors[nIn].IsNull() || !input_asset_blinding_factors[nIn].IsNull()) {
+            if (input_amounts[nIn] < 0) {
+                return -1;
+            }
+            value_blindptrs.push_back(input_value_blinding_factors[nIn].begin());
+            asset_blindptrs.push_back(input_asset_blinding_factors[nIn].begin());
+            blinded_amounts.push_back(input_amounts[nIn]);
+            num_known_input_blinds++;
+        }
+
+        // Count number of issuance pseudo-inputs to blind
+        CAssetIssuance& issuance = tx.vin[nIn].assetIssuance;
+        if (!issuance.IsNull()) {
+            // Marked for blinding
+            if (issuance_blinding_privkey.size() > nIn && issuance_blinding_privkey[nIn].IsValid()) {
+                if(issuance.nAmount.IsExplicit() && tx.witness.vtxinwit[nIn].vchIssuanceAmountRangeproof.empty()) {
+                    num_to_blind++;
+                } else {
+                    return -1;
+                }
+            }
+            if (token_blinding_privkey.size() > nIn && token_blinding_privkey[nIn].IsValid()) {
+                if(issuance.nInflationKeys.IsExplicit() && tx.witness.vtxinwit[nIn].vchInflationKeysRangeproof.empty()) {
+                    num_to_blind++;
+                } else {
+                    return -1;
+                }
+            }
+        }
+    }
+
+    for (size_t nOut = 0; nOut < output_pubkeys.size(); nOut++) {
+        if (output_pubkeys[nOut].IsValid()) {
+            // Keys must be valid and outputs completely unblinded or else call fails
+            if (!output_pubkeys[nOut].IsFullyValid() ||
+                (!tx.vout[nOut].nValue.IsExplicit() || !tx.vout[nOut].nAsset.IsExplicit()) ||
+                   (txoutwitsize > nOut && !tx.witness.vtxoutwit[nOut].IsNull())
+                        || tx.vout[nOut].IsFee()) {
+                return -1;
+            }
+            num_to_blind++;
+         }
+    }
+
+
+    //Running total of newly blinded outputs
+    static const unsigned char diff_zero[32] = {0};
+    assert(num_to_blind <= 10000); // More than 10k outputs? Stop spamming.
+    unsigned char blind[10000][32];
+    unsigned char asset_blind[10000][32];
+    secp256k1_pedersen_commitment value_commit;
+    secp256k1_generator asset_gen;
+    CAsset asset;
+
+    // First blind issuance pseudo-inputs
+    for (size_t nIn = 0; nIn < tx.vin.size(); nIn++) {
+        for (size_t nPseudo = 0; nPseudo < 2; nPseudo++) {
+            if ((nPseudo == 0 && issuance_blinding_privkey.size() > nIn && issuance_blinding_privkey[nIn].IsValid()) ||
+                    (nPseudo == 1 && token_blinding_privkey.size() > nIn && token_blinding_privkey[nIn].IsValid())) {
+                num_blind_attempts++;
+                num_issuance_blind_attempts++;
+                CAssetIssuance& issuance = tx.vin[nIn].assetIssuance;
+                // First iteration does issuance asset, second inflation keys
+                CConfidentialValue& conf_value = nPseudo ? issuance.nInflationKeys : issuance.nAmount;
+                if (conf_value.IsNull()) {
+                    continue;
+                }
+                CAmount amount = conf_value.GetAmount();
+                blinded_amounts.push_back(amount);
+
+                // Derive the asset of the issuance asset/token
+                if (issuance.assetBlindingNonce.IsNull()) {
+                    uint256 entropy;
+                    GenerateAssetEntropy(entropy, tx.vin[nIn].prevout, issuance.assetEntropy);
+                    if (nPseudo == 0) {
+                        CalculateAsset(asset, entropy);
+                    } else {
+                        bool blind_issuance = (token_blinding_privkey.size() > nIn && token_blinding_privkey[nIn].IsValid()) ? true : false;
+                        CalculateReissuanceToken(asset, entropy, blind_issuance);
+                    }
+                } else {
+                    if (nPseudo == 0) {
+                        CalculateAsset(asset, issuance.assetEntropy);
+                    } else {
+                        // Re-issuance only has one pseudo-input maximum
+                        continue;
+                    }
+                }
+
+                // Fill out the value blinders and blank asset blinder
+                GetStrongRandBytes(&blind[num_blind_attempts-1][0], 32);
+                // Issuances are not asset-blinded
+                memset(&asset_blind[num_blind_attempts-1][0], 0, 32);
+                value_blindptrs.push_back(&blind[num_blind_attempts-1][0]);
+                asset_blindptrs.push_back(&asset_blind[num_blind_attempts-1][0]);
+
+                if (num_blind_attempts == num_to_blind) {
+                    // All outputs we own are unblinded, we don't support this type of blinding
+                    // though it is possible. No privacy gained here, incompatible with secp api
+                    return num_blinded;
+                }
+
+                if (tx.witness.vtxinwit.size() <= nIn) {
+                    tx.witness.vtxinwit.resize(tx.vin.size());
+                }
+                CTxInWitness& txinwit = tx.witness.vtxinwit[nIn];
+
+                // Create unblinded generator. We throw away all but `asset_gen`
+                CConfidentialAsset conf_asset;
+                BlindAsset(conf_asset, asset_gen, asset, asset_blindptrs.back());
+
+                // Create value commitment
+                CreateValueCommitment(conf_value, value_commit, value_blindptrs.back(), asset_gen, amount);
+
+                // nonce should just be blinding key
+                uint256 nonce = nPseudo ? uint256(std::vector<unsigned char>(token_blinding_privkey[nIn].begin(), token_blinding_privkey[nIn].end())) : uint256(std::vector<unsigned char>(issuance_blinding_privkey[nIn].begin(), issuance_blinding_privkey[nIn].end()));
+
+                // Generate rangeproof, no script committed for issuances
+                bool rangeresult = GenerateRangeproof((nPseudo ? txinwit.vchInflationKeysRangeproof : txinwit.vchIssuanceAmountRangeproof), value_blindptrs, nonce, amount, CScript(), value_commit, asset_gen, asset, asset_blindptrs);
+                assert(rangeresult);
+
+                // Successfully blinded this issuance
+                num_blinded++;
+            }
+        }
+    }
+
+    // This section of code *only* deals with unblinded outputs
+    // that we want to blind
+    for (size_t nOut = 0; nOut < output_pubkeys.size(); nOut++) {
+        if (output_pubkeys[nOut].IsFullyValid()) {
+            CTxOut& out = tx.vout[nOut];
+            num_blind_attempts++;
+            CConfidentialAsset& conf_asset = out.nAsset;
+            CConfidentialValue& conf_value = out.nValue;
+            CAmount amount = conf_value.GetAmount();
+            asset = out.nAsset.GetAsset();
+            blinded_amounts.push_back(conf_value.GetAmount());
+
+            GetStrongRandBytes(&blind[num_blind_attempts-1][0], 32);
+            GetStrongRandBytes(&asset_blind[num_blind_attempts-1][0], 32);
+            value_blindptrs.push_back(&blind[num_blind_attempts-1][0]);
+            asset_blindptrs.push_back(&asset_blind[num_blind_attempts-1][0]);
+
+            // Last blinding factor r' is set as -(output's (vr + r') - input's (vr + r')).
+            // Before modifying the transaction or return arguments we must
+            // ensure the final blinding factor to not be its corresponding -vr (aka unblinded),
+            // or 0, in the case of 0-value output, insisting on additional output to blind.
+            if (num_blind_attempts == num_to_blind) {
+
+                // Can't successfully blind in this case, since -vr = r
+                // This check is assuming blinds are generated randomly
+                // Adversary would need to create all input blinds
+                // therefore would already know all your summed output amount anyways.
+                if (num_blind_attempts == 1 && num_known_input_blinds == 0) {
+                    return num_blinded;
+                }
+
+                // Generate value we intend to insert
+                ret = secp256k1_pedersen_blind_generator_blind_sum(secp256k1_blind_context, &blinded_amounts[0], &asset_blindptrs[0], &value_blindptrs[0], num_blind_attempts + num_known_input_blinds, num_issuance_blind_attempts + num_known_input_blinds);
+                assert(ret);
+
+                // Resulting blinding factor can sometimes be 0
+                // where inputs are the negations of each other
+                // and the unblinded value of the output is 0.
+                // e.g. 1 unblinded input to 2 blinded outputs,
+                // then spent to 1 unblinded output. (vr + r')
+                // becomes just (r'), if this is 0, we can just
+                // abort and not blind and the math adds up.
+                // Count as success(to signal caller that nothing wrong) and return early
+                if (memcmp(diff_zero, &blind[num_blind_attempts-1][0], 32) == 0) {
+                   return ++num_blinded;
+                }
+            }
+
+            CTxOutWitness& txoutwit = tx.witness.vtxoutwit[nOut];
+
+            out_val_blind_factors[nOut] = uint256(std::vector<unsigned char>(value_blindptrs[value_blindptrs.size()-1], value_blindptrs[value_blindptrs.size()-1]+32));
+            out_asset_blind_factors[nOut] = uint256(std::vector<unsigned char>(asset_blindptrs[asset_blindptrs.size()-1], asset_blindptrs[asset_blindptrs.size()-1]+32));
+
+            //Blind the asset ID
+            BlindAsset(conf_asset, asset_gen, asset, asset_blindptrs.back());
+
+            // Create value commitment
+            CreateValueCommitment(conf_value, value_commit, value_blindptrs.back(), asset_gen, amount);
+
+            // Generate nonce for rewind by owner
+            uint256 nonce = GenerateOutputRangeproofNonce(out, output_pubkeys[nOut]);
+
+            // Generate rangeproof
+            bool rangeresult = GenerateRangeproof(txoutwit.vchRangeproof, value_blindptrs, nonce, amount, out.scriptPubKey, value_commit, asset_gen, asset, asset_blindptrs);
+            assert(rangeresult);
+
+            // Create surjection proof for this output
+            if (!SurjectOutput(txoutwit, surjection_targets, target_asset_generators, target_asset_blinders, asset_blindptrs, asset_gen, asset)) {
+                continue;
+            }
+
+            // Successfully blinded this output
+            num_blinded++;
+        }
+    }
+
+    return num_blinded;
+}
+
+void RawFillBlinds(CMutableTransaction& tx, std::vector<uint256>& output_value_blinds, std::vector<uint256>& output_asset_blinds, std::vector<CPubKey>& output_pubkeys) {
+    for (size_t nOut = 0; nOut < tx.vout.size(); nOut++) {
+        // Any place-holder blinding pubkeys are extracted
+        if (tx.vout[nOut].nValue.IsExplicit()) {
+            CPubKey pubkey(tx.vout[nOut].nNonce.vchCommitment);
+            if (pubkey.IsFullyValid()) {
+                output_pubkeys.push_back(pubkey);
+            } else {
+                output_pubkeys.push_back(CPubKey());
+            }
+        }
+        // No way to unblind anything, just fill out
+        output_value_blinds.push_back(uint256());
+        output_asset_blinds.push_back(uint256());
+    }
+    // We cannot unwind issuance inputs because there is no nonce placeholder for pubkeys
+}
diff --git a/src/blind.h b/src/blind.h
new file mode 100644
index 0000000000000..4296b70ce7bdb
--- /dev/null
+++ b/src/blind.h
@@ -0,0 +1,63 @@
+// Copyright (c) 2017-2019 The Elements Core developers
+// // Distributed under the MIT software license, see the accompanying
+// // file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_BLIND_H
+#define BITCOIN_BLIND_H
+
+#include <key.h>
+#include <pubkey.h>
+#include <primitives/transaction.h>
+#include <primitives/confidential.h>
+
+#include <secp256k1.h>
+#include <secp256k1_rangeproof.h>
+#include <secp256k1_surjectionproof.h>
+
+//! ELEMENTS: 36-bit rangeproof size
+static const size_t DEFAULT_RANGEPROOF_SIZE = 2893;
+
+/*
+ * Unblind a pair of confidential asset and value.
+ * Note that unblinded data will only be outputted if *BOTH* asset and value could be unblinded.
+ *
+ * blinding_key is used to create the nonce to rewind the rangeproof in conjunction with the nNonce commitment. In the case of a 0-length nNonce, the blinding key is directly used as the nonce.
+ * Currently there is only a sidechannel message in the rangeproof so a valid rangeproof must
+ * be included in the pair to recover value and asset data.
+ */
+bool UnblindConfidentialPair(const CKey& blinding_key, const CConfidentialValue& conf_value, const CConfidentialAsset& conf_asset, const CConfidentialNonce& nonce_commitment, const CScript& committedScript, const std::vector<unsigned char>& vchRangeproof, CAmount& amount_out, uint256& blinding_factor_out, CAsset& asset_out, uint256& asset_blinding_factor_out);
+
+bool GenerateRangeproof(std::vector<unsigned char>& rangeproof, const std::vector<unsigned char*>& value_blindptrs, const uint256& nonce, const CAmount amount, const CScript& scriptPubKey, const secp256k1_pedersen_commitment& value_commit, const secp256k1_generator& gen, const CAsset& asset, std::vector<const unsigned char*>& asset_blindptrs);
+
+bool SurjectOutput(CTxOutWitness& txoutwit, const std::vector<secp256k1_fixed_asset_tag>& surjection_targets, const std::vector<secp256k1_generator>& target_asset_generators, const std::vector<uint256 >& target_asset_blinders, const std::vector<const unsigned char*> asset_blindptrs, const secp256k1_generator& output_asset_gen, const CAsset& asset);
+
+uint256 GenerateOutputRangeproofNonce(CTxOut& out, const CPubKey output_pubkey);
+
+void BlindAsset(CConfidentialAsset& conf_asset, secp256k1_generator& asset_gen, const CAsset& asset, const unsigned char* asset_blindptr);
+
+void CreateValueCommitment(CConfidentialValue& conf_value, secp256k1_pedersen_commitment& value_commit, const unsigned char* value_blindptr, const secp256k1_generator& asset_gen, const CAmount amount);
+
+/* Returns the number of outputs that were successfully blinded.
+ * In many cases a `0` can be fixed by adding an additional output.
+ * @param[in]   input_blinding_factors - A vector of input blinding factors that will be used to create the balanced output blinding factors
+ * @param[in]   input_asset_blinding_factors - A vector of input asset blinding factors that will be used to create the balanced output blinding factors
+ * @param[in]   input_assets - the asset of each corresponding input
+ * @param[in]   input_amounts - the unblinded amounts of each input. Required for owned blinded inputs
+ * @param[in/out]   output_blinding_factors - A vector of blinding factors. New blinding factors will replace these values.
+ * @param[in/out]   output_asset_blinding_factors - A vector of asset blinding factors. New blinding factors will replace these values.
+ * @param[in]   output_pubkeys - If valid, corresponding output must be unblinded, and will result in fully blinded output, modifying the output blinding arguments as well.
+ * @param[in]   vBlindIssuanceAsset - List of keys to use as nonces for issuance asset blinding.
+ * @param[in]   vBlindIssuanceToken - List of keys to use as nonces for issuance token blinding.
+ * @param[in/out]   tx - The transaction to be modified.
+ * @param[in] auxiliary_generators - a list of generators to create surjection proofs when inputs are not owned by caller. Passing in non-empty elements results in ignoring of other input arguments for that index
+ */
+int BlindTransaction(std::vector<uint256 >& input_value_blinding_factors, const std::vector<uint256 >& input_asset_blinding_factors, const std::vector<CAsset >& input_assets, const std::vector<CAmount >& input_amounts, std::vector<uint256 >& out_val_blind_factors, std::vector<uint256 >& out_asset_blind_factors, const std::vector<CPubKey>& output_pubkeys, const std::vector<CKey>& issuance_blinding_privkey, const std::vector<CKey>& token_blinding_privkey, CMutableTransaction& tx, std::vector<std::vector<unsigned char> >* auxiliary_generators = nullptr);
+
+/*
+ * Extract pubkeys from nonce commitment placeholders, fill out vector of blank output blinding data
+ */
+void RawFillBlinds(CMutableTransaction& tx, std::vector<uint256>& output_value_blinds, std::vector<uint256>& output_asset_blinds, std::vector<CPubKey>& output_pubkeys);
+
+size_t GetNumIssuances(const CTransaction& tx);
+
+#endif //BITCOIN_BLIND_H
diff --git a/src/chainparams.cpp b/src/chainparams.cpp
index 3a9533ff1a555..6cd7b36320e0c 100644
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -7,6 +7,7 @@
 
 #include <chainparamsseeds.h>
 #include <consensus/merkle.h>
+#include <issuance.h>
 #include <primitives/transaction.h>
 #include <tinyformat.h>
 #include <util.h>
@@ -47,10 +48,8 @@ static CBlock CreateGenesisBlock(const Consensus::Params& params, const CScript&
     CMutableTransaction txNew;
     txNew.nVersion = 1;
     txNew.vin.resize(1);
-    txNew.vout.resize(1);
     txNew.vin[0].scriptSig = genesisScriptSig;
-    txNew.vout[0].nValue = genesisReward;
-    txNew.vout[0].scriptPubKey = genesisOutputScript;
+    txNew.vout.push_back(CTxOut(CAsset(), genesisReward, genesisOutputScript));
 
     CBlock genesis;
     genesis.nTime    = nTime;
@@ -85,23 +84,6 @@ static CBlock CreateGenesisBlock(uint32_t nTime, uint32_t nNonce, uint32_t nBits
     return CreateGenesisBlock(params, genesisScriptSig, genesisOutputScript, nTime, nNonce, nBits, nVersion, genesisReward);
 }
 
-/** Add an issuance transaction to the genesis block. Typically used to pre-issue
- * the policyAsset of a blockchain. The genesis block is not actually validated,
- * so this transaction simply has to match issuance structure. */
-static void AppendInitialIssuance(CBlock& genesis_block, const COutPoint& prevout, const int64_t asset_values, const CScript& issuance_destination) {
-
-    // Note: Genesis block isn't actually validated, outputs are entered into utxo db only
-    CMutableTransaction txNew;
-    txNew.nVersion = 1;
-    txNew.vin.resize(1);
-    txNew.vin[0].prevout = prevout;
-
-    txNew.vout.push_back(CTxOut(asset_values, issuance_destination));
-
-    genesis_block.vtx.push_back(MakeTransactionRef(std::move(txNew)));
-    genesis_block.hashMerkleRoot = BlockMerkleRoot(genesis_block);
-}
-
 /**
  * Main network
  */
@@ -144,11 +126,14 @@ class CMainParams : public CChainParams {
 
         consensus.genesis_subsidy = 50*COIN;
         consensus.connect_genesis_outputs = false;
+        consensus.subsidy_asset = CAsset();
         anyonecanspend_aremine = false;
         enforce_pak = false;
         multi_data_permitted = false;
         consensus.has_parent_chain = false;
         g_signed_blocks = false;
+        g_con_elementsmode = false;
+        g_con_blockheightinheader = false;
 
         /**
          * The message start string is designed to be unlikely to occur in normal data.
@@ -187,6 +172,7 @@ class CMainParams : public CChainParams {
         base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x88, 0xAD, 0xE4};
 
         bech32_hrp = "bc";
+        blech32_hrp = blech32_hrp;
 
         vFixedSeeds = std::vector<SeedSpec6>(pnSeed6_main, pnSeed6_main + ARRAYLEN(pnSeed6_main));
 
@@ -266,10 +252,14 @@ class CTestNetParams : public CChainParams {
 
         consensus.genesis_subsidy = 50*COIN;
         consensus.connect_genesis_outputs = false;
+        consensus.subsidy_asset = CAsset();
         anyonecanspend_aremine = false;
         enforce_pak = false;
         multi_data_permitted = false;
         consensus.has_parent_chain = false;
+        g_signed_blocks = false;
+        g_con_elementsmode = false;
+        g_con_blockheightinheader = false;
 
         pchMessageStart[0] = 0x0b;
         pchMessageStart[1] = 0x11;
@@ -298,6 +288,7 @@ class CTestNetParams : public CChainParams {
         base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};
 
         bech32_hrp = "tb";
+        blech32_hrp = blech32_hrp;
 
         vFixedSeeds = std::vector<SeedSpec6>(pnSeed6_test, pnSeed6_test + ARRAYLEN(pnSeed6_test));
 
@@ -362,10 +353,14 @@ class CRegTestParams : public CChainParams {
 
         consensus.genesis_subsidy = 50*COIN;
         consensus.connect_genesis_outputs = false;
+        consensus.subsidy_asset = CAsset();
         anyonecanspend_aremine = false;
         enforce_pak = false;
         multi_data_permitted = false;
         consensus.has_parent_chain = false;
+        g_signed_blocks = false;
+        g_con_elementsmode = false;
+        g_con_blockheightinheader = false;
 
         pchMessageStart[0] = 0xfa;
         pchMessageStart[1] = 0xbf;
@@ -407,6 +402,7 @@ class CRegTestParams : public CChainParams {
         base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x35, 0x83, 0x94};
 
         bech32_hrp = "bcrt";
+        blech32_hrp = blech32_hrp;
 
         /* enable fallback fee on regtest */
         m_fallback_fee_enabled = true;
@@ -486,6 +482,7 @@ class CCustomParams : public CRegTestParams {
         m_fallback_fee_enabled = args.GetBoolArg("-fallback_fee_enabled", m_fallback_fee_enabled);
 
         bech32_hrp = args.GetArg("-bech32_hrp", bech32_hrp);
+        blech32_hrp = args.GetArg("-blech32_hrp", "el");
         base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1, args.GetArg("-pubkeyprefix", 111));
         base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1, args.GetArg("-scriptprefix", 196));
         base58Prefixes[SECRET_KEY] =     std::vector<unsigned char>(1, args.GetArg("-secretprefix", 239));
@@ -527,7 +524,7 @@ class CCustomParams : public CRegTestParams {
         // Note: These globals are needed to avoid circular dependencies.
         // Default to true for custom chains.
         g_con_blockheightinheader = args.GetBoolArg("-con_blockheightinheader", true);
-        g_con_elementswitness = args.GetBoolArg("-con_elementswitness", true);
+        g_con_elementsmode = args.GetBoolArg("-con_elementsmode", true);
 
         // No subsidy for custom chains by default
         consensus.genesis_subsidy = args.GetArg("-con_blocksubsidy", 0);
@@ -565,6 +562,30 @@ class CCustomParams : public CRegTestParams {
         base58Prefixes[PARENT_PUBKEY_ADDRESS] = std::vector<unsigned char>(1, args.GetArg("-parentpubkeyprefix", 111));
         base58Prefixes[PARENT_SCRIPT_ADDRESS] = std::vector<unsigned char>(1, args.GetArg("-parentscriptprefix", 196));
         parent_bech32_hrp = args.GetArg("-parent_bech32_hrp", "bcrt");
+        parent_blech32_hrp = args.GetArg("-parent_bech32_hrp", "bcrt");
+
+        base58Prefixes[BLINDED_ADDRESS] = std::vector<unsigned char>(1, args.GetArg("-blindedprefix", 4));
+
+        // Calculate pegged Bitcoin asset
+        std::vector<unsigned char> commit = CommitToArguments(consensus, strNetworkID);
+        uint256 entropy;
+        GenerateAssetEntropy(entropy,  COutPoint(uint256(commit), 0), parentGenesisBlockHash);
+
+        // Elements serialization uses derivation, bitcoin serialization uses 0x00
+        if (g_con_elementsmode) {
+            CalculateAsset(consensus.pegged_asset, entropy);
+        } else {
+            assert(consensus.pegged_asset == CAsset());
+        }
+
+        consensus.parent_pegged_asset.SetHex(args.GetArg("-con_parent_pegged_asset", "0x00"));
+        initial_reissuance_tokens = args.GetArg("-initialreissuancetokens", 0);
+
+        // Subsidy asset, like policyAsset, defaults to the pegged_asset
+        consensus.subsidy_asset = consensus.pegged_asset;
+        if (gArgs.IsArgSet("-subsidyasset")) {
+            consensus.subsidy_asset = CAsset(uint256S(gArgs.GetArg("-subsidyasset", "0x00")));
+        }
 
         // END ELEMENTS fields
 
@@ -583,8 +604,8 @@ class CCustomParams : public CRegTestParams {
             // Intended compatibility with Liquid v1 and elements-0.14.1
             std::vector<unsigned char> commit = CommitToArguments(consensus, strNetworkID);
             genesis = CreateGenesisBlock(consensus, CScript(commit), CScript(OP_RETURN), 1296688602, 2, 0x207fffff, 1, 0);
-            if (initialFreeCoins != 0) {
-                AppendInitialIssuance(genesis, COutPoint(uint256(commit), 0), initialFreeCoins, CScript() << OP_TRUE);
+            if (initialFreeCoins != 0 || initial_reissuance_tokens != 0) {
+                AppendInitialIssuance(genesis, COutPoint(uint256(commit), 0), parentGenesisBlockHash, (initialFreeCoins > 0) ? 1 : 0, initialFreeCoins, (initial_reissuance_tokens > 0) ? 1 : 0, initial_reissuance_tokens, CScript() << OP_TRUE);
             }
         } else {
             throw std::runtime_error(strprintf("Invalid -genesis_style (%s)", consensus.genesis_style));
@@ -601,6 +622,145 @@ class CCustomParams : public CRegTestParams {
     }
 };
 
+/**
+ * Liquid v1
+ */
+class CLiquidV1Params : public CChainParams {
+public:
+    CLiquidV1Params()
+    {
+
+        strNetworkID = "liquidv1";
+        consensus.nSubsidyHalvingInterval = 150;
+        consensus.BIP16Exception = uint256();
+        consensus.BIP34Height = 0;
+        consensus.BIP34Hash = uint256();
+        consensus.BIP65Height = 0;
+        consensus.BIP66Height = 0;
+        consensus.powLimit = uint256S("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+        consensus.nPowTargetTimespan = 14 * 24 * 60 * 60; // two weeks;
+        consensus.nPowTargetSpacing = 60; // Minute block assumption
+        consensus.fPowAllowMinDifficultyBlocks = true;
+        consensus.fPowNoRetargeting = true;
+        consensus.nRuleChangeActivationThreshold = 108;
+        consensus.nMinerConfirmationWindow = 144;
+
+        consensus.nMinimumChainWork = uint256();
+        consensus.defaultAssumeValid = uint256();
+
+        nPruneAfterHeight = 1000;
+        fDefaultConsistencyChecks = false;
+        fRequireStandard = true;
+        fMineBlocksOnDemand = false;
+        m_fallback_fee_enabled = false; // TODO Will this break stuff?
+
+        bech32_hrp = "ex"; // ex(plicit)
+        blech32_hrp = "lq"; // l(i)q(uid)
+        parent_bech32_hrp = "bc";
+        parent_blech32_hrp = "bc"; // Doesn't exist but...
+
+        base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1, 57);
+        base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1, 39);
+        base58Prefixes[SECRET_KEY] =     std::vector<unsigned char>(1, 128);
+        base58Prefixes[BLINDED_ADDRESS]= std::vector<unsigned char>(1,12);
+
+        base58Prefixes[EXT_PUBLIC_KEY] = {0x04, 0x88, 0xB2, 0x1E};
+        base58Prefixes[EXT_SECRET_KEY] = {0x04, 0x88, 0xAD, 0xE4};
+
+        base58Prefixes[PARENT_PUBKEY_ADDRESS] = std::vector<unsigned char>(1,0);
+        base58Prefixes[PARENT_SCRIPT_ADDRESS] = std::vector<unsigned char>(1,5);
+
+        pchMessageStart[0] = 0xfa;
+        pchMessageStart[1] = 0xbf;
+        pchMessageStart[2] = 0xb5;
+        pchMessageStart[3] = 0xda;
+
+        nDefaultPort = 7042;
+
+        vSeeds.clear();
+        vSeeds.emplace_back("seed.liquidnetwork.io");
+        vFixedSeeds = std::vector<SeedSpec6>(pnSeed6_liquidv1, pnSeed6_liquidv1 + ARRAYLEN(pnSeed6_liquidv1));
+
+        //
+        // ELEMENTS fields
+
+        consensus.genesis_style = "elements"; // unused here but let's set it anyways
+
+        // Block signing encumberance script, default of 51 aka OP_TRUE
+        std::vector<unsigned char> sign_bytes = ParseHex("5b21026a2a106ec32c8a1e8052e5d02a7b0a150423dbd9b116fc48d46630ff6e6a05b92102791646a8b49c2740352b4495c118d876347bf47d0551c01c4332fdc2df526f1a2102888bda53a424466b0451627df22090143bbf7c060e9eacb1e38426f6b07f2ae12102aee8967150dee220f613de3b239320355a498808084a93eaf39a34dcd62024852102d46e9259d0a0bb2bcbc461a3e68f34adca27b8d08fbe985853992b4b104e27412102e9944e35e5750ab621e098145b8e6cf373c273b7c04747d1aa020be0af40ccd62102f9a9d4b10a6d6c56d8c955c547330c589bb45e774551d46d415e51cd9ad5116321033b421566c124dfde4db9defe4084b7aa4e7f36744758d92806b8f72c2e943309210353dcc6b4cf6ad28aceb7f7b2db92a4bf07ac42d357adf756f3eca790664314b621037f55980af0455e4fb55aad9b85a55068bb6dc4740ea87276dc693f4598db45fa210384001daa88dabd23db878dbb1ce5b4c2a5fa72c3113e3514bf602325d0c37b8e21039056d089f2fe72dbc0a14780b4635b0dc8a1b40b7a59106325dd1bc45cc70493210397ab8ea7b0bf85bc7fc56bb27bf85e75502e94e76a6781c409f3f2ec3d1122192103b00e3b5b77884bf3cae204c4b4eac003601da75f96982ffcb3dcb29c5ee419b92103c1f3c0874cfe34b8131af34699589aacec4093399739ae352e8a46f80a6f68375fae");
+        consensus.signblockscript = CScript(sign_bytes.begin(), sign_bytes.end());
+        consensus.max_block_signature_size = 12*74; // 11 signatures plus wiggle room
+        g_signed_blocks = true;
+
+        g_con_blockheightinheader = true;
+        g_con_elementsmode = true;
+
+        consensus.genesis_subsidy = 0;
+
+        // All non-zero coinbase outputs must go to this scriptPubKey
+        std::vector<unsigned char> man_bytes = ParseHex("76a914fc26751a5025129a2fd006c6fbfa598ddd67f7e188ac");
+        consensus.mandatory_coinbase_destination = CScript(man_bytes.begin(), man_bytes.end()); // Blank script allows any coinbase destination
+
+        // Custom chains connect coinbase outputs to db by default
+        consensus.connect_genesis_outputs = true;
+
+        initialFreeCoins = 0;
+
+        anyonecanspend_aremine = false;
+
+        consensus.has_parent_chain = true;
+
+        enforce_pak = true;
+
+        multi_data_permitted = true;
+
+        parentGenesisBlockHash = uint256S("000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f");
+        const bool parent_genesis_is_null = parentGenesisBlockHash == uint256();
+        assert(consensus.has_parent_chain != parent_genesis_is_null);
+        consensus.parentChainPowLimit = uint256S("0000000000000000ffffffffffffffffffffffffffffffffffffffffffffffff");
+        consensus.parent_chain_signblockscript = CScript(); // It has PoW
+        consensus.pegin_min_depth = 100;
+
+        const CScript default_script(CScript() << OP_TRUE);
+        consensus.fedpegScript = StrHexToScriptWithDefault("745c87635b21020e0338c96a8870479f2396c373cc7696ba124e8635d41b0ea581112b678172612102675333a4e4b8fb51d9d4e22fa5a8eaced3fdac8a8cbf9be8c030f75712e6af992102896807d54bc55c24981f24a453c60ad3e8993d693732288068a23df3d9f50d4821029e51a5ef5db3137051de8323b001749932f2ff0d34c82e96a2c2461de96ae56c2102a4e1a9638d46923272c266631d94d36bdb03a64ee0e14c7518e49d2f29bc40102102f8a00b269f8c5e59c67d36db3cdc11b11b21f64b4bffb2815e9100d9aa8daf072103079e252e85abffd3c401a69b087e590a9b86f33f574f08129ccbd3521ecf516b2103111cf405b627e22135b3b3733a4a34aa5723fb0f58379a16d32861bf576b0ec2210318f331b3e5d38156da6633b31929c5b220349859cc9ca3d33fb4e68aa08401742103230dae6b4ac93480aeab26d000841298e3b8f6157028e47b0897c1e025165de121035abff4281ff00660f99ab27bb53e6b33689c2cd8dcd364bc3c90ca5aea0d71a62103bd45cddfacf2083b14310ae4a84e25de61e451637346325222747b157446614c2103cc297026b06c71cbfa52089149157b5ff23de027ac5ab781800a578192d175462103d3bde5d63bdb3a6379b461be64dad45eabff42f758543a9645afd42f6d4248282103ed1e8d5109c9ed66f7941bc53cc71137baa76d50d274bda8d5e8ffbd6e61fe9a5f6702c00fb275522103aab896d53a8e7d6433137bbba940f9c521e085dd07e60994579b64a6d992cf79210291b7d0b1b692f8f524516ed950872e5da10fb1b808b5a526dedc6fed1cf29807210386aa9372fbab374593466bc5451dc59954e90787f08060964d95c87ef34ca5bb5368ae", default_script);
+
+
+        // Calculate pegged Bitcoin asset
+        std::vector<unsigned char> commit = CommitToArguments(consensus, strNetworkID);
+        uint256 entropy;
+        GenerateAssetEntropy(entropy,  COutPoint(uint256(commit), 0), parentGenesisBlockHash);
+
+        // Elements serialization uses derivation, bitcoin serialization uses 0x00
+        if (g_con_elementsmode) {
+            CalculateAsset(consensus.pegged_asset, entropy);
+        } else {
+            assert(consensus.pegged_asset == CAsset());
+        }
+
+        consensus.parent_pegged_asset.SetHex("0x00"); // No parent pegged asset
+        initial_reissuance_tokens = 0;
+
+        consensus.subsidy_asset = consensus.pegged_asset;
+
+        // CSV always active
+        consensus.vDeployments[Consensus::DEPLOYMENT_CSV].bit = 0;
+        consensus.vDeployments[Consensus::DEPLOYMENT_CSV].nStartTime = Consensus::BIP9Deployment::ALWAYS_ACTIVE;
+        consensus.vDeployments[Consensus::DEPLOYMENT_CSV].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
+        // Segwit, likewise
+        consensus.vDeployments[Consensus::DEPLOYMENT_SEGWIT].bit = 1;
+        consensus.vDeployments[Consensus::DEPLOYMENT_SEGWIT].nStartTime = Consensus::BIP9Deployment::ALWAYS_ACTIVE;
+        consensus.vDeployments[Consensus::DEPLOYMENT_SEGWIT].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT;
+
+
+        // Finally, create genesis block
+        genesis = CreateGenesisBlock(consensus, CScript(commit), CScript(OP_RETURN), 1296688602, 2, 0x207fffff, 1, 0);
+        consensus.hashGenesisBlock = genesis.GetHash();
+        assert(consensus.hashGenesisBlock.GetHex() == "1466275836220db2944ca059a3a10ef6fd2ea684b0688d2c379296888a206003");
+    }
+
+};
+
+
 static std::unique_ptr<const CChainParams> globalChainParams;
 
 const CChainParams &Params() {
@@ -617,6 +777,8 @@ std::unique_ptr<const CChainParams> CreateChainParams(const std::string& chain)
         return std::unique_ptr<CChainParams>(new CTestNetParams());
     else if (chain == CBaseChainParams::REGTEST)
         return std::unique_ptr<CChainParams>(new CRegTestParams(gArgs));
+    else if (chain == CBaseChainParams::LIQUID1)
+        return std::unique_ptr<CChainParams>(new CLiquidV1Params());
 
     return std::unique_ptr<CChainParams>(new CCustomParams(chain, gArgs));
 }
diff --git a/src/chainparams.h b/src/chainparams.h
index 8a9e760f8b058..8bd849bda00d1 100644
--- a/src/chainparams.h
+++ b/src/chainparams.h
@@ -54,6 +54,7 @@ class CChainParams
         EXT_PUBLIC_KEY,
         EXT_SECRET_KEY,
         // ELEMENTS
+        BLINDED_ADDRESS,
         PARENT_PUBKEY_ADDRESS,
         PARENT_SCRIPT_ADDRESS,
 
@@ -80,6 +81,7 @@ class CChainParams
     const std::vector<std::string>& DNSSeeds() const { return vSeeds; }
     const std::vector<unsigned char>& Base58Prefix(Base58Type type) const { return base58Prefixes[type]; }
     const std::string& Bech32HRP() const { return bech32_hrp; }
+    const std::string& Blech32HRP() const { return blech32_hrp; }
     const std::vector<SeedSpec6>& FixedSeeds() const { return vFixedSeeds; }
     const CCheckpointData& Checkpoints() const { return checkpointData; }
     const ChainTxData& TxData() const { return chainTxData; }
@@ -87,6 +89,7 @@ class CChainParams
     const uint256 ParentGenesisBlockHash() const { return parentGenesisBlockHash; }
     bool anyonecanspend_aremine;
     const std::string& ParentBech32HRP() const { return parent_bech32_hrp; }
+    const std::string& ParentBlech32HRP() const { return parent_blech32_hrp; }
     bool GetEnforcePak() const { return enforce_pak; }
     bool GetMultiDataPermitted() const { return multi_data_permitted; }
 
@@ -100,9 +103,11 @@ class CChainParams
     std::vector<std::string> vSeeds;
     std::vector<unsigned char> base58Prefixes[MAX_BASE58_TYPES];
     std::string bech32_hrp;
+    std::string blech32_hrp;
     std::string strNetworkID;
     CBlock genesis;
     CAmount initialFreeCoins;
+    CAmount initial_reissuance_tokens;
     std::vector<SeedSpec6> vFixedSeeds;
     bool fDefaultConsistencyChecks;
     bool fRequireStandard;
@@ -113,6 +118,7 @@ class CChainParams
     // ELEMENTS extra fields:
     uint256 parentGenesisBlockHash;
     std::string parent_bech32_hrp;
+    std::string parent_blech32_hrp;
     bool enforce_pak;
     bool multi_data_permitted;
 };
diff --git a/src/chainparamsbase.cpp b/src/chainparamsbase.cpp
index 9f856be51f794..5b442b292805e 100644
--- a/src/chainparamsbase.cpp
+++ b/src/chainparamsbase.cpp
@@ -14,6 +14,7 @@
 const std::string CBaseChainParams::MAIN = "main";
 const std::string CBaseChainParams::TESTNET = "test";
 const std::string CBaseChainParams::REGTEST = "regtest";
+const std::string CBaseChainParams::LIQUID1 = "liquidv1";
 
 void SetupChainParamsBaseOptions()
 {
@@ -26,7 +27,7 @@ void SetupChainParamsBaseOptions()
     gArgs.AddArg("-con_mandatorycoinbase", "All non-zero valued coinbase outputs must go to this scriptPubKey, if set.", false, OptionsCategory::ELEMENTS);
     gArgs.AddArg("-con_blocksubsidy", "Defines the amount of block subsidy to start with, at genesis block.", false, OptionsCategory::ELEMENTS);
     gArgs.AddArg("-con_connect_coinbase", "Connect outputs in genesis block to utxo database.", false, OptionsCategory::ELEMENTS);
-    gArgs.AddArg("-con_elementswitness", "Use Elements-like instead of Core-like witness encoding.  This is required for CA/CT. (default: true)", false, OptionsCategory::ELEMENTS);
+    gArgs.AddArg("-con_elementsmode", "Use Elements-like instead of Core-like witness encoding.  This is required for CA/CT. (default: true)", false, OptionsCategory::ELEMENTS);
     gArgs.AddArg("-con_blockheightinheader", "Whether the chain includes the block height directly in the header, for easier validation of block height in low-resource environments. (default: true)", false, OptionsCategory::CHAINPARAMS);
     gArgs.AddArg("-con_genesis_style=<style>", "Use genesis style <style> (default: elements). Results in genesis block compatibility with various networks. Allowed values: elements, bitcoin", true, OptionsCategory::ELEMENTS);
     gArgs.AddArg("-con_signed_blocks", "Signed blockchain. Uses input of `-signblockscript` to define what signatures are necessary to solve it.", false, OptionsCategory::CHAINPARAMS);
@@ -61,9 +62,11 @@ std::unique_ptr<CBaseChainParams> CreateBaseChainParams(const std::string& chain
         return MakeUnique<CBaseChainParams>("testnet3", 18332, 8332);
     else if (chain == CBaseChainParams::REGTEST)
         return MakeUnique<CBaseChainParams>("regtest", 18443, 18332);
+    else if (chain == CBaseChainParams::LIQUID1)
+        return MakeUnique<CBaseChainParams>("liquidv1", 7041, 8332);
 
     // ELEMENTS:
-    return MakeUnique<CBaseChainParams>(chain, 7041, 18332);
+    return MakeUnique<CBaseChainParams>(chain, 7040, 18332);
 }
 
 void SelectBaseParams(const std::string& chain)
diff --git a/src/chainparamsbase.h b/src/chainparamsbase.h
index 4d3617eb6e7fa..273128178f82c 100644
--- a/src/chainparamsbase.h
+++ b/src/chainparamsbase.h
@@ -20,6 +20,7 @@ class CBaseChainParams
     static const std::string MAIN;
     static const std::string TESTNET;
     static const std::string REGTEST;
+    static const std::string LIQUID1;
 
     const std::string& DataDir() const { return strDataDir; }
     int RPCPort() const { return nRPCPort; }
diff --git a/src/chainparamsseeds.h b/src/chainparamsseeds.h
index 4b982a4715136..6bc7f85d9c1d6 100644
--- a/src/chainparamsseeds.h
+++ b/src/chainparamsseeds.h
@@ -1287,4 +1287,15 @@ static SeedSpec6 pnSeed6_test[] = {
     {{0xfd,0x87,0xd8,0x7e,0xeb,0x43,0x47,0xb1,0xe4,0x55,0xd1,0xb0,0x14,0x3f,0xb6,0xdb}, 18333},
     {{0xfd,0x87,0xd8,0x7e,0xeb,0x43,0xa0,0x60,0x9e,0x46,0x54,0xdb,0x61,0x3b,0xb2,0x6f}, 18333}
 };
+
+static SeedSpec6 pnSeed6_liquidv1[] = {
+    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x23,0xc4,0x10,0xfe}, 7042},
+    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x23,0xed,0xb0,0x3f}, 7042},
+    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x23,0xed,0x51,0x0e}, 7042},
+    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x23,0xed,0x93,0x15}, 7042},
+    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x23,0xe3,0x5f,0x6d}, 7042},
+    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x23,0xe7,0x8d,0xad}, 7042},
+    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x68,0xc4,0x30,0xb8}, 7042},
+    {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x23,0xe7,0x0a,0x93}, 7042}
+};
 #endif // BITCOIN_CHAINPARAMSSEEDS_H
diff --git a/src/checkqueue.h b/src/checkqueue.h
index 978e23a7c41b4..68c4d78407ac9 100644
--- a/src/checkqueue.h
+++ b/src/checkqueue.h
@@ -41,7 +41,7 @@ class CCheckQueue
 
     //! The queue of elements to be processed.
     //! As the order of booleans doesn't matter, it is used as a LIFO (stack)
-    std::vector<T> queue;
+    std::vector<T*> queue;
 
     //! The number of workers (including the master) that are idle.
     int nIdle;
@@ -66,7 +66,7 @@ class CCheckQueue
     bool Loop(bool fMaster = false)
     {
         boost::condition_variable& cond = fMaster ? condMaster : condWorker;
-        std::vector<T> vChecks;
+        std::vector<T*> vChecks;
         vChecks.reserve(nBatchSize);
         unsigned int nNow = 0;
         bool fOk = true;
@@ -105,20 +105,18 @@ class CCheckQueue
                 // * Try to account for idle jobs which will instantly start helping.
                 // * Don't do batches smaller than 1 (duh), or larger than nBatchSize.
                 nNow = std::max(1U, std::min(nBatchSize, (unsigned int)queue.size() / (nTotal + nIdle + 1)));
-                vChecks.resize(nNow);
-                for (unsigned int i = 0; i < nNow; i++) {
-                    // We want the lock on the mutex to be as short as possible, so swap jobs from the global
-                    // queue to the local batch vector instead of copying.
-                    vChecks[i].swap(queue.back());
-                    queue.pop_back();
-                }
+                vChecks.clear();
+                vChecks.insert(vChecks.end(), queue.end() - nNow, queue.end());
+                queue.resize(queue.size() - nNow);
                 // Check whether we need to do work at all
                 fOk = fAllOk;
             }
             // execute work
-            for (T& check : vChecks)
+            for (T* check : vChecks) {
                 if (fOk)
-                    fOk = check();
+                    fOk = (*check)();
+                delete check;
+            }
             vChecks.clear();
         } while (true);
     }
@@ -143,13 +141,10 @@ class CCheckQueue
     }
 
     //! Add a batch of checks to the queue
-    void Add(std::vector<T>& vChecks)
+    void Add(const std::vector<T*> vChecks)
     {
         boost::unique_lock<boost::mutex> lock(mutex);
-        for (T& check : vChecks) {
-            queue.push_back(T());
-            check.swap(queue.back());
-        }
+        queue.insert(queue.end(), vChecks.begin(), vChecks.end());
         nTodo += vChecks.size();
         if (vChecks.size() == 1)
             condWorker.notify_one();
@@ -159,6 +154,7 @@ class CCheckQueue
 
     ~CCheckQueue()
     {
+        assert(queue.empty());
     }
 
 };
@@ -171,14 +167,14 @@ template <typename T>
 class CCheckQueueControl
 {
 private:
-    CCheckQueue<T> * const pqueue;
+    CCheckQueue<T>* const pqueue;
     bool fDone;
 
 public:
     CCheckQueueControl() = delete;
     CCheckQueueControl(const CCheckQueueControl&) = delete;
     CCheckQueueControl& operator=(const CCheckQueueControl&) = delete;
-    explicit CCheckQueueControl(CCheckQueue<T> * const pqueueIn) : pqueue(pqueueIn), fDone(false)
+    explicit CCheckQueueControl(CCheckQueue<T>* const pqueueIn) : pqueue(pqueueIn), fDone(false)
     {
         // passed queue is supposed to be unused, or nullptr
         if (pqueue != nullptr) {
@@ -195,7 +191,7 @@ class CCheckQueueControl
         return fRet;
     }
 
-    void Add(std::vector<T>& vChecks)
+    void Add(std::vector<T*> vChecks)
     {
         if (pqueue != nullptr)
             pqueue->Add(vChecks);
diff --git a/src/coins.cpp b/src/coins.cpp
index 672912b2fdac9..2aa90b18abc50 100644
--- a/src/coins.cpp
+++ b/src/coins.cpp
@@ -124,7 +124,16 @@ bool CCoinsViewCache::SpendCoin(const COutPoint &outpoint, Coin* moveout) {
     return true;
 }
 
-static const Coin coinEmpty;
+// ELEMENTS:
+// Because g_con_elementsmode is only set after the moment coinEmpty is initialized,
+// we have to force set it to an empty coin without the default asset commitment.
+Coin generateEmptyCoin() {
+    Coin coin;
+    coin.out.nValue.vchCommitment.clear();
+    coin.out.nAsset.vchCommitment.clear();
+    return coin;
+}
+static const Coin coinEmpty = generateEmptyCoin();
 
 const Coin& CCoinsViewCache::AccessCoin(const COutPoint &outpoint) const {
     CCoinsMap::const_iterator it = FetchCoin(outpoint);
@@ -306,7 +315,8 @@ CAmount CCoinsViewCache::GetValueIn(const CTransaction& tx) const
 
     CAmount nResult = 0;
     for (unsigned int i = 0; i < tx.vin.size(); i++)
-        nResult += AccessCoin(tx.vin[i].prevout).out.nValue;
+        // ELEMENTS: this method is for tests only, just naively add amounts
+        nResult += AccessCoin(tx.vin[i].prevout).out.nValue.GetAmount();
 
     return nResult;
 }
diff --git a/src/compressor.h b/src/compressor.h
index c1eda503c8d82..b3c44addfeb39 100644
--- a/src/compressor.h
+++ b/src/compressor.h
@@ -95,14 +95,42 @@ class CTxOutCompressor
 
     template <typename Stream, typename Operation>
     inline void SerializationOp(Stream& s, Operation ser_action) {
-        if (!ser_action.ForRead()) {
-            uint64_t nVal = CompressAmount(txout.nValue);
-            READWRITE(VARINT(nVal));
+        if (g_con_elementsmode) {
+            if (!ser_action.ForRead()) {
+                if (txout.nValue.IsExplicit()) {
+                    uint8_t b = 0;
+                    READWRITE(b);
+                    uint64_t nVal = CompressAmount(txout.nValue.GetAmount());
+                    READWRITE(VARINT(nVal));
+                } else {
+                    uint8_t b = 1;
+                    READWRITE(b);
+                    READWRITE(txout.nValue);
+                }
+            } else {
+                uint8_t type = 0;
+                READWRITE(type);
+                if (type == 0) {
+                    uint64_t nVal = 0;
+                    READWRITE(VARINT(nVal));
+                    txout.nValue = DecompressAmount(nVal);
+                } else {
+                    READWRITE(txout.nValue);
+                }
+            }
+            READWRITE(txout.nAsset);
         } else {
-            uint64_t nVal = 0;
-            READWRITE(VARINT(nVal));
-            txout.nValue = DecompressAmount(nVal);
+            if (!ser_action.ForRead()) {
+                assert(txout.nValue.IsExplicit());
+                uint64_t nVal = CompressAmount(txout.nValue.GetAmount());
+                READWRITE(VARINT(nVal));
+            } else {
+                uint64_t nVal = 0;
+                READWRITE(VARINT(nVal));
+                txout.nValue = DecompressAmount(nVal);
+            }
         }
+
         CScriptCompressor cscript(REF(txout.scriptPubKey));
         READWRITE(cscript);
     }
diff --git a/src/confidential_validation.cpp b/src/confidential_validation.cpp
new file mode 100644
index 0000000000000..39a73bca71d24
--- /dev/null
+++ b/src/confidential_validation.cpp
@@ -0,0 +1,425 @@
+
+#include <confidential_validation.h>
+#include <issuance.h>
+#include <pegins.h>
+#include <script/sigcache.h>
+#include <blind.h>
+
+namespace {
+static secp256k1_context *secp256k1_ctx_verify_amounts;
+
+class CSecp256k1Init {
+public:
+    CSecp256k1Init() {
+        assert(secp256k1_ctx_verify_amounts == NULL);
+        secp256k1_ctx_verify_amounts = secp256k1_context_create(SECP256K1_CONTEXT_VERIFY | SECP256K1_CONTEXT_SIGN);
+        assert(secp256k1_ctx_verify_amounts != NULL);
+    }
+    ~CSecp256k1Init() {
+        assert(secp256k1_ctx_verify_amounts != NULL);
+        secp256k1_context_destroy(secp256k1_ctx_verify_amounts);
+        secp256k1_ctx_verify_amounts = NULL;
+    }
+};
+static CSecp256k1Init instance_of_csecp256k1;
+}
+
+bool HasValidFee(const CTransaction& tx) {
+    CAmountMap totalFee;
+    for (unsigned int i = 0; i < tx.vout.size(); i++) {
+        CAmount fee = 0;
+        if (tx.vout[i].IsFee()) {
+            fee = tx.vout[i].nValue.GetAmount();
+            if (fee == 0 || !MoneyRange(fee))
+                return false;
+            totalFee[tx.vout[i].nAsset.GetAsset()] += fee;
+        }
+    }
+    return MoneyRange(totalFee);
+}
+
+CAmountMap GetFeeMap(const CTransaction& tx) {
+    CAmountMap fee;
+    for (const CTxOut& txout : tx.vout) {
+        if (txout.IsFee()) {
+            fee[txout.nAsset.GetAsset()] += txout.nValue.GetAmount();
+        }
+    }
+    return fee;
+}
+
+bool CRangeCheck::operator()() {
+    if (val->IsExplicit()) {
+        return true;
+    }
+
+    if (!CachingRangeProofChecker(store).VerifyRangeProof(rangeproof, val->vchCommitment, assetCommitment, scriptPubKey, secp256k1_ctx_verify_amounts)) {
+        error = SCRIPT_ERR_RANGEPROOF;
+        return false;
+    }
+
+    return true;
+};
+
+bool CBalanceCheck::operator()() {
+    if (!secp256k1_pedersen_verify_tally(secp256k1_ctx_verify_amounts, vpCommitsIn.data(), vpCommitsIn.size(), vpCommitsOut.data(), vpCommitsOut.size())) {
+        error = SCRIPT_ERR_PEDERSEN_TALLY;
+        return false;
+    }
+
+    return true;
+}
+
+bool CSurjectionCheck::operator()() {
+    return CachingSurjectionProofChecker(store).VerifySurjectionProof(proof, vTags, gen, secp256k1_ctx_verify_amounts, wtxid);
+}
+
+// Destroys the check in the case of no queue, or passes its ownership to the queue.
+ScriptError QueueCheck(std::vector<CCheck*>* queue, CCheck* check) {
+    if (queue != NULL) {
+        queue->push_back(check);
+        return SCRIPT_ERR_OK;
+    }
+    bool success = (*check)();
+    ScriptError err = check->GetScriptError();
+    delete check;
+    return success ? SCRIPT_ERR_OK : err;
+}
+
+// Helper function for VerifyAmount(), not exported
+static bool VerifyIssuanceAmount(secp256k1_pedersen_commitment& value_commit, secp256k1_generator& asset_gen,
+                    const CAsset& asset, const CConfidentialValue& value, const std::vector<unsigned char>& rangeproof,
+                    std::vector<CCheck*>* checks, const bool store_result)
+{
+    // This is used to add in the explicit values
+    unsigned char explicit_blinds[32];
+    memset(explicit_blinds, 0, sizeof(explicit_blinds));
+    int ret;
+
+    ret = secp256k1_generator_generate(secp256k1_ctx_verify_amounts, &asset_gen, asset.begin());
+    assert(ret == 1);
+
+    // Build value commitment
+    if (value.IsExplicit()) {
+        if (!MoneyRange(value.GetAmount()) || value.GetAmount() == 0) {
+            return false;
+        }
+        if (!rangeproof.empty()) {
+            return false;
+        }
+
+
+        ret = secp256k1_pedersen_commit(secp256k1_ctx_verify_amounts, &value_commit, explicit_blinds, value.GetAmount(), &asset_gen);
+        // The explicit_blinds are all 0, and the amount is not 0. So secp256k1_pedersen_commit does not fail.
+        assert(ret == 1);
+    } else if (value.IsCommitment()) {
+        // Verify range proof
+        std::vector<unsigned char> vchAssetCommitment(CConfidentialAsset::nExplicitSize);
+        secp256k1_generator_serialize(secp256k1_ctx_verify_amounts, vchAssetCommitment.data(), &asset_gen);
+        if (QueueCheck(checks, new CRangeCheck(&value, rangeproof, vchAssetCommitment, CScript(), store_result)) != SCRIPT_ERR_OK) {
+            return false;
+        }
+
+        if (secp256k1_pedersen_commitment_parse(secp256k1_ctx_verify_amounts, &value_commit, value.vchCommitment.data()) != 1) {
+            return false;
+        }
+    } else {
+        return false;
+    }
+
+    return true;
+}
+
+bool VerifyAmounts(const std::vector<CTxOut>& inputs, const CTransaction& tx, std::vector<CCheck*>* checks, const bool store_result) {
+    assert(!tx.IsCoinBase());
+    assert(inputs.size() == tx.vin.size());
+
+    std::vector<secp256k1_pedersen_commitment> vData;
+    std::vector<secp256k1_pedersen_commitment *> vpCommitsIn, vpCommitsOut;
+
+    vData.reserve((tx.vin.size() + tx.vout.size() + GetNumIssuances(tx)));
+    secp256k1_pedersen_commitment *p = vData.data();
+    secp256k1_pedersen_commitment commit;
+    secp256k1_generator gen;
+    // This is used to add in the explicit values
+    unsigned char explicit_blinds[32] = {0};
+    int ret;
+
+    uint256 wtxid(tx.GetWitnessHash());
+
+    // This list is used to verify surjection proofs.
+    // Proofs must be constructed with the list being in
+    // order of input and non-null issuance pseudo-inputs, with
+    // input first, asset issuance second, reissuance token third.
+    std::vector<secp256k1_generator> target_generators;
+    target_generators.reserve(tx.vin.size() + GetNumIssuances(tx));
+
+    // Tally up value commitments, check balance
+    for (size_t i = 0; i < tx.vin.size(); ++i) {
+        const CConfidentialValue& val = inputs[i].nValue;
+        const CConfidentialAsset& asset = inputs[i].nAsset;
+
+        if (val.IsNull() || asset.IsNull())
+            return false;
+
+        if (asset.IsExplicit()) {
+            ret = secp256k1_generator_generate(secp256k1_ctx_verify_amounts, &gen, asset.GetAsset().begin());
+            assert(ret != 0);
+        }
+        else if (asset.IsCommitment()) {
+            if (secp256k1_generator_parse(secp256k1_ctx_verify_amounts, &gen, &asset.vchCommitment[0]) != 1)
+                return false;
+        }
+        else {
+            return false;
+        }
+
+        target_generators.push_back(gen);
+
+        if (val.IsExplicit()) {
+            if (!MoneyRange(val.GetAmount()))
+                return false;
+
+            // Fails if val.GetAmount() == 0
+            if (secp256k1_pedersen_commit(secp256k1_ctx_verify_amounts, &commit, explicit_blinds, val.GetAmount(), &gen) != 1)
+                return false;
+        } else if (val.IsCommitment()) {
+            if (secp256k1_pedersen_commitment_parse(secp256k1_ctx_verify_amounts, &commit, &val.vchCommitment[0]) != 1)
+                return false;
+        } else {
+                return false;
+        }
+
+        vData.push_back(commit);
+        vpCommitsIn.push_back(p);
+        p++;
+
+        // Each transaction input may have up to two "pseudo-inputs" to add to the LHS
+        // for (re)issuance and may require up to two rangeproof checks:
+        // blinded value of the new assets being made
+        // blinded value of the issuance tokens being made (only for initial issuance)
+        const CAssetIssuance& issuance = tx.vin[i].assetIssuance;
+
+        // No issuances to process, continue to next input
+        if (issuance.IsNull()) {
+            continue;
+        }
+
+        CAsset assetID;
+        CAsset assetTokenID;
+
+        // First construct the assets of the issuances and reissuance token
+        // These are calculated differently depending on if initial issuance or followup
+
+        // New issuance, compute the asset ids
+        if (issuance.assetBlindingNonce.IsNull()) {
+            uint256 entropy;
+            GenerateAssetEntropy(entropy, tx.vin[i].prevout, issuance.assetEntropy);
+            CalculateAsset(assetID, entropy);
+            // Null nAmount is considered explicit 0, so just check for commitment
+            CalculateReissuanceToken(assetTokenID, entropy, issuance.nAmount.IsCommitment());
+        } else {
+        // Re-issuance
+            // hashAssetIdentifier doubles as the entropy on reissuance
+            CalculateAsset(assetID, issuance.assetEntropy);
+            CalculateReissuanceToken(assetTokenID, issuance.assetEntropy, issuance.nAmount.IsCommitment());
+
+            // Must check that prevout is the blinded issuance token
+            // prevout's asset tag = assetTokenID + assetBlindingNonce
+            if (secp256k1_generator_generate_blinded(secp256k1_ctx_verify_amounts, &gen, assetTokenID.begin(), issuance.assetBlindingNonce.begin()) != 1) {
+                return false;
+            }
+            // Serialize the generator for direct comparison
+            unsigned char derived_generator[33];
+            secp256k1_generator_serialize(secp256k1_ctx_verify_amounts, derived_generator, &gen);
+
+            // Belt-and-suspenders: Check that asset commitment from issuance input is correct size
+            if (asset.vchCommitment.size() != sizeof(derived_generator)) {
+                return false;
+            }
+
+            // We have already checked the outputs' generator commitment for general validity, so directly compare serialized bytes
+            if (memcmp(asset.vchCommitment.data(), derived_generator, sizeof(derived_generator))) {
+                return false;
+            }
+        }
+
+        // Process issuance of asset
+
+        if (!issuance.nAmount.IsValid()) {
+            return false;
+        }
+        if (!issuance.nAmount.IsNull()) {
+            // Note: This check disallows issuances in transactions with *no* witness data.
+            // This can be relaxed in a future update as a HF by passing in an empty rangeproof
+            // to `VerifyIssuanceAmount` instead.
+            if (i >= tx.witness.vtxinwit.size()) {
+                return false;
+            }
+            if (!VerifyIssuanceAmount(commit, gen, assetID, issuance.nAmount, tx.witness.vtxinwit[i].vchIssuanceAmountRangeproof, checks, store_result)) {
+                return false;
+            }
+            target_generators.push_back(gen);
+            vData.push_back(commit);
+            vpCommitsIn.push_back(p);
+            p++;
+        }
+
+        // Process issuance of reissuance tokens
+
+        if (!issuance.nInflationKeys.IsValid()) {
+            return false;
+        }
+        if (!issuance.nInflationKeys.IsNull()) {
+            // Only initial issuance can have reissuance tokens
+            if (!issuance.assetBlindingNonce.IsNull()) {
+                return false;
+            }
+
+            // Note: This check disallows issuances in transactions with *no* witness data.
+            // This can be relaxed in a future update as a HF by passing in an empty rangeproof
+            // to `VerifyIssuanceAmount` instead.
+            if (i >= tx.witness.vtxinwit.size()) {
+                return false;
+            }
+            if (!VerifyIssuanceAmount(commit, gen, assetTokenID, issuance.nInflationKeys, tx.witness.vtxinwit[i].vchInflationKeysRangeproof, checks, store_result)) {
+                return false;
+            }
+            target_generators.push_back(gen);
+            vData.push_back(commit);
+            vpCommitsIn.push_back(p);
+            p++;
+        }
+    }
+
+    for (size_t i = 0; i < tx.vout.size(); ++i)
+    {
+        const CConfidentialValue& val = tx.vout[i].nValue;
+        const CConfidentialAsset& asset = tx.vout[i].nAsset;
+        if (!asset.IsValid())
+            return false;
+        if (!val.IsValid())
+            return false;
+        if (!tx.vout[i].nNonce.IsValid())
+            return false;
+
+        if (asset.IsExplicit()) {
+            ret = secp256k1_generator_generate(secp256k1_ctx_verify_amounts, &gen, asset.GetAsset().begin());
+            assert(ret != 0);
+        }
+        else if (asset.IsCommitment()) {
+            if (secp256k1_generator_parse(secp256k1_ctx_verify_amounts, &gen, &asset.vchCommitment[0]) != 1)
+                return false;
+        }
+        else {
+            return false;
+        }
+
+        if (val.IsExplicit()) {
+            if (!MoneyRange(val.GetAmount()))
+                return false;
+
+            if (val.GetAmount() == 0) {
+                if (tx.vout[i].scriptPubKey.IsUnspendable()) {
+                    continue;
+                } else {
+                    // No spendable 0-value outputs
+                    // Reason: A spendable output of 0 reissuance tokens would allow reissuance without reissuance tokens.
+                    return false;
+                }
+            }
+
+            ret = secp256k1_pedersen_commit(secp256k1_ctx_verify_amounts, &commit, explicit_blinds, val.GetAmount(), &gen);
+            // The explicit_blinds are all 0, and the amount is not 0. So secp256k1_pedersen_commit does not fail.
+            assert(ret == 1);
+        }
+        else if (val.IsCommitment()) {
+            if (secp256k1_pedersen_commitment_parse(secp256k1_ctx_verify_amounts, &commit, &val.vchCommitment[0]) != 1)
+                return false;
+        } else {
+            return false;
+        }
+
+        vData.push_back(commit);
+        vpCommitsOut.push_back(p);
+        p++;
+    }
+
+    // Check balance
+    if (QueueCheck(checks, new CBalanceCheck(vData, vpCommitsIn, vpCommitsOut)) != SCRIPT_ERR_OK) {
+        return false;
+    }
+
+    // Range proofs
+    for (size_t i = 0; i < tx.vout.size(); i++) {
+        const CConfidentialValue& val = tx.vout[i].nValue;
+        const CConfidentialAsset& asset = tx.vout[i].nAsset;
+        std::vector<unsigned char> vchAssetCommitment = asset.vchCommitment;
+        const CTxOutWitness* ptxoutwit = tx.witness.vtxoutwit.size() <= i? NULL: &tx.witness.vtxoutwit[i];
+        if (val.IsExplicit())
+        {
+            if (ptxoutwit && !ptxoutwit->vchRangeproof.empty())
+                return false;
+            continue;
+        }
+        if (asset.IsExplicit()) {
+            int ret = secp256k1_generator_generate(secp256k1_ctx_verify_amounts, &gen, asset.GetAsset().begin());
+            assert(ret != 0);
+            secp256k1_generator_serialize(secp256k1_ctx_verify_amounts, &vchAssetCommitment[0], &gen);
+        }
+        if (!ptxoutwit) {
+            return false;
+        }
+        if (QueueCheck(checks, new CRangeCheck(&val, ptxoutwit->vchRangeproof, vchAssetCommitment, tx.vout[i].scriptPubKey, store_result)) != SCRIPT_ERR_OK) {
+            return false;
+        }
+    }
+
+    // Surjection proofs
+    for (size_t i = 0; i < tx.vout.size(); i++)
+    {
+        const CConfidentialAsset& asset = tx.vout[i].nAsset;
+        const CTxOutWitness* ptxoutwit = tx.witness.vtxoutwit.size() <= i? NULL: &tx.witness.vtxoutwit[i];
+        // No need for surjection proof
+        if (asset.IsExplicit()) {
+            if (ptxoutwit && !ptxoutwit->vchSurjectionproof.empty()) {
+                return false;
+            }
+            continue;
+        }
+        if (!ptxoutwit)
+            return false;
+        if (secp256k1_generator_parse(secp256k1_ctx_verify_amounts, &gen, &asset.vchCommitment[0]) != 1)
+            return false;
+
+        secp256k1_surjectionproof proof;
+        if (secp256k1_surjectionproof_parse(secp256k1_ctx_verify_amounts, &proof, &ptxoutwit->vchSurjectionproof[0], ptxoutwit->vchSurjectionproof.size()) != 1)
+            return false;
+
+        if (QueueCheck(checks, new CSurjectionCheck(proof, target_generators, gen, wtxid, store_result)) != SCRIPT_ERR_OK) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+bool VerifyCoinbaseAmount(const CTransaction& tx, const CAmountMap& mapFees) {
+    assert(tx.IsCoinBase());
+    CAmountMap remaining = mapFees;
+    for (unsigned int i = 0; i < tx.vout.size(); i++) {
+        const CTxOut& out = tx.vout[i];
+        if (!out.nValue.IsExplicit() || !out.nAsset.IsExplicit()) {
+            return false;
+        }
+        if (!MoneyRange(out.nValue.GetAmount())) {
+            return false;
+        }
+        if (g_con_elementsmode &&
+                out.nValue.GetAmount() == 0 && !out.scriptPubKey.IsUnspendable()) {
+            return false;
+        }
+        remaining[out.nAsset.GetAsset()] -= out.nValue.GetAmount();
+    }
+    return MoneyRange(remaining);
+}
diff --git a/src/confidential_validation.h b/src/confidential_validation.h
new file mode 100644
index 0000000000000..5a667a89e3d93
--- /dev/null
+++ b/src/confidential_validation.h
@@ -0,0 +1,97 @@
+
+#ifndef BITCOIN_CONFIDENTIAL_VALIDATION_H
+#define BITCOIN_CONFIDENTIAL_VALIDATION_H
+
+#include <amount.h>
+#include <asset.h>
+#include <coins.h>
+#include <primitives/confidential.h>
+#include <primitives/transaction.h>
+#include <script/script_error.h>
+#include <secp256k1.h>
+#include <secp256k1_rangeproof.h>
+#include <secp256k1_surjectionproof.h>
+#include <uint256.h>
+
+
+// Check if explicit TX fees overflow or are negative
+bool HasValidFee(const CTransaction& tx);
+
+// Compute the fee from the explicit fee outputs. Must call HasValidFee first
+CAmountMap GetFeeMap(const CTransaction& tx);
+
+/**
+ * ELEMENTS:
+ * Closure representing one verification, either script or range checks.
+ * Note that this stores references to the spending transaction
+ */
+class CCheck
+ {
+ protected:
+     ScriptError error;
+
+ public:
+     CCheck() : error(SCRIPT_ERR_UNKNOWN_ERROR) {}
+     virtual ~CCheck() {}
+
+     virtual bool operator()() = 0;
+
+     ScriptError GetScriptError() const { return error; }
+};
+
+/** Closure representing one output range check. */
+class CRangeCheck : public CCheck
+{
+private:
+    const CConfidentialValue* val;
+    const std::vector<unsigned char>& rangeproof;
+    // *Must* be a commitment, not an explicit value
+    const std::vector<unsigned char> assetCommitment;
+    const CScript scriptPubKey;
+    const bool store;
+
+public:
+    CRangeCheck(const CConfidentialValue* val_, const std::vector<unsigned char>& rangeproof_, const std::vector<unsigned char>& assetCommitment_, const CScript& scriptPubKey_, const bool storeIn) : val(val_), rangeproof(rangeproof_), assetCommitment(assetCommitment_), scriptPubKey(scriptPubKey_), store(storeIn) {}
+
+    bool operator()();
+};
+
+/** Closure representing a transaction amount balance check. */
+class CBalanceCheck : public CCheck
+{
+private:
+    std::vector<secp256k1_pedersen_commitment> vData;
+    std::vector<secp256k1_pedersen_commitment *> vpCommitsIn, vpCommitsOut;
+
+public:
+    CBalanceCheck(std::vector<secp256k1_pedersen_commitment>& vData_, std::vector<secp256k1_pedersen_commitment*>& vpCommitsIn_, std::vector<secp256k1_pedersen_commitment*>& vpCommitsOut_)  {
+        vData.swap(vData_);
+        vpCommitsIn.swap(vpCommitsIn_);
+        vpCommitsOut.swap(vpCommitsOut_);
+    }
+
+    bool operator()();
+};
+
+class CSurjectionCheck : public CCheck
+{
+private:
+    secp256k1_surjectionproof proof;
+    std::vector<secp256k1_generator> vTags;
+    secp256k1_generator gen;
+    uint256 wtxid;
+    const bool store;
+public:
+    CSurjectionCheck(secp256k1_surjectionproof& proof_in, std::vector<secp256k1_generator>& tags_in, secp256k1_generator& gen_in, uint256& wtxid_in, const bool store_in) : proof(proof_in), vTags(tags_in), gen(gen_in), wtxid(wtxid_in), store(store_in) {}
+
+    bool operator()();
+};
+
+ScriptError QueueCheck(std::vector<CCheck*>* queue, CCheck* check);
+
+bool VerifyAmounts(const std::vector<CTxOut>& inputs, const CTransaction& tx, std::vector<CCheck*>* pvChecks, const bool cacheStore);
+
+bool VerifyCoinbaseAmount(const CTransaction& tx, const CAmountMap& mapFees);
+
+
+#endif // BITCOIN_CONFIDENTIAL_VALIDATION_H
diff --git a/src/consensus/merkle.cpp b/src/consensus/merkle.cpp
index 4d7df48f242a0..e38d8dcdf4fab 100644
--- a/src/consensus/merkle.cpp
+++ b/src/consensus/merkle.cpp
@@ -77,13 +77,17 @@ uint256 BlockWitnessMerkleRoot(const CBlock& block, bool* mutated)
 {
     std::vector<uint256> leaves;
     leaves.resize(block.vtx.size());
-    leaves[0].SetNull(); // The witness hash of the coinbase is 0.
-    for (size_t s = 1; s < block.vtx.size(); s++) {
-        if (g_con_elementswitness) {
+    if (g_con_elementsmode) {
+        // Coinbase witness hash for inputs is just CTxInWitness().GetHash()
+        for (size_t s = 0; s < block.vtx.size(); s++) {
             leaves[s] = block.vtx[s]->GetWitnessOnlyHash();
-        } else {
+        }
+        return ComputeFastMerkleRoot(std::move(leaves));
+    } else {
+        leaves[0].SetNull(); // The witness hash of the coinbase is 0.
+        for (size_t s = 1; s < block.vtx.size(); s++) {
             leaves[s] = block.vtx[s]->GetWitnessHash();
         }
+        return ComputeMerkleRoot(std::move(leaves), mutated);
     }
-    return ComputeMerkleRoot(std::move(leaves), mutated);
 }
diff --git a/src/consensus/params.h b/src/consensus/params.h
index e762402c9ead4..dfe19b5ac84fd 100644
--- a/src/consensus/params.h
+++ b/src/consensus/params.h
@@ -6,6 +6,7 @@
 #ifndef BITCOIN_CONSENSUS_PARAMS_H
 #define BITCOIN_CONSENSUS_PARAMS_H
 
+#include <asset.h>
 #include <uint256.h>
 #include <limits>
 #include <map>
@@ -83,6 +84,7 @@ struct Params {
     // ELEMENTS CHAIN PARAMS
     CScript mandatory_coinbase_destination;
     CAmount genesis_subsidy;
+    CAsset subsidy_asset;
     bool connect_genesis_outputs;
     bool has_parent_chain;
     uint256 parentChainPowLimit;
@@ -90,6 +92,8 @@ struct Params {
     CScript parent_chain_signblockscript;
     bool ParentChainHasPow() const { return parent_chain_signblockscript == CScript();}
     CScript fedpegScript;
+    CAsset pegged_asset;
+    CAsset parent_pegged_asset;
     // g_con_blockheightinheader global hack instead of proper arg due to circular dep
     std::string genesis_style;
     CScript signblockscript;
diff --git a/src/consensus/tx_verify.cpp b/src/consensus/tx_verify.cpp
index 5fbf5153d3472..d3a711d3e1b6e 100644
--- a/src/consensus/tx_verify.cpp
+++ b/src/consensus/tx_verify.cpp
@@ -190,15 +190,19 @@ bool CheckTransaction(const CTransaction& tx, CValidationState &state, bool fChe
         return state.DoS(100, false, REJECT_INVALID, "bad-txns-oversize");
 
     // Check for negative or overflow output values
-    CAmount nValueOut = 0;
+    CAmount nValueOutExplicit = 0;
     for (const auto& txout : tx.vout)
     {
-        if (txout.nValue < 0)
+        if (!txout.nValue.IsValid())
+            return state.DoS(100, false, REJECT_INVALID, "bad-txns-vout-amount-invalid");
+        if (!txout.nValue.IsExplicit())
+            continue;
+        if (txout.nValue.GetAmount() < 0)
             return state.DoS(100, false, REJECT_INVALID, "bad-txns-vout-negative");
-        if (txout.nValue > MAX_MONEY)
+        if (txout.nValue.GetAmount() > MAX_MONEY)
             return state.DoS(100, false, REJECT_INVALID, "bad-txns-vout-toolarge");
-        nValueOut += txout.nValue;
-        if (!MoneyRange(nValueOut))
+        nValueOutExplicit += txout.nValue.GetAmount();
+        if (!MoneyRange(nValueOutExplicit))
             return state.DoS(100, false, REJECT_INVALID, "bad-txns-txouttotal-toolarge");
     }
 
@@ -216,6 +220,12 @@ bool CheckTransaction(const CTransaction& tx, CValidationState &state, bool fChe
     {
         if (tx.vin[0].scriptSig.size() < 2 || tx.vin[0].scriptSig.size() > 100)
             return state.DoS(100, false, REJECT_INVALID, "bad-cb-length");
+
+        for (unsigned int i = 0; i < tx.vout.size(); i++) {
+            if (tx.vout[i].IsFee()) {
+                return state.DoS(100, false, REJECT_INVALID, "bad-cb-fee");
+            }
+        }
     }
     else
     {
@@ -228,7 +238,7 @@ bool CheckTransaction(const CTransaction& tx, CValidationState &state, bool fChe
 }
 
 namespace Consensus {
-bool CheckTxInputs(const CTransaction& tx, CValidationState& state, const CCoinsViewCache& inputs, int nSpendHeight, CAmount& txfee, std::set<std::pair<uint256, COutPoint>>& setPeginsSpent)
+bool CheckTxInputs(const CTransaction& tx, CValidationState& state, const CCoinsViewCache& inputs, int nSpendHeight, CAmountMap& fee_map, std::set<std::pair<uint256, COutPoint>>& setPeginsSpent, std::vector<CCheck*> *pvChecks, const bool cacheStore, bool fScriptChecks)
 {
     // are the actual inputs available?
     if (!inputs.HaveInputs(tx)) {
@@ -236,6 +246,7 @@ bool CheckTxInputs(const CTransaction& tx, CValidationState& state, const CCoins
                          strprintf("%s: inputs missing/spent", __func__));
     }
 
+    std::vector<CTxOut> spent_inputs;
     CAmount nValueIn = 0;
     for (unsigned int i = 0; i < tx.vin.size(); ++i) {
         const COutPoint &prevout = tx.vin[i].prevout;
@@ -243,7 +254,7 @@ bool CheckTxInputs(const CTransaction& tx, CValidationState& state, const CCoins
             // Check existence and validity of pegin witness
             std::string err;
             if (tx.witness.vtxinwit.size() <= i || !IsValidPeginWitness(tx.witness.vtxinwit[i].m_pegin_witness, prevout, err, true)) {
-                return state.DoS(0, false, REJECT_PEGIN, "bad-pegin-witness");
+                return state.DoS(0, false, REJECT_PEGIN, "bad-pegin-witness", false, err);
             }
             std::pair<uint256, COutPoint> pegin = std::make_pair(uint256(tx.witness.vtxinwit[i].m_pegin_witness.stack[2]), prevout);
             if (inputs.IsPeginSpent(pegin)) {
@@ -256,11 +267,12 @@ bool CheckTxInputs(const CTransaction& tx, CValidationState& state, const CCoins
             setPeginsSpent.insert(pegin);
 
             // Tally the input amount.
-            const CTxOut out = GetPeginOutputFromWitness(tx.witness.vtxinwit[i].m_pegin_witness);
-            if (!MoneyRange(out.nValue)) {
+            spent_inputs.push_back(GetPeginOutputFromWitness(tx.witness.vtxinwit[i].m_pegin_witness));
+            const CTxOut& out = spent_inputs.back();
+            nValueIn += out.nValue.GetAmount(); // Non-explicit already filtered by IsValidPeginWitness
+            if (!MoneyRange(out.nValue.GetAmount())) {
                 return state.DoS(100, false, REJECT_INVALID, "bad-txns-pegin-inputvalue-outofrange");
             }
-            nValueIn += out.nValue;
         } else {
             const Coin& coin = inputs.AccessCoin(prevout);
             assert(!coin.IsSpent());
@@ -271,29 +283,40 @@ bool CheckTxInputs(const CTransaction& tx, CValidationState& state, const CCoins
                     REJECT_INVALID, "bad-txns-premature-spend-of-coinbase",
                     strprintf("tried to spend coinbase at depth %d", nSpendHeight - coin.nHeight));
             }
-
-            // Check for negative or overflow input values
-            nValueIn += coin.out.nValue;
-            if (!MoneyRange(coin.out.nValue) || !MoneyRange(nValueIn)) {
-                return state.DoS(100, false, REJECT_INVALID, "bad-txns-inputvalues-outofrange");
+            spent_inputs.push_back(coin.out);
+            if (coin.out.nValue.IsExplicit()) {
+                nValueIn += coin.out.nValue.GetAmount();
             }
         }
     }
 
-    //TODO(rebase) you need to replace these two blocks with the `VerifyAmounts` and `HasValidFee` methods
-    const CAmount value_out = tx.GetValueOut();
-    if (nValueIn < value_out) {
-        return state.DoS(100, false, REJECT_INVALID, "bad-txns-in-belowout", false,
-            strprintf("value in (%s) < value out (%s)", FormatMoney(nValueIn), FormatMoney(value_out)));
-    }
+    if (g_con_elementsmode) {
+        // Tally transaction fees
+        if (!HasValidFee(tx)) {
+            return state.DoS(100, false, REJECT_INVALID, "bad-txns-fee-outofrange");
+        }
+
+        // Verify that amounts add up.
+        if (fScriptChecks && !VerifyAmounts(spent_inputs, tx, pvChecks, cacheStore)) {
+            return state.DoS(100, false, REJECT_INVALID, "bad-txns-in-ne-out", false, "value in != value out");
+        }
+        fee_map += GetFeeMap(tx);
+    } else {
+        const CAmount value_out = tx.GetValueOutMap()[CAsset()];
+        if (nValueIn < value_out) {
+            return state.DoS(100, false, REJECT_INVALID, "bad-txns-in-belowout", false,
+                strprintf("value in (%s) < value out (%s)", FormatMoney(nValueIn), FormatMoney(value_out)));
+        }
+
+        // Tally transaction fees
+        const CAmount txfee_aux = nValueIn - value_out;
+        if (!MoneyRange(txfee_aux)) {
+            return state.DoS(100, false, REJECT_INVALID, "bad-txns-fee-outofrange");
+        }
 
-    // Tally transaction fees
-    const CAmount txfee_aux = nValueIn - value_out;
-    if (!MoneyRange(txfee_aux)) {
-        return state.DoS(100, false, REJECT_INVALID, "bad-txns-fee-outofrange");
+        fee_map[CAsset()] += txfee_aux;
     }
 
-    txfee = txfee_aux;
     return true;
 }
 }// namespace Consensus
diff --git a/src/consensus/tx_verify.h b/src/consensus/tx_verify.h
index 2830535fdcd26..767531e88e7cf 100644
--- a/src/consensus/tx_verify.h
+++ b/src/consensus/tx_verify.h
@@ -7,6 +7,7 @@
 
 #include <amount.h>
 
+#include <confidential_validation.h>
 #include <set>
 #include <stdint.h>
 #include <vector>
@@ -27,10 +28,10 @@ namespace Consensus {
 /**
  * Check whether all inputs of this transaction are valid (no double spends and amounts)
  * This does not modify the UTXO set. This does not check scripts and sigs.
- * @param[out] txfee Set to the transaction fee if successful.
+ * @param[out] fee_map Set to the transaction fee if successful.
  * Preconditions: tx.IsCoinBase() is false.
  */
-bool CheckTxInputs(const CTransaction& tx, CValidationState& state, const CCoinsViewCache& inputs, int nSpendHeight, CAmount& txfee, std::set<std::pair<uint256, COutPoint>>& setPeginsSpent);
+bool CheckTxInputs(const CTransaction& tx, CValidationState& state, const CCoinsViewCache& inputs, int nSpendHeight, CAmountMap& fee_map, std::set<std::pair<uint256, COutPoint>>& setPeginsSpent, std::vector<CCheck*> *pvChecks, const bool cacheStore, bool fScriptChecks);
 } // namespace Consensus
 
 /** Auxiliary functions for transaction validation (ideally should not be exposed) */
diff --git a/src/consensus/validation.h b/src/consensus/validation.h
index 8c1fa5cdbb478..70d9fd2a07901 100644
--- a/src/consensus/validation.h
+++ b/src/consensus/validation.h
@@ -108,11 +108,14 @@ static inline int64_t GetTransactionInputWeight(const CTransaction& tx, const si
 {
     // scriptWitness size is added here because witnesses and txins are split up in segwit serialization.
     assert(tx.witness.vtxinwit.size() > nIn);
-    //TODO(rebase) only count CA/CT witnesses when g_con_elementswitness is true
+    // ELEMENTS: This is only used for change size calculation in wallet, assert if
+    // anything is unexpected for this call e.g. issuances, rangeproofs
+    assert(tx.witness.vtxinwit[nIn].vchIssuanceAmountRangeproof.empty());
+    assert(tx.witness.vtxinwit[nIn].vchInflationKeysRangeproof.empty());
+
     return ::GetSerializeSize(tx.vin[nIn], PROTOCOL_VERSION | SERIALIZE_TRANSACTION_NO_WITNESS) * (WITNESS_SCALE_FACTOR - 1)
     + ::GetSerializeSize(tx.vin[nIn], PROTOCOL_VERSION)
-    + ::GetSerializeSize(tx.witness.vtxinwit[nIn].scriptWitness.stack, PROTOCOL_VERSION)
-    + ::GetSerializeSize(tx.witness.vtxinwit[nIn].m_pegin_witness.stack, PROTOCOL_VERSION);
+    + ::GetSerializeSize(tx.witness.vtxinwit[nIn].scriptWitness.stack, PROTOCOL_VERSION);
 }
 
 #endif // BITCOIN_CONSENSUS_VALIDATION_H
diff --git a/src/core_io.h b/src/core_io.h
index d53a45c0cb80d..a10d748217ace 100644
--- a/src/core_io.h
+++ b/src/core_io.h
@@ -6,6 +6,7 @@
 #define BITCOIN_CORE_IO_H
 
 #include <amount.h>
+#include <asset.h>
 
 #include <string>
 #include <vector>
diff --git a/src/core_write.cpp b/src/core_write.cpp
index c48130ecde03f..49be842f3b7fd 100644
--- a/src/core_write.cpp
+++ b/src/core_write.cpp
@@ -6,6 +6,7 @@
 
 #include <consensus/consensus.h>
 #include <consensus/validation.h>
+#include <issuance.h>
 #include <key_io.h>
 #include <script/script.h>
 #include <script/standard.h>
@@ -16,6 +17,32 @@
 #include <utilmoneystr.h>
 #include <utilstrencodings.h>
 
+#include <secp256k1_rangeproof.h>
+
+static secp256k1_context* secp256k1_blind_context = NULL;
+
+class RPCRawTransaction_ECC_Init {
+public:
+    RPCRawTransaction_ECC_Init() {
+        assert(secp256k1_blind_context == NULL);
+
+        secp256k1_context *ctx = secp256k1_context_create(SECP256K1_CONTEXT_NONE);
+        assert(ctx != NULL);
+
+        secp256k1_blind_context = ctx;
+    }
+
+    ~RPCRawTransaction_ECC_Init() {
+        secp256k1_context *ctx = secp256k1_blind_context;
+        secp256k1_blind_context = NULL;
+
+        if (ctx) {
+            secp256k1_context_destroy(ctx);
+        }
+    }
+};
+static RPCRawTransaction_ECC_Init ecc_init_on_load;
+
 UniValue ValueFromAmount(const CAmount& amount)
 {
     bool sign = amount < 0;
@@ -200,7 +227,7 @@ void TxToUniv(const CTransaction& tx, const uint256& hashBlock, UniValue& entry,
 {
     entry.pushKV("txid", tx.GetHash().GetHex());
     entry.pushKV("hash", tx.GetWitnessHash().GetHex());
-    if (g_con_elementswitness) {
+    if (g_con_elementsmode) {
         entry.pushKV("wtxid", tx.GetWitnessHash().GetHex());
         entry.pushKV("withash", tx.GetWitnessOnlyHash().GetHex());
     }
@@ -223,29 +250,65 @@ void TxToUniv(const CTransaction& tx, const uint256& hashBlock, UniValue& entry,
             o.pushKV("asm", ScriptToAsmStr(txin.scriptSig, true));
             o.pushKV("hex", HexStr(txin.scriptSig.begin(), txin.scriptSig.end()));
             in.pushKV("scriptSig", o);
+            in.pushKV("is_pegin", txin.m_is_pegin);
+        }
+        in.pushKV("sequence", (int64_t)txin.nSequence);
 
-            if (tx.witness.vtxinwit.size() > i) {
-                const CScriptWitness &scriptWitness = tx.witness.vtxinwit[i].scriptWitness;
-                if (!scriptWitness.IsNull()) {
-                    UniValue txinwitness(UniValue::VARR);
-                    for (const auto &item : scriptWitness.stack) {
-                        txinwitness.push_back(HexStr(item.begin(), item.end()));
-                    }
-                    in.pushKV("txinwitness", txinwitness);
+        if (tx.witness.vtxinwit.size() > i) {
+            const CScriptWitness &scriptWitness = tx.witness.vtxinwit[i].scriptWitness;
+            if (!scriptWitness.IsNull()) {
+                UniValue txinwitness(UniValue::VARR);
+                for (const auto &item : scriptWitness.stack) {
+                    txinwitness.push_back(HexStr(item.begin(), item.end()));
                 }
+                in.pushKV("txinwitness", txinwitness);
             }
+        }
 
-            // ELEMENTS:
-            in.pushKV("is_pegin", txin.m_is_pegin);
-            if (tx.witness.vtxinwit.size() > i && !tx.witness.vtxinwit[i].m_pegin_witness.IsNull()) {
-                UniValue pegin_witness(UniValue::VARR);
-                for (const auto& item : tx.witness.vtxinwit[i].m_pegin_witness.stack) {
-                    pegin_witness.push_back(HexStr(item.begin(), item.end()));
-                }
-                in.pushKV("pegin_witness", pegin_witness);
+        // ELEMENTS:
+        if (tx.witness.vtxinwit.size() > i && !tx.witness.vtxinwit[i].m_pegin_witness.IsNull()) {
+            UniValue pegin_witness(UniValue::VARR);
+            for (const auto& item : tx.witness.vtxinwit[i].m_pegin_witness.stack) {
+                pegin_witness.push_back(HexStr(item.begin(), item.end()));
             }
+            in.pushKV("pegin_witness", pegin_witness);
         }
-        in.pushKV("sequence", (int64_t)txin.nSequence);
+        const CAssetIssuance& issuance = txin.assetIssuance;
+        if (!issuance.IsNull()) {
+            UniValue issue(UniValue::VOBJ);
+            issue.pushKV("assetBlindingNonce", issuance.assetBlindingNonce.GetHex());
+            CAsset asset;
+            CAsset token;
+            uint256 entropy;
+            if (issuance.assetBlindingNonce.IsNull()) {
+                GenerateAssetEntropy(entropy, txin.prevout, issuance.assetEntropy);
+                issue.pushKV("assetEntropy", entropy.GetHex());
+                CalculateAsset(asset, entropy);
+                CalculateReissuanceToken(token, entropy, issuance.nAmount.IsCommitment());
+                issue.pushKV("isreissuance", false);
+                issue.pushKV("token", token.GetHex());
+            }
+            else {
+                issue.pushKV("assetEntropy", issuance.assetEntropy.GetHex());
+                issue.pushKV("isreissuance", true);
+                CalculateAsset(asset, issuance.assetEntropy);
+            }
+            issue.pushKV("asset", asset.GetHex());
+
+            if (issuance.nAmount.IsExplicit()) {
+                issue.pushKV("assetamount", ValueFromAmount(issuance.nAmount.GetAmount()));
+            } else if (issuance.nAmount.IsCommitment()) {
+                issue.pushKV("assetamountcommitment", HexStr(issuance.nAmount.vchCommitment));
+            }
+            if (issuance.nInflationKeys.IsExplicit()) {
+                issue.pushKV("tokenamount", ValueFromAmount(issuance.nInflationKeys.GetAmount()));
+            } else if (issuance.nInflationKeys.IsCommitment()) {
+                issue.pushKV("tokenamountcommitment", HexStr(issuance.nInflationKeys.vchCommitment));
+            }
+            in.pushKV("issuance", issue);
+        }
+        // END ELEMENTS
+
         vin.push_back(in);
     }
     entry.pushKV("vin", vin);
@@ -256,7 +319,37 @@ void TxToUniv(const CTransaction& tx, const uint256& hashBlock, UniValue& entry,
 
         UniValue out(UniValue::VOBJ);
 
-        out.pushKV("value", ValueFromAmount(txout.nValue));
+        if (txout.nValue.IsExplicit()) {
+            out.pushKV("value", ValueFromAmount(txout.nValue.GetAmount()));
+        } else {
+            int exp;
+            int mantissa;
+            uint64_t minv;
+            uint64_t maxv;
+            const CTxOutWitness* ptxoutwit = tx.witness.vtxoutwit.size() <= i? NULL: &tx.witness.vtxoutwit[i];
+            if (ptxoutwit && secp256k1_rangeproof_info(secp256k1_blind_context, &exp, &mantissa, &minv, &maxv, &ptxoutwit->vchRangeproof[0], ptxoutwit->vchRangeproof.size())) {
+                if (exp == -1) {
+                    out.pushKV("value", ValueFromAmount((CAmount)minv));
+                } else {
+                    out.pushKV("value-minimum", ValueFromAmount((CAmount)minv));
+                    out.pushKV("value-maximum", ValueFromAmount((CAmount)maxv));
+                }
+                out.pushKV("ct-exponent", exp);
+                out.pushKV("ct-bits", mantissa);
+            }
+            out.pushKV("valuecommitment", txout.nValue.GetHex());
+        }
+        if (g_con_elementsmode) {
+            if (txout.nAsset.IsExplicit()) {
+                out.pushKV("asset", txout.nAsset.GetAsset().GetHex());
+            } else {
+                out.pushKV("assetcommitment", txout.nAsset.GetHex());
+            }
+
+            out.pushKV("commitmentnonce", txout.nNonce.GetHex());
+            CPubKey pubkey(txout.nNonce.vchCommitment);
+            out.pushKV("commitmentnonce_fully_valid", pubkey.IsFullyValid());
+        }
         out.pushKV("n", (int64_t)i);
 
         UniValue o(UniValue::VOBJ);
diff --git a/src/init.cpp b/src/init.cpp
index 4e6d376a24e5b..15782717107ca 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -64,6 +64,8 @@
 #include <openssl/crypto.h>
 
 #include <primitives/pak.h> // CPAKList
+#include <assetsdir.h> // InitGlobalAssetDir
+#include <pegins.h>
 
 #if ENABLE_ZMQ
 #include <zmq/zmqnotificationinterface.h>
@@ -508,6 +510,11 @@ void SetupServerArgs()
     gArgs.AddArg("-extpubkeyprefix", strprintf("The 4-byte prefix, in hex, of the chain's base58 extended public key encoding. (default: %s)", HexStr(defaultChainParams->Base58Prefix(CChainParams::EXT_PUBLIC_KEY))), false, OptionsCategory::CHAINPARAMS);
     gArgs.AddArg("-extprvkeyprefix", strprintf("The 4-byte prefix, in hex, of the chain's base58 extended private key encoding. (default: %s)", HexStr(defaultChainParams->Base58Prefix(CChainParams::EXT_SECRET_KEY))), false, OptionsCategory::CHAINPARAMS);
     gArgs.AddArg("-bech32_hrp", strprintf("The human-readable part of the chain's bech32 encoding. (default: %s)", defaultChainParams->Bech32HRP()), false, OptionsCategory::CHAINPARAMS);
+    gArgs.AddArg("-blech32_hrp", strprintf("The human-readable part of the chain's blech32 encoding. Used in confidential addresses.(default: %s)", defaultChainParams->Blech32HRP()), false, OptionsCategory::CHAINPARAMS);
+    gArgs.AddArg("-assetdir", "Entries of pet names of assets, in this format:asset=<hex>:<label>. There can be any number of entries.", false, OptionsCategory::ELEMENTS);
+    gArgs.AddArg("-defaultpeggedassetname", "Default name of the pegged asset. (default: bitcoin)", false, OptionsCategory::ELEMENTS);
+    gArgs.AddArg("-blindedaddresses", "Give blind addresses by default via getnewaddress and getrawchangeaddress. (default: -con_elementsmode value)", false, OptionsCategory::ELEMENTS);
+    gArgs.AddArg("-blindedprefix", "The byte prefix, in decimal, of blinded addresses. (default: 4)", false, OptionsCategory::ELEMENTS);
 
 #if HAVE_DECL_DAEMON
     gArgs.AddArg("-daemon", "Run in the background as a daemon and accept commands", false, OptionsCategory::OPTIONS);
@@ -534,6 +541,13 @@ void SetupServerArgs()
     gArgs.AddArg("-parentpubkeyprefix", strprintf("The byte prefix, in decimal, of the parent chain's base58 pubkey address. (default: %d)", 111), false, OptionsCategory::CHAINPARAMS);
     gArgs.AddArg("-parentscriptprefix", strprintf("The byte prefix, in decimal, of the parent chain's base58 script address. (default: %d)", 196), false, OptionsCategory::CHAINPARAMS);
     gArgs.AddArg("-parent_bech32_hrp", strprintf("The human-readable part of the parent chain's bech32 encoding. (default: %s)", "bc"), false, OptionsCategory::CHAINPARAMS);
+    gArgs.AddArg("-parent_blech32_hrp", strprintf("The human-readable part of the parent chain's blech32 encoding. (default: %s)", "bc"), false, OptionsCategory::CHAINPARAMS);
+    gArgs.AddArg("-con_parent_pegged_asset=<hex>", "Asset ID (hex) for pegged asset for when parent chain has CA. (default: 0x00)", false, OptionsCategory::CHAINPARAMS);
+    gArgs.AddArg("-feeasset=<hex>", strprintf("Asset ID (hex) for mempool/relay fees (default: %s)", defaultChainParams->GetConsensus().pegged_asset.GetHex()), false, OptionsCategory::CHAINPARAMS);
+    gArgs.AddArg("-subsidyasset=<hex>", strprintf("Asset ID (hex) for the block subsidy (default: %s)", defaultChainParams->GetConsensus().pegged_asset.GetHex()), false, OptionsCategory::CHAINPARAMS);
+    gArgs.AddArg("-initialreissuancetokens=<n>", "The amount of reissuance tokens created in the genesis block. (default: 0)", false, OptionsCategory::CHAINPARAMS);
+    gArgs.AddArg("-ct_bits", strprintf("The default number of hiding bits in a rangeproof. Will be exceeded to cover amounts exceeding the maximum hiding value. (default: %d)", 36), false, OptionsCategory::CHAINPARAMS);
+    gArgs.AddArg("-ct_exponent", strprintf("The hiding exponent. (default: %s)", 0), false, OptionsCategory::CHAINPARAMS);
 
     // Add the hidden options
     gArgs.AddHiddenArgs(hidden_args);
@@ -1161,6 +1175,13 @@ bool AppInitParameterInteraction()
         }
     }
 
+    try {
+        const std::string default_asset_name = gArgs.GetArg("-defaultpeggedassetname", "bitcoin");
+        InitGlobalAssetDir(gArgs.GetArgs("-assetdir"), default_asset_name);
+    } catch (const std::exception& e) {
+        return InitError(strprintf("Error in -assetdir: %s\n", e.what()));
+    }
+
     return true;
 }
 
@@ -1259,6 +1280,9 @@ bool AppInitMain()
 
     InitSignatureCache();
     InitScriptExecutionCache();
+    InitRangeproofCache();
+    InitSurjectionproofCache();
+
 
     LogPrintf("Using %u threads for script verification\n", nScriptCheckThreads);
     if (nScriptCheckThreads) {
@@ -1282,6 +1306,9 @@ bool AppInitMain()
     RegisterZMQRPCCommands(tableRPC);
 #endif
 
+    // ELEMENTS:
+    policyAsset = CAsset(uint256S(gArgs.GetArg("-feeasset", chainparams.GetConsensus().pegged_asset.GetHex())));
+
     /* Start the RPC server already.  It will be started in "warmup" mode
      * and not really process calls already (but it will signify connections
      * that the server is there and will be ready later).  Warmup mode will
@@ -1820,7 +1847,21 @@ bool AppInitMain()
         }
     }
 
-    // ********************************************************* Step 14: finished
+    // ********************************************************* Step 14: Check fedpeg
+    // ELEMENTS:
+    if (chainparams.GetConsensus().has_parent_chain) {
+        // Will assert if not properly formatted
+        const CScript& fedpeg_script = chainparams.GetConsensus().fedpegScript;
+        unsigned int dummy_required;
+        std::vector<std::vector<unsigned char>> dummy_keys;
+        if (!MatchLiquidWatchman(fedpeg_script) &&
+                fedpeg_script != CScript() << OP_TRUE &&
+                !MatchMultisig(fedpeg_script, dummy_required, dummy_keys)) {
+            return InitError(_("ERROR: Fedpegscript is not one of the accepted templates: OP_TRUE, CHECKMULTISIG, and Liquidv1"));
+        }
+    }
+
+    // ********************************************************* Step 15: finished
 
     SetRPCWarmupFinished();
 
diff --git a/src/interfaces/wallet.cpp b/src/interfaces/wallet.cpp
index 566ae375099a2..74c03c1399851 100644
--- a/src/interfaces/wallet.cpp
+++ b/src/interfaces/wallet.cpp
@@ -31,7 +31,7 @@ namespace {
 class PendingWalletTxImpl : public PendingWalletTx
 {
 public:
-    explicit PendingWalletTxImpl(CWallet& wallet) : m_wallet(wallet), m_key(&wallet) {}
+    explicit PendingWalletTxImpl(CWallet& wallet) : m_wallet(wallet) { m_keys.reserve(1); m_keys.emplace_back(new CReserveKey(&wallet)); }
 
     const CTransaction& get() override { return *m_tx; }
 
@@ -43,7 +43,7 @@ class PendingWalletTxImpl : public PendingWalletTx
     {
         LOCK2(cs_main, m_wallet.cs_wallet);
         CValidationState state;
-        if (!m_wallet.CommitTransaction(m_tx, std::move(value_map), std::move(order_form), m_key, g_connman.get(), state)) {
+        if (!m_wallet.CommitTransaction(m_tx, std::move(value_map), std::move(order_form), m_keys, g_connman.get(), state)) {
             reject_reason = state.GetRejectReason();
             return false;
         }
@@ -52,7 +52,7 @@ class PendingWalletTxImpl : public PendingWalletTx
 
     CTransactionRef m_tx;
     CWallet& m_wallet;
-    CReserveKey m_key;
+    std::vector<std::unique_ptr<CReserveKey>> m_keys;
 };
 
 //! Construct wallet tx struct.
@@ -224,7 +224,7 @@ class WalletImpl : public Wallet
     {
         LOCK2(cs_main, m_wallet.cs_wallet);
         auto pending = MakeUnique<PendingWalletTxImpl>(m_wallet);
-        if (!m_wallet.CreateTransaction(recipients, pending->m_tx, pending->m_key, fee, change_pos,
+        if (!m_wallet.CreateTransaction(recipients, pending->m_tx, pending->m_keys, fee, change_pos,
                 fail_reason, coin_control, sign)) {
             return {};
         }
@@ -355,8 +355,8 @@ class WalletImpl : public Wallet
         num_blocks = ::chainActive.Height();
         return true;
     }
-    CAmount getBalance() override { return m_wallet.GetBalance(); }
-    CAmount getAvailableBalance(const CCoinControl& coin_control) override
+    CAmountMap getBalance() override { return m_wallet.GetBalance(); }
+    CAmountMap getAvailableBalance(const CCoinControl& coin_control) override
     {
         return m_wallet.GetAvailableBalance(&coin_control);
     }
@@ -370,12 +370,12 @@ class WalletImpl : public Wallet
         LOCK2(::cs_main, m_wallet.cs_wallet);
         return m_wallet.IsMine(txout);
     }
-    CAmount getDebit(const CTxIn& txin, isminefilter filter) override
+    CAmountMap getDebit(const CTxIn& txin, isminefilter filter) override
     {
         LOCK2(::cs_main, m_wallet.cs_wallet);
         return m_wallet.GetDebit(txin, filter);
     }
-    CAmount getCredit(const CTxOut& txout, isminefilter filter) override
+    CAmountMap getCredit(const CTxOut& txout, isminefilter filter) override
     {
         LOCK2(::cs_main, m_wallet.cs_wallet);
         return m_wallet.GetCredit(txout, filter);
diff --git a/src/interfaces/wallet.h b/src/interfaces/wallet.h
index 7aa91f37e1084..e9f8d31975f87 100644
--- a/src/interfaces/wallet.h
+++ b/src/interfaces/wallet.h
@@ -6,6 +6,7 @@
 #define BITCOIN_INTERFACES_WALLET_H
 
 #include <amount.h>                    // For CAmount
+#include <asset.h>                     // For CAmountMap
 #include <pubkey.h>                    // For CKeyID and CScriptID (definitions needed in CTxDestination instantiation)
 #include <script/ismine.h>             // For isminefilter, isminetype
 #include <script/standard.h>           // For CTxDestination
@@ -196,10 +197,10 @@ class Wallet
     virtual bool tryGetBalances(WalletBalances& balances, int& num_blocks) = 0;
 
     //! Get balance.
-    virtual CAmount getBalance() = 0;
+    virtual CAmountMap getBalance() = 0;
 
     //! Get available balance.
-    virtual CAmount getAvailableBalance(const CCoinControl& coin_control) = 0;
+    virtual CAmountMap getAvailableBalance(const CCoinControl& coin_control) = 0;
 
     //! Return whether transaction input belongs to wallet.
     virtual isminetype txinIsMine(const CTxIn& txin) = 0;
@@ -208,10 +209,10 @@ class Wallet
     virtual isminetype txoutIsMine(const CTxOut& txout) = 0;
 
     //! Return debit amount if transaction input belongs to wallet.
-    virtual CAmount getDebit(const CTxIn& txin, isminefilter filter) = 0;
+    virtual CAmountMap getDebit(const CTxIn& txin, isminefilter filter) = 0;
 
     //! Return credit amount if transaction input belongs to wallet.
-    virtual CAmount getCredit(const CTxOut& txout, isminefilter filter) = 0;
+    virtual CAmountMap getCredit(const CTxOut& txout, isminefilter filter) = 0;
 
     //! Return AvailableCoins + LockedCoins grouped by wallet address.
     //! (put change in one group with wallet address)
@@ -309,13 +310,13 @@ struct WalletAddress
 //! Collection of wallet balances.
 struct WalletBalances
 {
-    CAmount balance = 0;
-    CAmount unconfirmed_balance = 0;
-    CAmount immature_balance = 0;
+    CAmountMap balance = CAmountMap();
+    CAmountMap unconfirmed_balance = CAmountMap();
+    CAmountMap immature_balance = CAmountMap();
     bool have_watch_only = false;
-    CAmount watch_only_balance = 0;
-    CAmount unconfirmed_watch_only_balance = 0;
-    CAmount immature_watch_only_balance = 0;
+    CAmountMap watch_only_balance = CAmountMap();
+    CAmountMap unconfirmed_watch_only_balance = CAmountMap();
+    CAmountMap immature_watch_only_balance = CAmountMap();
 
     bool balanceChanged(const WalletBalances& prev) const
     {
@@ -334,9 +335,9 @@ struct WalletTx
     std::vector<isminetype> txout_is_mine;
     std::vector<CTxDestination> txout_address;
     std::vector<isminetype> txout_address_is_mine;
-    CAmount credit;
-    CAmount debit;
-    CAmount change;
+    CAmountMap credit;
+    CAmountMap debit;
+    CAmountMap change;
     int64_t time;
     std::map<std::string, std::string> value_map;
     bool is_coinbase;
diff --git a/src/issuance.cpp b/src/issuance.cpp
new file mode 100644
index 0000000000000..abf70610329eb
--- /dev/null
+++ b/src/issuance.cpp
@@ -0,0 +1,82 @@
+
+#include <issuance.h>
+
+#include <primitives/transaction.h>
+#include <amount.h>
+
+void GenerateAssetEntropy(uint256& entropy, const COutPoint& prevout, const uint256& contracthash)
+{
+    // E : entropy
+    // I : prevout
+    // C : contract
+    // E = H( H(I) || H(C) )
+    std::vector<uint256> leaves;
+    leaves.reserve(2);
+    leaves.push_back(SerializeHash(prevout, SER_GETHASH, 0));
+    leaves.push_back(contracthash);
+    entropy = ComputeFastMerkleRoot(leaves);
+}
+
+void CalculateAsset(CAsset& asset, const uint256& entropy)
+{
+    static const uint256 kZero = uint256S("0x0000000000000000000000000000000000000000000000000000000000000000");
+    // H_a : asset tag
+    // E   : entropy
+    // H_a = H( E || 0 )
+    std::vector<uint256> leaves;
+    leaves.reserve(2);
+    leaves.push_back(entropy);
+    leaves.push_back(kZero);
+    asset = CAsset(ComputeFastMerkleRoot(leaves));
+}
+
+void CalculateReissuanceToken(CAsset& reissuanceToken, const uint256& entropy, bool fConfidential)
+{
+    static const uint256 kOne = uint256S("0x0000000000000000000000000000000000000000000000000000000000000001");
+    static const uint256 kTwo = uint256S("0x0000000000000000000000000000000000000000000000000000000000000002");
+    // H_a : asset reissuance tag
+    // E   : entropy
+    // if not fConfidential:
+    //     H_a = H( E || 1 )
+    // else
+    //     H_a = H( E || 2 )
+    std::vector<uint256> leaves;
+    leaves.reserve(2);
+    leaves.push_back(entropy);
+    leaves.push_back(fConfidential ? kTwo : kOne);
+    reissuanceToken = CAsset(ComputeFastMerkleRoot(leaves));
+}
+
+/** Add an issuance transaction to the genesis block. Typically used to pre-issue
+ * the policyAsset of a blockchain. The genesis block is not actually validated,
+ * so this transaction simply has to match issuance structure. */
+void AppendInitialIssuance(CBlock& genesis_block, const COutPoint& prevout, const uint256& contract, const int64_t asset_outputs, const int64_t asset_values, const int64_t reissuance_outputs, const int64_t reissuance_values, const CScript& issuance_destination) {
+    uint256 entropy;
+    GenerateAssetEntropy(entropy, prevout, contract);
+
+    CAsset asset;
+    CalculateAsset(asset, entropy);
+
+    // Re-issuance of policyAsset is always unblinded
+    CAsset reissuance;
+    CalculateReissuanceToken(reissuance, entropy, false);
+
+    // Note: Genesis block isn't actually validated, outputs are entered into utxo db only
+    CMutableTransaction txNew;
+    txNew.nVersion = 1;
+    txNew.vin.resize(1);
+    txNew.vin[0].prevout = prevout;
+    txNew.vin[0].assetIssuance.assetEntropy = contract;
+    txNew.vin[0].assetIssuance.nAmount = CConfidentialValue(asset_values * asset_outputs);
+    txNew.vin[0].assetIssuance.nInflationKeys = CConfidentialValue(reissuance_values * reissuance_outputs);
+
+    for (unsigned int i = 0; i < asset_outputs; i++) {
+        txNew.vout.push_back(CTxOut(asset, CConfidentialValue(asset_values), issuance_destination));
+    }
+    for (unsigned int i = 0; i < reissuance_outputs; i++) {
+        txNew.vout.push_back(CTxOut(reissuance, CConfidentialValue(reissuance_values), issuance_destination));
+    }
+
+    genesis_block.vtx.push_back(MakeTransactionRef(std::move(txNew)));
+    genesis_block.hashMerkleRoot = BlockMerkleRoot(genesis_block);
+}
diff --git a/src/issuance.h b/src/issuance.h
new file mode 100644
index 0000000000000..b64ec8b75a77b
--- /dev/null
+++ b/src/issuance.h
@@ -0,0 +1,48 @@
+
+#ifndef BITCOIN_ISSUANCE_H
+#define BITCOIN_ISSUANCE_H
+
+#include <primitives/transaction.h>
+#include <amount.h>
+#include <hash.h>
+#include <consensus/merkle.h>
+
+/**
+ * Calculate the asset entropy from an COutPoint and a tx-author specified
+ * Ricardian contract. See Definition 18 of the confidential assets paper.
+ *
+ * @param[out]  entropy       The asset entropy, which is used as input to
+ *                            CalculateAsset and CalculateReissuanceToken.
+ * @param[in]   prevout       Reference to the UTXO being spent.
+ * @param[in]   contracthash  Root hash of the issuer-specified Ricardian
+ *                            contract.
+ */
+void GenerateAssetEntropy(uint256& entropy, const COutPoint& prevout, const uint256& contracthash);
+
+/**
+ * Derive the asset from the entropy. See Definition 19 of the confidential
+ * assets paper.
+ *
+ * @param[out]  asset    The nonce used as auxiliary input to the Pedersen
+ *                       commitment setup to derive the unblinded asset tag.
+ * @param[in]   entropy  The asset entropy returned by GenerateAssetEntropy.
+ */
+void CalculateAsset(CAsset& asset, const uint256& entropy);
+
+/**
+ * Derive the asset reissuance token asset from the entropy and reissuance
+ * parameters (confidential or explicit). See Definition 21 of the confidential
+ * assets paper.
+ *
+ * @param[out]  reissuanceToken  The nonce used as auxiliary input to the
+ *                               Pedersen commitment setup to derive the
+ *                               unblinded reissuance asset tag.
+ * @param[in]   entropy          The asset entropy returned by GenerateAssetEntropy.
+ * @param[in]   fConfidential    Set to true if the initial issuance was blinded,
+ *                               false otherwise.
+ */
+void CalculateReissuanceToken(CAsset& reissuanceToken, const uint256& entropy, bool fConfidential);
+
+void AppendInitialIssuance(CBlock& genesis_block, const COutPoint& prevout, const uint256& contract, const int64_t asset_outputs, const int64_t asset_values, const int64_t reissuance_outputs, const int64_t reissuance_values, const CScript& issuance_destination);
+
+#endif // BITCOIN_ISSUANCE_H
diff --git a/src/key.cpp b/src/key.cpp
index 0a89ce36e0686..be1249cfc24e3 100644
--- a/src/key.cpp
+++ b/src/key.cpp
@@ -12,6 +12,7 @@
 
 #include <secp256k1.h>
 #include <secp256k1_recovery.h>
+#include <secp256k1_ecdh.h>
 
 static secp256k1_context* secp256k1_context_sign = nullptr;
 
@@ -202,6 +203,15 @@ bool SigHasLowR(const secp256k1_ecdsa_signature* sig)
     return compact_sig[0] < 0x80;
 }
 
+uint256 CKey::ECDH(const CPubKey& pubkey) const {
+    assert(fValid);
+    uint256 result;
+    secp256k1_pubkey pkey;
+    assert(secp256k1_ec_pubkey_parse(secp256k1_context_sign, &pkey, pubkey.begin(), pubkey.size()));
+    assert(secp256k1_ecdh(secp256k1_context_sign, result.begin(), &pkey, begin(), NULL, NULL));
+    return result;
+}
+
 bool CKey::Sign(const uint256 &hash, std::vector<unsigned char>& vchSig, bool grind, uint32_t test_case) const {
     if (!fValid)
         return false;
diff --git a/src/key.h b/src/key.h
index e054d4f4c77e5..3bc8e01737421 100644
--- a/src/key.h
+++ b/src/key.h
@@ -110,6 +110,11 @@ class CKey
      */
     CPubKey GetPubKey() const;
 
+    /**
+     * Compute the ECDH exchange result using this private key and another public key.
+     */
+    uint256 ECDH(const CPubKey& pubkey) const;
+
     /**
      * Create a DER-serialized signature.
      * The test_case parameter tweaks the deterministic nonce.
diff --git a/src/key_io.cpp b/src/key_io.cpp
index 8efcbaf07b279..9ee053bdbeb2b 100644
--- a/src/key_io.cpp
+++ b/src/key_io.cpp
@@ -6,6 +6,7 @@
 
 #include <base58.h>
 #include <bech32.h>
+#include <blech32.h>
 #include <chainparams.h>
 #include <script/script.h>
 #include <utilstrencodings.h>
@@ -29,16 +30,38 @@ class DestinationEncoder : public boost::static_visitor<std::string>
 public:
     explicit DestinationEncoder(const CChainParams& params, const bool for_parent) : m_params(params), for_parent(for_parent) {}
 
-    std::string operator()(const CKeyID& id) const
+    std::string operator()(const PKHash& id) const
     {
+        if (id.blinding_pubkey.IsFullyValid()) {
+            assert(!for_parent);
+            std::vector<unsigned char> data = m_params.Base58Prefix(CChainParams::BLINDED_ADDRESS);
+            // Blinded addresses have the actual address type prefix inside the payload.
+            std::vector<unsigned char> prefix = m_params.Base58Prefix(CChainParams::PUBKEY_ADDRESS);
+            data.insert(data.end(), prefix.begin(), prefix.end());
+            data.insert(data.end(), id.blinding_pubkey.begin(), id.blinding_pubkey.end());
+            data.insert(data.end(), id.begin(), id.end());
+            return EncodeBase58Check(data);
+        }
+
         CChainParams::Base58Type type = for_parent ? CChainParams::PARENT_PUBKEY_ADDRESS : CChainParams::PUBKEY_ADDRESS;
         std::vector<unsigned char> data = m_params.Base58Prefix(type);
         data.insert(data.end(), id.begin(), id.end());
         return EncodeBase58Check(data);
     }
 
-    std::string operator()(const CScriptID& id) const
+    std::string operator()(const ScriptHash& id) const
     {
+        if (id.blinding_pubkey.IsFullyValid()) {
+            assert(!for_parent);
+            std::vector<unsigned char> data = m_params.Base58Prefix(CChainParams::BLINDED_ADDRESS);
+            // Blinded addresses have the actual address type prefix inside the payload.
+            std::vector<unsigned char> prefix = m_params.Base58Prefix(CChainParams::SCRIPT_ADDRESS);
+            data.insert(data.end(), prefix.begin(), prefix.end());
+            data.insert(data.end(), id.blinding_pubkey.begin(), id.blinding_pubkey.end());
+            data.insert(data.end(), id.begin(), id.end());
+            return EncodeBase58Check(data);
+        }
+
         CChainParams::Base58Type type = for_parent ? CChainParams::PARENT_SCRIPT_ADDRESS : CChainParams::SCRIPT_ADDRESS;
         std::vector<unsigned char> data = m_params.Base58Prefix(type);
         data.insert(data.end(), id.begin(), id.end());
@@ -48,7 +71,15 @@ class DestinationEncoder : public boost::static_visitor<std::string>
     std::string operator()(const WitnessV0KeyHash& id) const
     {
         std::vector<unsigned char> data = {0};
-        data.reserve(33);
+        data.reserve(53);
+        if (id.blinding_pubkey.IsFullyValid()) {
+            std::vector<unsigned char> bytes(id.blinding_pubkey.begin(), id.blinding_pubkey.end());
+            bytes.insert(bytes.end(), id.begin(), id.end());
+            ConvertBits<8, 5, true>([&](unsigned char c) { data.push_back(c); }, bytes.begin(), bytes.end());
+            const std::string& hrp = for_parent ? m_params.ParentBlech32HRP() : m_params.Blech32HRP();
+            return blech32::Encode(hrp, data);
+        }
+
         ConvertBits<8, 5, true>([&](unsigned char c) { data.push_back(c); }, id.begin(), id.end());
         const std::string& hrp = for_parent ? m_params.ParentBech32HRP() : m_params.Bech32HRP();
         return bech32::Encode(hrp, data);
@@ -58,6 +89,14 @@ class DestinationEncoder : public boost::static_visitor<std::string>
     {
         std::vector<unsigned char> data = {0};
         data.reserve(53);
+        if (id.blinding_pubkey.IsFullyValid()) {
+            std::vector<unsigned char> bytes(id.blinding_pubkey.begin(), id.blinding_pubkey.end());
+            bytes.insert(bytes.end(), id.begin(), id.end());
+            ConvertBits<8, 5, true>([&](unsigned char c) { data.push_back(c); }, bytes.begin(), bytes.end());
+            const std::string& hrp = for_parent ? m_params.ParentBlech32HRP() : m_params.Blech32HRP();
+            return blech32::Encode(hrp, data);
+        }
+
         ConvertBits<8, 5, true>([&](unsigned char c) { data.push_back(c); }, id.begin(), id.end());
         const std::string& hrp = for_parent ? m_params.ParentBech32HRP() : m_params.Bech32HRP();
         return bech32::Encode(hrp, data);
@@ -70,6 +109,14 @@ class DestinationEncoder : public boost::static_visitor<std::string>
         }
         std::vector<unsigned char> data = {(unsigned char)id.version};
         data.reserve(1 + (id.length * 8 + 4) / 5);
+        if (id.blinding_pubkey.IsFullyValid()) {
+            std::vector<unsigned char> bytes(id.blinding_pubkey.begin(), id.blinding_pubkey.end());
+            bytes.insert(bytes.end(), id.program, id.program + id.length);
+            ConvertBits<8, 5, true>([&](unsigned char c) { data.push_back(c); }, bytes.begin(), bytes.end());
+            const std::string& hrp = for_parent ? m_params.ParentBlech32HRP() : m_params.Blech32HRP();
+            return blech32::Encode(hrp, data);
+        }
+
         ConvertBits<8, 5, true>([&](unsigned char c) { data.push_back(c); }, id.program, id.program + id.length);
         const std::string& hrp = for_parent ? m_params.ParentBech32HRP() : m_params.Bech32HRP();
         return bech32::Encode(hrp, data);
@@ -82,24 +129,46 @@ class DestinationEncoder : public boost::static_visitor<std::string>
 CTxDestination DecodeDestination(const std::string& str, const CChainParams& params, const bool for_parent)
 {
     std::vector<unsigned char> data;
+    size_t pk_size = CPubKey::COMPRESSED_PUBLIC_KEY_SIZE;
     uint160 hash;
     if (DecodeBase58Check(str, data)) {
         // base58-encoded Bitcoin addresses.
         // Public-key-hash-addresses have version 0 (or 111 testnet).
         // The data vector contains RIPEMD160(SHA256(pubkey)), where pubkey is the serialized public key.
+
+        // Blinded addresses have two prefixes: first the blinded one, then the traditional one.
+        const std::vector<unsigned char>& blinded_prefix = params.Base58Prefix(CChainParams::BLINDED_ADDRESS);
+
         CChainParams::Base58Type type_pkh = for_parent ? CChainParams::PARENT_PUBKEY_ADDRESS : CChainParams::PUBKEY_ADDRESS;
         const std::vector<unsigned char>& pubkey_prefix = params.Base58Prefix(type_pkh);
         if (data.size() == hash.size() + pubkey_prefix.size() && std::equal(pubkey_prefix.begin(), pubkey_prefix.end(), data.begin())) {
             std::copy(data.begin() + pubkey_prefix.size(), data.end(), hash.begin());
-            return CKeyID(hash);
+            return PKHash(hash);
+        } else if (data.size() == hash.size() + blinded_prefix.size() + pubkey_prefix.size() + pk_size &&
+                std::equal(blinded_prefix.begin(), blinded_prefix.end(), data.begin()) &&
+                std::equal(pubkey_prefix.begin(), pubkey_prefix.end(), data.begin() + blinded_prefix.size())) {
+            auto payload_start = data.begin() + blinded_prefix.size() + pubkey_prefix.size();
+            CPubKey pubkey;
+            pubkey.Set(payload_start, payload_start + pk_size);
+            std::copy(payload_start + pk_size, data.end(), hash.begin());
+            return PKHash(hash, pubkey);
         }
+
         // Script-hash-addresses have version 5 (or 196 testnet).
         // The data vector contains RIPEMD160(SHA256(cscript)), where cscript is the serialized redemption script.
         CChainParams::Base58Type type_sh = for_parent ? CChainParams::PARENT_SCRIPT_ADDRESS : CChainParams::SCRIPT_ADDRESS;
         const std::vector<unsigned char>& script_prefix = params.Base58Prefix(type_sh);
         if (data.size() == hash.size() + script_prefix.size() && std::equal(script_prefix.begin(), script_prefix.end(), data.begin())) {
             std::copy(data.begin() + script_prefix.size(), data.end(), hash.begin());
-            return CScriptID(hash);
+            return ScriptHash(hash);
+        } else if (data.size() == hash.size() + blinded_prefix.size() + pubkey_prefix.size() + pk_size &&
+                std::equal(blinded_prefix.begin(), blinded_prefix.end(), data.begin()) &&
+                std::equal(script_prefix.begin(), script_prefix.end(), data.begin() + blinded_prefix.size())) {
+            auto payload_start = data.begin() + blinded_prefix.size() + script_prefix.size();
+            CPubKey pubkey;
+            pubkey.Set(payload_start, payload_start + pk_size);
+            std::copy(payload_start + pk_size, data.end(), hash.begin());
+            return ScriptHash(hash, pubkey);
         }
     }
     data.clear();
@@ -138,6 +207,56 @@ CTxDestination DecodeDestination(const std::string& str, const CChainParams& par
             return unk;
         }
     }
+    // ELEMENTS confidential addresses: version + 8to5(ecdhkey || witness program)
+    data.clear();
+    auto blech = blech32::Decode(str);
+    const std::string& bl_hrp = for_parent ? params.ParentBlech32HRP() : params.Blech32HRP();
+    if (blech.second.size() > 0 && blech.first == bl_hrp) {
+        // Blech32 decoding
+        int version = blech.second[0]; // The first 5 bit symbol is the witness version (0-16)
+
+        data.reserve(((blech.second.size() - 1) * 5) / 8);
+
+        // The rest of the symbols are converted blinding pubkey and witness program bytes.
+        if (ConvertBits<5, 8, false>([&](unsigned char c) { data.push_back(c); }, blech.second.begin() + 1, blech.second.end())) {
+            // Must be long enough for blinding key and other data taken below
+            if (data.size() < 34) {
+                return CNoDestination();
+            }
+            std::vector<unsigned char> pubkey_bytes(data.begin(), data.begin()+33);
+            data = std::vector<unsigned char>(data.begin()+33, data.end());
+            CPubKey blinding_pubkey(pubkey_bytes);
+            if (version == 0) {
+                {
+                    WitnessV0KeyHash keyid;
+                    if (data.size() == keyid.size()) {
+                        std::copy(data.begin(), data.end(), keyid.begin());
+                        keyid.blinding_pubkey = blinding_pubkey;
+                        return keyid;
+                    }
+                }
+                {
+                    WitnessV0ScriptHash scriptid;
+                    if (data.size() == scriptid.size()) {
+                        std::copy(data.begin(), data.end(), scriptid.begin());
+                        scriptid.blinding_pubkey = blinding_pubkey;
+                        return scriptid;
+                    }
+                }
+                return CNoDestination();
+            }
+            if (version > 16 || data.size() < 2 || data.size() > 40) {
+                return CNoDestination();
+            }
+            WitnessUnknown unk;
+            unk.version = version;
+            std::copy(data.begin(), data.end(), unk.program);
+            unk.blinding_pubkey = blinding_pubkey;
+            unk.length = data.size();
+            return unk;
+        }
+    }
+
     return CNoDestination();
 }
 } // namespace
diff --git a/src/keystore.cpp b/src/keystore.cpp
index b2012a04bb7ab..48515c92018c9 100644
--- a/src/keystore.cpp
+++ b/src/keystore.cpp
@@ -178,16 +178,17 @@ CKeyID GetKeyForDestination(const CKeyStore& store, const CTxDestination& dest)
 {
     // Only supports destinations which map to single public keys, i.e. P2PKH,
     // P2WPKH, and P2SH-P2WPKH.
-    if (auto id = boost::get<CKeyID>(&dest)) {
-        return *id;
+    if (auto id = boost::get<PKHash>(&dest)) {
+        return CKeyID(*id);
     }
     if (auto witness_id = boost::get<WitnessV0KeyHash>(&dest)) {
         return CKeyID(*witness_id);
     }
-    if (auto script_id = boost::get<CScriptID>(&dest)) {
+    if (auto script_hash = boost::get<ScriptHash>(&dest)) {
         CScript script;
+        CScriptID script_id(*script_hash);
         CTxDestination inner_dest;
-        if (store.GetCScript(*script_id, script) && ExtractDestination(script, inner_dest)) {
+        if (store.GetCScript(script_id, script) && ExtractDestination(script, inner_dest)) {
             if (auto inner_witness_id = boost::get<WitnessV0KeyHash>(&inner_dest)) {
                 return CKeyID(*inner_witness_id);
             }
diff --git a/src/miner.cpp b/src/miner.cpp
index 4e24b7eea2937..791d883d190ee 100644
--- a/src/miner.cpp
+++ b/src/miner.cpp
@@ -124,7 +124,7 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
 
     // Pad block weight to account for OP_RETURN commitments with two compressed pubkeys
     for (const auto& commitment : commitments) {
-        CTxOut output(0, commitment);
+        CTxOut output(CAsset(), 0, commitment);
         nBlockWeight += ::GetSerializeSize(output, PROTOCOL_VERSION)*WITNESS_SCALE_FACTOR;
     }
     // END PAK
@@ -187,12 +187,23 @@ std::unique_ptr<CBlockTemplate> BlockAssembler::CreateNewBlock(const CScript& sc
     coinbaseTx.vin[0].prevout.SetNull();
     coinbaseTx.vout.resize(1);
     coinbaseTx.vout[0].scriptPubKey = scriptPubKeyIn;
+    coinbaseTx.vout[0].nAsset = policyAsset;
     coinbaseTx.vout[0].nValue = nFees + GetBlockSubsidy(nHeight, chainparams.GetConsensus());
+    if (g_con_elementsmode) {
+        if(chainparams.GetConsensus().subsidy_asset != policyAsset) {
+            // Only claim the subsidy if it's the same as the policy asset.
+            coinbaseTx.vout[0].nValue = nFees;
+        }
+        // 0-value outputs must be unspendable
+        if (coinbaseTx.vout[0].nValue.GetAmount() == 0) {
+            coinbaseTx.vout[0].scriptPubKey = CScript() << OP_RETURN;
+        }
+    }
     coinbaseTx.vin[0].scriptSig = CScript() << nHeight << OP_0;
     // ELEMENTS: PAK
     // Add PAK transition commitments
     for (unsigned int i = 0; i < commitments.size(); i++) {
-        coinbaseTx.vout.push_back(CTxOut(0, commitments[i]));
+        coinbaseTx.vout.push_back(CTxOut(CAsset(), 0, commitments[i]));
     }
     // END PAK
     pblock->vtx[0] = MakeTransactionRef(std::move(coinbaseTx));
diff --git a/src/outputtype.cpp b/src/outputtype.cpp
index 7e5690dfc5d4c..cfd054e2f8bfc 100644
--- a/src/outputtype.cpp
+++ b/src/outputtype.cpp
@@ -45,14 +45,14 @@ const std::string& FormatOutputType(OutputType type)
 CTxDestination GetDestinationForKey(const CPubKey& key, OutputType type)
 {
     switch (type) {
-    case OutputType::LEGACY: return key.GetID();
+    case OutputType::LEGACY: return PKHash(key);
     case OutputType::P2SH_SEGWIT:
     case OutputType::BECH32: {
-        if (!key.IsCompressed()) return key.GetID();
-        CTxDestination witdest = WitnessV0KeyHash(key.GetID());
+        if (!key.IsCompressed()) return PKHash(key);
+        CTxDestination witdest = WitnessV0KeyHash(PKHash(key));
         CScript witprog = GetScriptForDestination(witdest);
         if (type == OutputType::P2SH_SEGWIT) {
-            return CScriptID(witprog);
+            return ScriptHash(witprog);
         } else {
             return witdest;
         }
@@ -61,12 +61,33 @@ CTxDestination GetDestinationForKey(const CPubKey& key, OutputType type)
     }
 }
 
+// Elements
+CTxDestination GetDestinationForKey(const CPubKey& key, OutputType type, const CPubKey& blinding_pubkey)
+{
+    switch (type) {
+    case OutputType::LEGACY: return PKHash(key, blinding_pubkey);
+    case OutputType::P2SH_SEGWIT:
+    case OutputType::BECH32: {
+        if (!key.IsCompressed()) return PKHash(key, blinding_pubkey);
+        CTxDestination witdest = WitnessV0KeyHash(PKHash(key), blinding_pubkey);
+        CScript witprog = GetScriptForDestination(witdest);
+        if (type == OutputType::P2SH_SEGWIT) {
+            return ScriptHash(witprog, blinding_pubkey);
+        } else {
+            return witdest;
+        }
+    }
+    default: assert(false);
+    }
+}
+//
+
 std::vector<CTxDestination> GetAllDestinationsForKey(const CPubKey& key)
 {
-    CKeyID keyid = key.GetID();
+    PKHash keyid(key);
     if (key.IsCompressed()) {
         CTxDestination segwit = WitnessV0KeyHash(keyid);
-        CTxDestination p2sh = CScriptID(GetScriptForDestination(segwit));
+        CTxDestination p2sh = ScriptHash(GetScriptForDestination(segwit));
         return std::vector<CTxDestination>{std::move(keyid), std::move(p2sh), std::move(segwit)};
     } else {
         return std::vector<CTxDestination>{std::move(keyid)};
@@ -80,19 +101,19 @@ CTxDestination AddAndGetDestinationForScript(CKeyStore& keystore, const CScript&
     // Note that scripts over 520 bytes are not yet supported.
     switch (type) {
     case OutputType::LEGACY:
-        return CScriptID(script);
+        return ScriptHash(script);
     case OutputType::P2SH_SEGWIT:
     case OutputType::BECH32: {
         CTxDestination witdest = WitnessV0ScriptHash(script);
         CScript witprog = GetScriptForDestination(witdest);
         // Check if the resulting program is solvable (i.e. doesn't use an uncompressed key)
-        if (!IsSolvable(keystore, witprog)) return CScriptID(script);
+        if (!IsSolvable(keystore, witprog)) return ScriptHash(script);
         // Add the redeemscript, so that P2WSH and P2SH-P2WSH outputs are recognized as ours.
         keystore.AddCScript(witprog);
         if (type == OutputType::BECH32) {
             return witdest;
         } else {
-            return CScriptID(witprog);
+            return ScriptHash(CScriptID(witprog));
         }
     }
     default: assert(false);
diff --git a/src/outputtype.h b/src/outputtype.h
index 4c4d93bc8b534..3b37e78c13ed4 100644
--- a/src/outputtype.h
+++ b/src/outputtype.h
@@ -34,6 +34,7 @@ const std::string& FormatOutputType(OutputType type);
  * The caller must make sure LearnRelatedScripts has been called beforehand.
  */
 CTxDestination GetDestinationForKey(const CPubKey& key, OutputType);
+CTxDestination GetDestinationForKey(const CPubKey& key, OutputType, const CPubKey& blinding_pubkey);
 
 /** Get all destinations (potentially) supported by the wallet for the given key. */
 std::vector<CTxDestination> GetAllDestinationsForKey(const CPubKey& key);
diff --git a/src/pegins.cpp b/src/pegins.cpp
index b7a457e33a708..7ac516f59632e 100644
--- a/src/pegins.cpp
+++ b/src/pegins.cpp
@@ -54,18 +54,16 @@ bool GetAmountFromParentChainPegin(CAmount& amount, const Sidechain::Bitcoin::CT
 
 bool GetAmountFromParentChainPegin(CAmount& amount, const CTransaction& txBTC, unsigned int nOut)
 {
-    //if (!txBTC.vout[nOut].nValue.IsExplicit()) {
-    //    return false;
-    //}
-    //if (!txBTC.vout[nOut].nAsset.IsExplicit()) {
-    //    return false;
-    //}
-    //if (txBTC.vout[nOut].nAsset.GetAsset() != Params().GetConsensus().parent_pegged_asset) {
-    //    return false;
-    //}
-    //amount = txBTC.vout[nOut].nValue.GetAmount();
-    //TODO(rebase) re-enable above for CA/CT
-    amount = txBTC.vout[nOut].nValue;
+    if (!txBTC.vout[nOut].nValue.IsExplicit()) {
+        return false;
+    }
+    if (!txBTC.vout[nOut].nAsset.IsExplicit()) {
+        return false;
+    }
+    if (txBTC.vout[nOut].nAsset.GetAsset() != Params().GetConsensus().parent_pegged_asset) {
+        return false;
+    }
+    amount = txBTC.vout[nOut].nValue.GetAmount();
     return true;
 }
 
@@ -75,67 +73,72 @@ CScript calculate_contract(const CScript& federation_script, const CScript& scri
     std::vector<std::vector<unsigned char> > solutions;
     unsigned int required;
     std::vector<std::vector<unsigned char>> keys;
+    bool is_liquidv1_watchman = MatchLiquidWatchman(federation_script);
     // Sanity check federation_script only to match 3 templates
-    if (federation_script != CScript() << OP_TRUE &&
-            !MatchMultisig(federation_script, required, keys) &&
-            !MatchLiquidWatchman(federation_script)) {
-       assert(false);
+    if (!is_liquidv1_watchman &&
+            federation_script != CScript() << OP_TRUE &&
+            !MatchMultisig(federation_script, required, keys)) {
+        assert(false);
     }
 
+    CScript::const_iterator sdpc = federation_script.begin();
+    std::vector<unsigned char> vch;
+    opcodetype opcodeTmp;
+    bool liquid_op_else_found = false;
+    while (federation_script.GetOp(sdpc, opcodeTmp, vch))
     {
-        CScript::const_iterator sdpc = federation_script.begin();
-        std::vector<unsigned char> vch;
-        opcodetype opcodeTmp;
-        while (federation_script.GetOp(sdpc, opcodeTmp, vch))
+        // For liquid watchman template, don't tweak emergency keys
+        if (is_liquidv1_watchman && opcodeTmp == OP_ELSE) {
+            liquid_op_else_found = true;
+        }
+
+        size_t pub_len = 33;
+        if (vch.size() == pub_len && !liquid_op_else_found)
         {
-            size_t pub_len = 33;
-            if (vch.size() == pub_len)
-            {
-                unsigned char tweak[32];
-                CHMAC_SHA256(vch.data(), pub_len).Write(scriptPubKey.data(), scriptPubKey.size()).Finalize(tweak);
-                int ret;
-                secp256k1_pubkey watchman;
-                secp256k1_pubkey tweaked;
-                ret = secp256k1_ec_pubkey_parse(secp256k1_ctx_validation, &watchman, vch.data(), pub_len);
-                assert(ret == 1);
-                ret = secp256k1_ec_pubkey_parse(secp256k1_ctx_validation, &tweaked, vch.data(), pub_len);
-                assert(ret == 1);
-                // If someone creates a tweak that makes this fail, they broke SHA256
-                ret = secp256k1_ec_pubkey_tweak_add(secp256k1_ctx_validation, &tweaked, tweak);
-                assert(ret == 1);
-                unsigned char new_pub[33];
-                ret = secp256k1_ec_pubkey_serialize(secp256k1_ctx_validation, new_pub, &pub_len, &tweaked, SECP256K1_EC_COMPRESSED);
-                assert(ret == 1);
-                assert(pub_len == 33);
-
-                // push tweaked pubkey
-                std::vector<unsigned char> pub_vec(new_pub, new_pub + pub_len);
-                scriptDestination << pub_vec;
-
-                // Sanity checks to reduce pegin risk. If the tweaked
-                // value flips a bit, we may lose pegin funds irretrievably.
-                // We take the tweak, derive its pubkey and check that
-                // `tweaked - watchman = tweak` to check the computation
-                // two different ways
-                secp256k1_pubkey tweaked2;
-                ret = secp256k1_ec_pubkey_create(secp256k1_ctx_validation, &tweaked2, tweak);
-                assert(ret);
-                ret = secp256k1_ec_pubkey_negate(secp256k1_ctx_validation, &watchman);
-                assert(ret);
-                secp256k1_pubkey* pubkey_combined[2];
-                pubkey_combined[0] = &watchman;
-                pubkey_combined[1] = &tweaked;
-                secp256k1_pubkey maybe_tweaked2;
-                ret = secp256k1_ec_pubkey_combine(secp256k1_ctx_validation, &maybe_tweaked2, pubkey_combined, 2);
-                assert(ret);
-                assert(!memcmp(&maybe_tweaked2, &tweaked2, 64));
+            unsigned char tweak[32];
+            CHMAC_SHA256(vch.data(), pub_len).Write(scriptPubKey.data(), scriptPubKey.size()).Finalize(tweak);
+            int ret;
+            secp256k1_pubkey watchman;
+            secp256k1_pubkey tweaked;
+            ret = secp256k1_ec_pubkey_parse(secp256k1_ctx_validation, &watchman, vch.data(), pub_len);
+            assert(ret == 1);
+            ret = secp256k1_ec_pubkey_parse(secp256k1_ctx_validation, &tweaked, vch.data(), pub_len);
+            assert(ret == 1);
+            // If someone creates a tweak that makes this fail, they broke SHA256
+            ret = secp256k1_ec_pubkey_tweak_add(secp256k1_ctx_validation, &tweaked, tweak);
+            assert(ret == 1);
+            unsigned char new_pub[33];
+            ret = secp256k1_ec_pubkey_serialize(secp256k1_ctx_validation, new_pub, &pub_len, &tweaked, SECP256K1_EC_COMPRESSED);
+            assert(ret == 1);
+            assert(pub_len == 33);
+
+            // push tweaked pubkey
+            std::vector<unsigned char> pub_vec(new_pub, new_pub + pub_len);
+            scriptDestination << pub_vec;
+
+            // Sanity checks to reduce pegin risk. If the tweaked
+            // value flips a bit, we may lose pegin funds irretrievably.
+            // We take the tweak, derive its pubkey and check that
+            // `tweaked - watchman = tweak` to check the computation
+            // two different ways
+            secp256k1_pubkey tweaked2;
+            ret = secp256k1_ec_pubkey_create(secp256k1_ctx_validation, &tweaked2, tweak);
+            assert(ret);
+            ret = secp256k1_ec_pubkey_negate(secp256k1_ctx_validation, &watchman);
+            assert(ret);
+            secp256k1_pubkey* pubkey_combined[2];
+            pubkey_combined[0] = &watchman;
+            pubkey_combined[1] = &tweaked;
+            secp256k1_pubkey maybe_tweaked2;
+            ret = secp256k1_ec_pubkey_combine(secp256k1_ctx_validation, &maybe_tweaked2, pubkey_combined, 2);
+            assert(ret);
+            assert(!memcmp(&maybe_tweaked2, &tweaked2, 64));
+        } else {
+            // add to script untouched
+            if (vch.size() > 0) {
+                scriptDestination << vch;
             } else {
-                // add to script untouched
-                if (vch.size() > 0) {
-                    scriptDestination << vch;
-                } else {
-                    scriptDestination << opcodeTmp;
-                }
+                scriptDestination << opcodeTmp;
             }
         }
     }
@@ -177,7 +180,7 @@ static bool CheckPeginTx(const std::vector<unsigned char>& tx_data, T& pegtx, co
     // Check that the witness program matches the p2ch on the p2sh-p2wsh transaction output
     CScript tweaked_fedpegscript = calculate_contract(Params().GetConsensus().fedpegScript, claim_script);
     CScript witness_output(GetScriptForWitness(tweaked_fedpegscript));
-    CScript expected_script(CScript() << OP_HASH160 << ToByteVector(CScriptID(witness_output)) << OP_EQUAL);
+    CScript expected_script(CScript() << OP_HASH160 << ToByteVector(ScriptHash(CScriptID(witness_output))) << OP_EQUAL);
     if (pegtx->vout[prevout.n].scriptPubKey != expected_script) {
         return false;
     }
@@ -273,8 +276,7 @@ bool IsValidPeginWitness(const CScriptWitness& pegin_witness, const COutPoint& p
         err_msg = "Asset type was not 32 bytes.";
         return false;
     }
-    //TODO(rebase) CA
-    //CAsset asset(stack[1]);
+    CAsset asset(stack[1]);
 
     // Get genesis blockhash
     if (stack[2].size() != 32) {
@@ -345,11 +347,10 @@ bool IsValidPeginWitness(const CScriptWitness& pegin_witness, const COutPoint& p
         return false;
     }
 
-    //TODO(rebase) CA
-    //// Check the asset type corresponds to a valid pegged asset (only one for now)
-    //if (asset != Params().GetConsensus().pegged_asset) {
-    //    return false;
-    //}
+    // Check the asset type corresponds to a valid pegged asset (only one for now)
+    if (asset != Params().GetConsensus().pegged_asset) {
+        return false;
+    }
 
     // Finally, validate peg-in via rpc call
     if (check_depth && gArgs.GetBoolArg("-validatepegin", DEFAULT_VALIDATE_PEGIN)) {
@@ -367,9 +368,7 @@ CTxOut GetPeginOutputFromWitness(const CScriptWitness& pegin_witness) {
     CAmount value;
     stream >> value;
 
-    //TODO(rebase) CA
-    //return CTxOut(CAsset(pegin_witness.stack[1]), value, CScript(pegin_witness.stack[3].begin(), pegin_witness.stack[3].end()));
-    return CTxOut(value, CScript(pegin_witness.stack[3].begin(), pegin_witness.stack[3].end()));
+    return CTxOut(CAsset(pegin_witness.stack[1]), CConfidentialValue(value), CScript(pegin_witness.stack[3].begin(), pegin_witness.stack[3].end()));
 }
 
 bool MatchLiquidWatchman(const CScript& script)
@@ -441,5 +440,5 @@ bool MatchLiquidWatchman(const CScript& script)
         return false;
     }
     // No more pushes
-    return (it + 1 == script.end());
+    return (it == script.end());
 }
diff --git a/src/policy/policy.cpp b/src/policy/policy.cpp
index 2e6acdd6fb61a..a91d6e4992099 100644
--- a/src/policy/policy.cpp
+++ b/src/policy/policy.cpp
@@ -16,6 +16,8 @@
 #include <utilstrencodings.h>
 #include <chainparams.h> // Peg-out enforcement
 
+// ELEMENTS:
+CAsset policyAsset;
 
 CAmount GetDustThreshold(const CTxOut& txout, const CFeeRate& dustRelayFeeIn)
 {
@@ -53,7 +55,13 @@ CAmount GetDustThreshold(const CTxOut& txout, const CFeeRate& dustRelayFeeIn)
 
 bool IsDust(const CTxOut& txout, const CFeeRate& dustRelayFeeIn)
 {
-    return (txout.nValue < GetDustThreshold(txout, dustRelayFeeIn));
+    if (!txout.nValue.IsExplicit())
+        return false; // FIXME
+    if (!txout.nAsset.IsExplicit())
+        return false;
+    if (txout.IsFee())
+        return false;
+    return (txout.nValue.GetAmount() < GetDustThreshold(txout, dustRelayFeeIn));
 }
 
 bool IsStandard(const CScript& scriptPubKey, txnouttype& whichType)
@@ -129,21 +137,19 @@ bool IsStandardTx(const CTransaction& tx, std::string& reason)
             return false;
         }
 
-        if (whichType == TX_NULL_DATA) {
-        }
         if (whichType == TX_NULL_DATA) {
             nDataOut++;
             if (params.GetEnforcePak() &&
                     txout.scriptPubKey.IsPegoutScript(params.ParentGenesisBlockHash()) &&
-                (!ScriptHasValidPAKProof(txout.scriptPubKey, params.ParentGenesisBlockHash()))) {
-                // TODO(rebase) CT/CA check for asset type
+                    txout.nAsset.IsExplicit() && txout.nAsset.GetAsset() == Params().GetConsensus().pegged_asset &&
+                    (!ScriptHasValidPAKProof(txout.scriptPubKey, params.ParentGenesisBlockHash()))) {
                 reason = "invalid-pegout-proof";
                 return false;
             }
         } else if ((whichType == TX_MULTISIG) && (!fIsBareMultisigStd)) {
             reason = "bare-multisig";
             return false;
-        } else if (IsDust(txout, ::dustRelayFee)) {
+        } else if ((txout.nAsset.IsExplicit() && txout.nAsset.GetAsset() == policyAsset) && IsDust(txout, ::dustRelayFee)) {
             reason = "dust";
             return false;
         }
diff --git a/src/policy/policy.h b/src/policy/policy.h
index 5b12d97af5f55..97476b13a0ebf 100644
--- a/src/policy/policy.h
+++ b/src/policy/policy.h
@@ -16,6 +16,9 @@
 class CCoinsViewCache;
 class CTxOut;
 
+// ELEMENTS:
+extern CAsset policyAsset;
+
 /** Default for -blockmaxweight, which controls the range of block weights the mining code will create **/
 static const unsigned int DEFAULT_BLOCK_MAX_WEIGHT = MAX_BLOCK_WEIGHT - 4000;
 /** Default for -blockmintxfee, which sets the minimum feerate for a transaction in blocks created by mining code **/
diff --git a/src/primitives/confidential.cpp b/src/primitives/confidential.cpp
new file mode 100644
index 0000000000000..fd1a9eca0d274
--- /dev/null
+++ b/src/primitives/confidential.cpp
@@ -0,0 +1,34 @@
+
+#include <primitives/confidential.h>
+
+#include <tinyformat.h>
+
+void CConfidentialAsset::SetToAsset(const CAsset& asset)
+{
+    vchCommitment.clear();
+    vchCommitment.reserve(nExplicitSize);
+    vchCommitment.push_back(1);
+    vchCommitment.insert(vchCommitment.end(), asset.begin(), asset.end());
+}
+
+void CConfidentialValue::SetToAmount(const CAmount amount)
+{
+    vchCommitment.resize(nExplicitSize);
+    vchCommitment[0] = 1;
+    WriteBE64(&vchCommitment[1], amount);
+}
+
+std::string CAssetIssuance::ToString() const
+{
+    std::string str;
+    str += "CAssetIssuance(";
+    str += assetBlindingNonce.ToString();
+    str += ", ";
+    str += assetEntropy.ToString();
+    if (!nAmount.IsNull())
+        str += strprintf(", amount=%s", (nAmount.IsExplicit() ? strprintf("%d.%08d", nAmount.GetAmount() / COIN, nAmount.GetAmount() % COIN) : std::string("CONFIDENTIAL")));
+    if (!nInflationKeys.IsNull())
+        str += strprintf(", inflationkeys=%s", (nInflationKeys.IsExplicit() ? strprintf("%d.%08d", nInflationKeys.GetAmount() / COIN, nInflationKeys.GetAmount() % COIN) : std::string("CONFIDENTIAL")));
+    str += ")";
+    return str;
+}
diff --git a/src/primitives/confidential.h b/src/primitives/confidential.h
new file mode 100644
index 0000000000000..2544754d8f89f
--- /dev/null
+++ b/src/primitives/confidential.h
@@ -0,0 +1,224 @@
+
+#ifndef BITCOIN_PRIMITIVES_CONFIDENTIAL_H
+#define BITCOIN_PRIMITIVES_CONFIDENTIAL_H
+
+#include <amount.h>
+#include <asset.h>
+#include <script/script.h>
+#include <serialize.h>
+#include <span.h>
+#include <uint256.h>
+#include <utilstrencodings.h>
+
+extern bool g_con_elementsmode;
+
+/**
+ * Confidential assets, values, and nonces all share enough code in common
+ * that it makes sense to define a common abstract base class. */
+template<size_t ExplicitSize, unsigned char PrefixA, unsigned char PrefixB>
+class CConfidentialCommitment
+{
+public:
+    static const size_t nExplicitSize = ExplicitSize;
+    static const size_t nCommittedSize = 33;
+
+    std::vector<unsigned char> vchCommitment;
+
+    CConfidentialCommitment() { SetNull(); }
+
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action) {
+        unsigned char version = vchCommitment.empty()? 0: vchCommitment[0];
+        READWRITE(version);
+        if (ser_action.ForRead()) {
+            switch (version) {
+                /* Null */
+                case 0:
+                    vchCommitment.clear();
+                    return;
+                /* Explicit value */
+                case 1:
+                    vchCommitment.resize(nExplicitSize);
+                    break;
+                /* Confidential commitment */
+                case PrefixA:
+                case PrefixB:
+                    vchCommitment.resize(nCommittedSize);
+                    break;
+                /* Invalid serialization! */
+                default:
+                    throw std::ios_base::failure("Unrecognized serialization prefix");
+            }
+            vchCommitment[0] = version;
+        }
+        if (vchCommitment.size() > 1) {
+            READWRITE(REF(Span<unsigned char>(vchCommitment.data() + 1, vchCommitment.size()-1)));
+        }
+    }
+
+    /* Null is the default state when no explicit asset or confidential
+     * asset commitment has been set. */
+    bool IsNull() const { return vchCommitment.empty(); }
+    void SetNull() { vchCommitment.clear(); }
+
+    bool IsExplicit() const
+    {
+        return vchCommitment.size()==nExplicitSize && vchCommitment[0]==1;
+    }
+
+    bool IsCommitment() const
+    {
+        return vchCommitment.size()==nCommittedSize && (vchCommitment[0]==PrefixA || vchCommitment[0]==PrefixB);
+    }
+
+    bool IsValid() const
+    {
+        return IsNull() || IsExplicit() || IsCommitment();
+    }
+
+    std::string GetHex() const { return HexStr(vchCommitment); }
+
+    friend bool operator==(const CConfidentialCommitment& a, const CConfidentialCommitment& b)
+    {
+        return a.vchCommitment == b.vchCommitment;
+    }
+
+    friend bool operator!=(const CConfidentialCommitment& a, const CConfidentialCommitment& b)
+    {
+        return !(a == b);
+    }
+};
+
+/** A commitment to a blinded asset, or an explicit asset NUMS identifier */
+class CConfidentialAsset : public CConfidentialCommitment<33, 10, 11>
+{
+public:
+    CConfidentialAsset() {
+        SetNull();
+    }
+    CConfidentialAsset(CAsset asset) { SetToAsset(asset); }
+
+    void SetNull() {
+        vchCommitment.clear();
+
+        // Set to dummy asset when not doing CA.
+        if (!g_con_elementsmode) {
+            SetToAsset(CAsset());
+        }
+    }
+
+    /* An explicit asset identifier is a 256-bit nothing-up-my-sleeve number
+     * that used as auxiliary input to the Pedersen commitment setup to create
+     * a generator which acts as the asset tag. */
+    const CAsset& GetAsset() const
+    {
+        assert(IsExplicit());
+        return *reinterpret_cast<const CAsset*>(&vchCommitment[1]);
+    }
+    void SetToAsset(const CAsset& asset);
+
+};
+
+/** A 33-byte commitment to a confidential value, or a 64-bit explicit value. */
+class CConfidentialValue : public CConfidentialCommitment<9, 8, 9>
+{
+public:
+    CConfidentialValue() { SetNull(); }
+    CConfidentialValue(CAmount nAmount) { SetToAmount(nAmount); }
+
+    /* An explicit value is called an amount. The first byte indicates it is
+     * an explicit value, and the remaining 8 bytes is the value serialized as
+     * a 64-bit big-endian integer. */
+    CAmount GetAmount() const
+    {
+        if (!g_con_elementsmode && IsNull()) {
+            return -1;
+        }
+
+        assert(IsExplicit());;
+        return ReadBE64(&vchCommitment[1]);
+    }
+    void SetToAmount(CAmount nAmount);
+};
+
+/**
+ * A 33-byte data field that typically is used to convey to the
+ * recipient the ECDH ephemeral key (an EC point) for deriving the
+ * transaction output blinding factor. */
+class CConfidentialNonce : public CConfidentialCommitment<33, 2, 3>
+{
+public:
+    CConfidentialNonce() { SetNull(); }
+};
+
+/** A new asset issuance, or a reissuance (inflation) of an existing asset */
+class CAssetIssuance
+{
+public:
+    // == 0
+    //   Indicates new asset issuance.
+    // != 0
+    //   This is a revelation of the blinding factor for the input,
+    //   which shows that the input being spent is of the reissuance
+    //   capability type for the asset being inflated.
+    uint256 assetBlindingNonce;
+
+    // New asset issuance:
+    //   This is a 32-byte nonce of no consensus-defined meaning,
+    //   but is used as additional entropy to the asset tag calculation.
+    //   This is used by higher-layer protocols for defining the
+    //   Ricardian contract governing the asset.
+    // Existing asset reissuance:
+    //   The original asset entropy (combination of Ricardian contract
+    //   and outpoint used) which was used to generate the fixed asset
+    //   tag and reissuance tokens.
+    uint256 assetEntropy;
+
+    // Both explicit and blinded issuance amounts are supported
+    // (see class definition for CConfidentialValue for details).
+    CConfidentialValue nAmount;
+
+    // If nonzero, specifies the number of asset issuance tokens to
+    // generate. These tokens are made available to the outputs of the
+    // generating transaction.
+    CConfidentialValue nInflationKeys;
+
+public:
+    CAssetIssuance()
+    {
+        SetNull();
+    }
+
+    ADD_SERIALIZE_METHODS;
+
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action)
+    {
+        READWRITE(assetBlindingNonce);
+        READWRITE(assetEntropy);
+        READWRITE(nAmount);
+        READWRITE(nInflationKeys);
+    }
+
+    void SetNull() { nAmount.SetNull(); nInflationKeys.SetNull(); }
+    bool IsNull() const { return (nAmount.IsNull() && nInflationKeys.IsNull()); }
+
+    friend bool operator==(const CAssetIssuance& a, const CAssetIssuance& b)
+    {
+        return a.assetBlindingNonce == b.assetBlindingNonce &&
+               a.assetEntropy == b.assetEntropy &&
+               a.nAmount == b.nAmount &&
+               a.nInflationKeys == b.nInflationKeys;
+    }
+
+    friend bool operator!=(const CAssetIssuance& a, const CAssetIssuance& b)
+    {
+        return !(a == b);
+    }
+
+    std::string ToString() const;
+};
+
+#endif // BITCOIN_PRIMITIVES_CONFIDENTIAL_H
diff --git a/src/primitives/transaction.cpp b/src/primitives/transaction.cpp
index d5c677de090be..91d416341dae2 100644
--- a/src/primitives/transaction.cpp
+++ b/src/primitives/transaction.cpp
@@ -9,7 +9,7 @@
 #include <tinyformat.h>
 #include <utilstrencodings.h>
 
-bool g_con_elementswitness = false;
+bool g_con_elementsmode = false;
 
 std::string COutPoint::ToString() const
 {
@@ -41,19 +41,27 @@ std::string CTxIn::ToString() const
         str += strprintf(", scriptSig=%s", HexStr(scriptSig).substr(0, 24));
     if (nSequence != SEQUENCE_FINAL)
         str += strprintf(", nSequence=%u", nSequence);
+    if (!assetIssuance.IsNull())
+        str += strprintf(", %s", assetIssuance.ToString());
     str += ")";
     return str;
 }
 
-CTxOut::CTxOut(const CAmount& nValueIn, CScript scriptPubKeyIn)
+CTxOut::CTxOut(const CConfidentialAsset& nAssetIn, const CConfidentialValue& nValueIn, CScript scriptPubKeyIn)
 {
+    nAsset = nAssetIn;
     nValue = nValueIn;
     scriptPubKey = scriptPubKeyIn;
 }
 
 std::string CTxOut::ToString() const
 {
-    return strprintf("CTxOut(nValue=%d.%08d, scriptPubKey=%s)", nValue / COIN, nValue % COIN, HexStr(scriptPubKey).substr(0, 30));
+    std::string strAsset;
+    if (nAsset.IsExplicit())
+        strAsset = strprintf("nAsset=%s, ", nAsset.GetAsset().GetHex());
+    if (nAsset.IsCommitment())
+        strAsset = std::string("nAsset=CONFIDENTIAL, ");
+    return strprintf("CTxOut(%snValue=%s, scriptPubKey=%s)", strAsset, (nValue.IsExplicit() ? strprintf("%d.%08d", nValue.GetAmount() / COIN, nValue.GetAmount() % COIN) : std::string("CONFIDENTIAL")), HexStr(scriptPubKey).substr(0, 30));
 }
 
 CMutableTransaction::CMutableTransaction() : nVersion(CTransaction::CURRENT_VERSION), nLockTime(0) {}
@@ -81,13 +89,14 @@ uint256 CTransaction::ComputeWitnessHash() const
 // ELEMENTS ONLY
 uint256 CTransaction::GetWitnessOnlyHash() const
 {
-    assert(g_con_elementswitness);
+    assert(g_con_elementsmode);
 
     std::vector<uint256> leaves;
     leaves.reserve(std::max(vin.size(), vout.size()));
     /* Inputs */
     for (size_t i = 0; i < vin.size(); ++i) {
-        const CTxInWitness& txinwit = witness.vtxinwit.size() <= i || vin[i].prevout.IsNull() ? CTxInWitness() : witness.vtxinwit[i];
+        // Input has no witness OR is null input(coinbase)
+        const CTxInWitness& txinwit = (witness.vtxinwit.size() <= i || vin[i].prevout.IsNull()) ? CTxInWitness() : witness.vtxinwit[i];
         leaves.push_back(txinwit.GetHash());
     }
     uint256 hashIn = ComputeFastMerkleRoot(leaves);
@@ -112,15 +121,19 @@ CTransaction::CTransaction(const CMutableTransaction& tx) :
 CTransaction::CTransaction(CMutableTransaction&& tx) :
         vin(std::move(tx.vin)), vout(std::move(tx.vout)), nVersion(tx.nVersion), nLockTime(tx.nLockTime), witness(std::move(tx.witness)),hash{ComputeHash()}, m_witness_hash{ComputeWitnessHash()} {}
 
-CAmount CTransaction::GetValueOut() const
-{
-    CAmount nValueOut = 0;
+CAmountMap CTransaction::GetValueOutMap() const {
+
+    CAmountMap values;
     for (const auto& tx_out : vout) {
-        nValueOut += tx_out.nValue;
-        if (!MoneyRange(tx_out.nValue) || !MoneyRange(nValueOut))
-            throw std::runtime_error(std::string(__func__) + ": value out of range");
+        if (tx_out.nValue.IsExplicit() && tx_out.nAsset.IsExplicit()) {
+            CAmountMap m;
+            m[tx_out.nAsset.GetAsset()] = tx_out.nValue.GetAmount();
+            values += m;
+            if (!MoneyRange(tx_out.nValue.GetAmount()) || !MoneyRange(values[tx_out.nAsset.GetAsset()]))
+                throw std::runtime_error(std::string(__func__) + ": value out of range");
+        }
     }
-    return nValueOut;
+    return values;
 }
 
 unsigned int CTransaction::GetTotalSize() const
diff --git a/src/primitives/transaction.h b/src/primitives/transaction.h
index 687682abb25c1..047b10139a80e 100644
--- a/src/primitives/transaction.h
+++ b/src/primitives/transaction.h
@@ -11,13 +11,14 @@
 #include <script/script.h>
 #include <serialize.h>
 #include <uint256.h>
+#include <primitives/confidential.h>
 #include <primitives/txwitness.h>
 
 static const int SERIALIZE_TRANSACTION_NO_WITNESS = 0x40000000;
 
 // ELEMENTS:
 // Globals to avoid circular dependencies.
-extern bool g_con_elementswitness;
+extern bool g_con_elementsmode;
 
 /** An outpoint - a combination of a transaction hash and an index n into its vout */
 class COutPoint
@@ -31,8 +32,7 @@ class COutPoint
 
     /* If this flag is set, the CTxIn including this COutPoint has a
      * CAssetIssuance object. */
-    //TODO(rebase) CA
-    //static const uint32_t OUTPOINT_ISSUANCE_FLAG = (1 << 31);
+    static const uint32_t OUTPOINT_ISSUANCE_FLAG = (1 << 31);
 
     /* If this flag is set, the CTxIn including this COutPoint
      * is a peg-in input. */
@@ -93,6 +93,8 @@ class CTxIn
     //
     // ELEMENTS:
 
+    CAssetIssuance assetIssuance;
+
     /* If this is set to true, the input is interpreted as a
      * peg-in claim and processed as such */
     bool m_is_pegin = false;
@@ -143,14 +145,13 @@ class CTxIn
         //
         // ELEMENTS:
 
-        //TODO(rebase) CA/CT
-        //bool fHasAssetIssuance;
+        bool fHasAssetIssuance;
         COutPoint outpoint;
         if (!ser_action.ForRead()) {
             if (prevout.n == (uint32_t) -1) {
                 // Coinbase inputs do not have asset issuances attached
                 // to them.
-            //    fHasAssetIssuance = false;
+                fHasAssetIssuance = false;
                 outpoint = prevout;
             } else {
                 // The issuance and pegin bits can't be set as it is used to indicate
@@ -160,15 +161,15 @@ class CTxIn
                 assert(!(prevout.n & ~COutPoint::OUTPOINT_INDEX_MASK));
                 // The assetIssuance object is used to represent both new
                 // asset generation and reissuance of existing asset types.
-            //    fHasAssetIssuance = !assetIssuance.IsNull();
+                fHasAssetIssuance = !assetIssuance.IsNull();
                 // The mode is placed in the upper bits of the outpoint's
                 // index field. The IssuanceMode enum values are chosen to
                 // make this as simple as a bitwise-OR.
                 outpoint.hash = prevout.hash;
                 outpoint.n = prevout.n & COutPoint::OUTPOINT_INDEX_MASK;
-            //    if (fHasAssetIssuance) {
-            //        outpoint.n |= COutPoint::OUTPOINT_ISSUANCE_FLAG;
-            //    }
+                if (fHasAssetIssuance) {
+                    outpoint.n |= COutPoint::OUTPOINT_ISSUANCE_FLAG;
+                }
                 if (m_is_pegin) {
                     outpoint.n |= COutPoint::OUTPOINT_PEGIN_FLAG;
                 }
@@ -180,13 +181,13 @@ class CTxIn
         if (ser_action.ForRead()) {
             if (outpoint.n == (uint32_t) -1) {
                 // No asset issuance for Coinbase inputs.
-            //    fHasAssetIssuance = false;
+                fHasAssetIssuance = false;
                 prevout = outpoint;
                 m_is_pegin = false;
             } else {
                 // The presence of the asset issuance object is indicated by
                 // a bit set in the outpoint index field.
-            //    fHasAssetIssuance = !!(outpoint.n & COutPoint::OUTPOINT_ISSUANCE_FLAG);
+                fHasAssetIssuance = !!(outpoint.n & COutPoint::OUTPOINT_ISSUANCE_FLAG);
                 // The interpretation of this input as a peg-in is indicated by
                 // a bit set in the outpoint index field.
                 m_is_pegin = !!(outpoint.n & COutPoint::OUTPOINT_PEGIN_FLAG);
@@ -204,13 +205,22 @@ class CTxIn
 
         READWRITE(scriptSig);
         READWRITE(nSequence);
+
+        // ELEMENTS:
+        // The asset fields are deserialized only if they are present.
+        if (fHasAssetIssuance) {
+            READWRITE(assetIssuance);
+        } else if (ser_action.ForRead()) {
+            assetIssuance.SetNull();
+        }
     }
 
     friend bool operator==(const CTxIn& a, const CTxIn& b)
     {
         return (a.prevout   == b.prevout &&
                 a.scriptSig == b.scriptSig &&
-                a.nSequence == b.nSequence);
+                a.nSequence     == b.nSequence &&
+                a.assetIssuance == b.assetIssuance);
     }
 
     friend bool operator!=(const CTxIn& a, const CTxIn& b)
@@ -227,7 +237,9 @@ class CTxIn
 class CTxOut
 {
 public:
-    CAmount nValue;
+    CConfidentialAsset nAsset;
+    CConfidentialValue nValue;
+    CConfidentialNonce nNonce;
     CScript scriptPubKey;
 
     CTxOut()
@@ -235,30 +247,58 @@ class CTxOut
         SetNull();
     }
 
-    CTxOut(const CAmount& nValueIn, CScript scriptPubKeyIn);
+    CTxOut(const CConfidentialAsset& nAssetIn, const CConfidentialValue& nValueIn, CScript scriptPubKeyIn);
 
     ADD_SERIALIZE_METHODS;
 
     template <typename Stream, typename Operation>
     inline void SerializationOp(Stream& s, Operation ser_action) {
-        READWRITE(nValue);
-        READWRITE(scriptPubKey);
+        if (g_con_elementsmode) {
+            READWRITE(nAsset);
+            READWRITE(nValue);
+            READWRITE(nNonce);
+            READWRITE(scriptPubKey);
+        } else {
+            CAmount value;
+            if (!ser_action.ForRead()) {
+                value = nValue.GetAmount();
+            }
+            READWRITE(value);
+            if (ser_action.ForRead()) {
+                nValue.SetToAmount(value);
+            }
+            READWRITE(scriptPubKey);
+        }
     }
 
     void SetNull()
     {
-        nValue = -1;
+        nAsset.SetNull();
+        nValue.SetNull();
+        nNonce.SetNull();
         scriptPubKey.clear();
     }
 
     bool IsNull() const
     {
-        return (nValue == -1);
+        if (!g_con_elementsmode) {
+            // Ignore the asset and the nonce in compatibility mode.
+            return nValue.IsNull() && scriptPubKey.empty();
+        }
+
+        return nAsset.IsNull() && nValue.IsNull() && nNonce.IsNull() && scriptPubKey.empty();
+    }
+
+    bool IsFee() const {
+        return g_con_elementsmode && scriptPubKey == CScript()
+            && nValue.IsExplicit() && nAsset.IsExplicit();
     }
 
     friend bool operator==(const CTxOut& a, const CTxOut& b)
     {
-        return (a.nValue       == b.nValue &&
+        return (a.nAsset == b.nAsset &&
+                a.nValue == b.nValue &&
+                a.nNonce == b.nNonce &&
                 a.scriptPubKey == b.scriptPubKey);
     }
 
@@ -300,7 +340,7 @@ inline void UnserializeTransaction(TxType& tx, Stream& s) {
 
     // Witness serialization is different between Elements and Core.
     // See code comments in SerializeTransaction for details about the differences.
-    if (g_con_elementswitness) {
+    if (g_con_elementsmode) {
         s >> flags;
         s >> tx.vin;
         s >> tx.vout;
@@ -368,7 +408,7 @@ inline void SerializeTransaction(const TxType& tx, Stream& s) {
     }
 
     // Witness serialization is different between Elements and Core.
-    if (g_con_elementswitness) {
+    if (g_con_elementsmode) {
         // In Elements-style serialization, all normal data is serialized first and the
         // witnesses all in the end.
         s << flags;
@@ -472,7 +512,7 @@ class CTransaction
     uint256 GetWitnessOnlyHash() const;
 
     // Return sum of txouts.
-    CAmount GetValueOut() const;
+    CAmountMap GetValueOutMap() const;
     // GetValueIn() is a method on CCoinsViewCache, because
     // inputs must be known to compute value in.
 
diff --git a/src/primitives/txwitness.cpp b/src/primitives/txwitness.cpp
index e62bedaaeb19c..ddfedb5ea09af 100644
--- a/src/primitives/txwitness.cpp
+++ b/src/primitives/txwitness.cpp
@@ -16,9 +16,8 @@
 uint256 CTxInWitness::GetHash() const
 {
     std::vector<uint256> leaves;
-    //TODO(rebase) CA/CT
-    //leaves.push_back(SerializeHash(vchIssuanceAmountRangeproof, SER_GETHASH, 0));
-    //leaves.push_back(SerializeHash(vchInflationKeysRangeproof, SER_GETHASH, 0));
+    leaves.push_back(SerializeHash(vchIssuanceAmountRangeproof, SER_GETHASH, 0));
+    leaves.push_back(SerializeHash(vchInflationKeysRangeproof, SER_GETHASH, 0));
     leaves.push_back(SerializeHash(scriptWitness.stack, SER_GETHASH, 0));
     leaves.push_back(SerializeHash(m_pegin_witness.stack, SER_GETHASH, 0));
     return ComputeFastMerkleRoot(leaves);
diff --git a/src/primitives/txwitness.h b/src/primitives/txwitness.h
index 23a1bd2a53ded..1071c1c7c04e4 100644
--- a/src/primitives/txwitness.h
+++ b/src/primitives/txwitness.h
@@ -5,16 +5,15 @@
 #ifndef BITCOIN_PRIMITIVES_TXWITNESS_H
 #define BITCOIN_PRIMITIVES_TXWITNESS_H
 
+#include <primitives/confidential.h>
 #include <script/script.h>
 #include <uint256.h>
 
 class CTxInWitness
 {
 public:
-    // TODO generalize CScriptWitness into just CWitness
-    //TODO(rebase) CA/CT
-    //std::vector<unsigned char> vchIssuanceAmountRangeproof;
-    //std::vector<unsigned char> vchInflationKeysRangeproof;
+    std::vector<unsigned char> vchIssuanceAmountRangeproof;
+    std::vector<unsigned char> vchInflationKeysRangeproof;
     CScriptWitness scriptWitness;
     // Re-use script witness struct to include its own witness
     CScriptWitness m_pegin_witness;
@@ -24,8 +23,8 @@ class CTxInWitness
     template <typename Stream, typename Operation>
     inline void SerializationOp(Stream& s, Operation ser_action)
     {
-        //READWRITE(vchIssuanceAmountRangeproof);
-        //READWRITE(vchInflationKeysRangeproof);
+        READWRITE(vchIssuanceAmountRangeproof);
+        READWRITE(vchInflationKeysRangeproof);
         READWRITE(scriptWitness.stack);
         READWRITE(m_pegin_witness.stack);
     }
@@ -34,13 +33,12 @@ class CTxInWitness
 
     bool IsNull() const
     {
-        //return vchIssuanceAmountRangeproof.empty() && vchInflationKeysRangeproof.empty() && scriptWitness.IsNull() && m_pegin_witness.IsNull();
-        return scriptWitness.IsNull() && m_pegin_witness.IsNull();
+        return vchIssuanceAmountRangeproof.empty() && vchInflationKeysRangeproof.empty() && scriptWitness.IsNull() && m_pegin_witness.IsNull();
     }
     void SetNull()
     {
-        //vchIssuanceAmountRangeproof.clear();
-        //vchInflationKeysRangeproof.clear();
+        vchIssuanceAmountRangeproof.clear();
+        vchInflationKeysRangeproof.clear();
         scriptWitness.stack.clear();
         m_pegin_witness.stack.clear();
     }
@@ -107,15 +105,13 @@ class CTxWitness
         for (size_t n = 0; n < vtxinwit.size(); n++) {
             READWRITE(vtxinwit[n]);
         }
-        //TODO(rebase) CA/CT
-        //for (size_t n = 0; n < vtxoutwit.size(); n++) {
-        //    READWRITE(vtxoutwit[n]);
-        //}
-        //TODO(stevenroose) re-enabled after testing
-        //if (IsNull()) {
-        //    /* It's illegal to encode a witness when all vtxinwit and vtxoutwit entries are empty. */
-        //    throw std::ios_base::failure("Superfluous witness record");
-        //}
+        for (size_t n = 0; n < vtxoutwit.size(); n++) {
+            READWRITE(vtxoutwit[n]);
+        }
+        if (IsNull()) {
+            /* It's illegal to encode a witness when all vtxinwit and vtxoutwit entries are empty. */
+            throw std::ios_base::failure("Superfluous witness record");
+        }
     }
 
     bool IsEmpty() const
diff --git a/src/qt/coincontroldialog.cpp b/src/qt/coincontroldialog.cpp
index 68330c51fa52c..12526717e855c 100644
--- a/src/qt/coincontroldialog.cpp
+++ b/src/qt/coincontroldialog.cpp
@@ -419,7 +419,7 @@ void CoinControlDialog::updateLabels(WalletModel *model, QDialog* dialog)
 
         if (amount > 0)
         {
-            CTxOut txout(amount, static_cast<CScript>(std::vector<unsigned char>(24, 0)));
+            CTxOut txout(::policyAsset, amount, static_cast<CScript>(std::vector<unsigned char>(24, 0)));
             txDummy.vout.push_back(txout);
             fDust |= IsDust(txout, model->node().getDustRelayFee());
         }
@@ -454,7 +454,7 @@ void CoinControlDialog::updateLabels(WalletModel *model, QDialog* dialog)
         nQuantity++;
 
         // Amount
-        nAmount += out.txout.nValue;
+        nAmount += out.txout.nValue.GetAmount();
 
         // Bytes
         CTxDestination address;
@@ -468,8 +468,8 @@ void CoinControlDialog::updateLabels(WalletModel *model, QDialog* dialog)
         else if(ExtractDestination(out.txout.scriptPubKey, address))
         {
             CPubKey pubkey;
-            CKeyID *keyid = boost::get<CKeyID>(&address);
-            if (keyid && model->wallet().getPubKey(*keyid, pubkey))
+            PKHash *keyid = boost::get<PKHash>(&address);
+            if (keyid && model->wallet().getPubKey(CKeyID(*keyid), pubkey))
             {
                 nBytesInputs += (pubkey.IsCompressed() ? 148 : 180);
             }
@@ -510,7 +510,7 @@ void CoinControlDialog::updateLabels(WalletModel *model, QDialog* dialog)
             // Never create dust outputs; if we would, just add the dust to the fee.
             if (nChange > 0 && nChange < MIN_CHANGE)
             {
-                CTxOut txout(nChange, static_cast<CScript>(std::vector<unsigned char>(24, 0)));
+                CTxOut txout(::policyAsset, nChange, static_cast<CScript>(std::vector<unsigned char>(24, 0)));
                 if (IsDust(txout, model->node().getDustRelayFee()))
                 {
                     nPayFee += nChange;
@@ -639,7 +639,7 @@ void CoinControlDialog::updateView()
         for (const auto& outpair : coins.second) {
             const COutPoint& output = std::get<0>(outpair);
             const interfaces::WalletTxOut& out = std::get<1>(outpair);
-            nSum += out.txout.nValue;
+            nSum += out.txout.nValue.GetAmount();
             nChildren++;
 
             CCoinControlWidgetItem *itemOutput;
@@ -676,8 +676,8 @@ void CoinControlDialog::updateView()
             }
 
             // amount
-            itemOutput->setText(COLUMN_AMOUNT, BitcoinUnits::format(nDisplayUnit, out.txout.nValue));
-            itemOutput->setData(COLUMN_AMOUNT, Qt::UserRole, QVariant((qlonglong)out.txout.nValue)); // padding so that sorting works correctly
+            itemOutput->setText(COLUMN_AMOUNT, BitcoinUnits::format(nDisplayUnit, out.txout.nValue.GetAmount()));
+            itemOutput->setData(COLUMN_AMOUNT, Qt::UserRole, QVariant((qlonglong)out.txout.nValue.GetAmount())); // padding so that sorting works correctly
 
             // date
             itemOutput->setText(COLUMN_DATE, GUIUtil::dateTimeStr(out.time));
diff --git a/src/qt/guiutil.cpp b/src/qt/guiutil.cpp
index ad137438141eb..77d99ad307b53 100644
--- a/src/qt/guiutil.cpp
+++ b/src/qt/guiutil.cpp
@@ -9,6 +9,7 @@
 #include <qt/qvalidatedlineedit.h>
 #include <qt/walletmodel.h>
 
+#include <asset.h>
 #include <base58.h>
 #include <chainparams.h>
 #include <primitives/transaction.h>
@@ -211,7 +212,7 @@ bool isDust(interfaces::Node& node, const QString& address, const CAmount& amoun
 {
     CTxDestination dest = DecodeDestination(address.toStdString());
     CScript script = GetScriptForDestination(dest);
-    CTxOut txOut(amount, script);
+    CTxOut txOut(CAsset(), amount, script);
     return IsDust(txOut, node.getDustRelayFee());
 }
 
diff --git a/src/qt/overviewpage.cpp b/src/qt/overviewpage.cpp
index 1db9609979d2a..465086e3426ec 100644
--- a/src/qt/overviewpage.cpp
+++ b/src/qt/overviewpage.cpp
@@ -15,6 +15,8 @@
 #include <qt/transactiontablemodel.h>
 #include <qt/walletmodel.h>
 
+#include <policy/policy.h>
+
 #include <QAbstractItemDelegate>
 #include <QPainter>
 
@@ -119,7 +121,7 @@ OverviewPage::OverviewPage(const PlatformStyle *platformStyle, QWidget *parent)
 {
     ui->setupUi(this);
 
-    m_balances.balance = -1;
+    m_balances.balance[::policyAsset] = -1;
 
     // use a SingleColorIcon for the "out of sync warning" icon
     QIcon icon = platformStyle->SingleColorIcon(":/icons/warning");
@@ -161,19 +163,19 @@ void OverviewPage::setBalance(const interfaces::WalletBalances& balances)
 {
     int unit = walletModel->getOptionsModel()->getDisplayUnit();
     m_balances = balances;
-    ui->labelBalance->setText(BitcoinUnits::formatWithUnit(unit, balances.balance, false, BitcoinUnits::separatorAlways));
-    ui->labelUnconfirmed->setText(BitcoinUnits::formatWithUnit(unit, balances.unconfirmed_balance, false, BitcoinUnits::separatorAlways));
-    ui->labelImmature->setText(BitcoinUnits::formatWithUnit(unit, balances.immature_balance, false, BitcoinUnits::separatorAlways));
-    ui->labelTotal->setText(BitcoinUnits::formatWithUnit(unit, balances.balance + balances.unconfirmed_balance + balances.immature_balance, false, BitcoinUnits::separatorAlways));
-    ui->labelWatchAvailable->setText(BitcoinUnits::formatWithUnit(unit, balances.watch_only_balance, false, BitcoinUnits::separatorAlways));
-    ui->labelWatchPending->setText(BitcoinUnits::formatWithUnit(unit, balances.unconfirmed_watch_only_balance, false, BitcoinUnits::separatorAlways));
-    ui->labelWatchImmature->setText(BitcoinUnits::formatWithUnit(unit, balances.immature_watch_only_balance, false, BitcoinUnits::separatorAlways));
-    ui->labelWatchTotal->setText(BitcoinUnits::formatWithUnit(unit, balances.watch_only_balance + balances.unconfirmed_watch_only_balance + balances.immature_watch_only_balance, false, BitcoinUnits::separatorAlways));
+    ui->labelBalance->setText(BitcoinUnits::formatWithUnit(unit, valueFor(balances.balance, ::policyAsset), false, BitcoinUnits::separatorAlways));
+    ui->labelUnconfirmed->setText(BitcoinUnits::formatWithUnit(unit, valueFor(balances.unconfirmed_balance, ::policyAsset), false, BitcoinUnits::separatorAlways));
+    ui->labelImmature->setText(BitcoinUnits::formatWithUnit(unit, valueFor(balances.immature_balance, ::policyAsset), false, BitcoinUnits::separatorAlways));
+    ui->labelTotal->setText(BitcoinUnits::formatWithUnit(unit, valueFor(balances.balance, ::policyAsset) + valueFor(balances.unconfirmed_balance, ::policyAsset) + valueFor(balances.immature_balance, ::policyAsset), false, BitcoinUnits::separatorAlways));
+    ui->labelWatchAvailable->setText(BitcoinUnits::formatWithUnit(unit, valueFor(balances.watch_only_balance, ::policyAsset), false, BitcoinUnits::separatorAlways));
+    ui->labelWatchPending->setText(BitcoinUnits::formatWithUnit(unit, valueFor(balances.unconfirmed_watch_only_balance, ::policyAsset), false, BitcoinUnits::separatorAlways));
+    ui->labelWatchImmature->setText(BitcoinUnits::formatWithUnit(unit, valueFor(balances.immature_watch_only_balance, ::policyAsset), false, BitcoinUnits::separatorAlways));
+    ui->labelWatchTotal->setText(BitcoinUnits::formatWithUnit(unit, valueFor(balances.watch_only_balance, ::policyAsset) + valueFor(balances.unconfirmed_watch_only_balance, ::policyAsset) + valueFor(balances.immature_watch_only_balance, ::policyAsset), false, BitcoinUnits::separatorAlways));
 
     // only show immature (newly mined) balance if it's non-zero, so as not to complicate things
     // for the non-mining users
-    bool showImmature = balances.immature_balance != 0;
-    bool showWatchOnlyImmature = balances.immature_watch_only_balance != 0;
+    bool showImmature = valueFor(balances.immature_balance, ::policyAsset) != 0;
+    bool showWatchOnlyImmature = valueFor(balances.immature_watch_only_balance, ::policyAsset) != 0;
 
     // for symmetry reasons also show immature label when the watch-only one is shown
     ui->labelImmature->setVisible(showImmature || showWatchOnlyImmature);
@@ -243,7 +245,7 @@ void OverviewPage::updateDisplayUnit()
 {
     if(walletModel && walletModel->getOptionsModel())
     {
-        if (m_balances.balance != -1) {
+        if (m_balances.balance[::policyAsset] != -1) {
             setBalance(m_balances);
         }
 
diff --git a/src/qt/paymentserver.cpp b/src/qt/paymentserver.cpp
index bcafc8f859f9a..43fc614871ec9 100644
--- a/src/qt/paymentserver.cpp
+++ b/src/qt/paymentserver.cpp
@@ -566,7 +566,7 @@ bool PaymentServer::processPaymentRequest(const PaymentRequestPlus& request, Sen
         }
 
         // Extract and check amounts
-        CTxOut txOut(sendingTo.second, sendingTo.first);
+        CTxOut txOut(::policyAsset, sendingTo.second, sendingTo.first);
         if (IsDust(txOut, optionsModel->node().getDustRelayFee())) {
             Q_EMIT message(tr("Payment request error"), tr("Requested payment amount of %1 is too small (considered dust).")
                 .arg(BitcoinUnits::formatWithUnit(optionsModel->getDisplayUnit(), sendingTo.second)),
diff --git a/src/qt/sendcoinsdialog.cpp b/src/qt/sendcoinsdialog.cpp
index 6f66bc19e1002..0a268f7898e7a 100644
--- a/src/qt/sendcoinsdialog.cpp
+++ b/src/qt/sendcoinsdialog.cpp
@@ -21,6 +21,7 @@
 #include <ui_interface.h>
 #include <txmempool.h>
 #include <policy/fees.h>
+#include <policy/policy.h>
 #include <wallet/fees.h>
 
 #include <QFontMetrics>
@@ -526,7 +527,7 @@ void SendCoinsDialog::setBalance(const interfaces::WalletBalances& balances)
 {
     if(model && model->getOptionsModel())
     {
-        ui->labelBalance->setText(BitcoinUnits::formatWithUnit(model->getOptionsModel()->getDisplayUnit(), balances.balance));
+        ui->labelBalance->setText(BitcoinUnits::formatWithUnit(model->getOptionsModel()->getDisplayUnit(), valueFor(balances.balance, ::policyAsset)));
     }
 }
 
@@ -618,7 +619,7 @@ void SendCoinsDialog::useAvailableBalance(SendCoinsEntry* entry)
     }
 
     // Calculate available amount to send.
-    CAmount amount = model->wallet().getAvailableBalance(coin_control);
+    CAmount amount = valueFor(model->wallet().getAvailableBalance(coin_control), ::policyAsset);
     for (int i = 0; i < ui->entries->count(); ++i) {
         SendCoinsEntry* e = qobject_cast<SendCoinsEntry*>(ui->entries->itemAt(i)->widget());
         if (e && !e->isHidden() && e != entry) {
@@ -784,7 +785,8 @@ void SendCoinsDialog::coinControlChangeChecked(int state)
 {
     if (state == Qt::Unchecked)
     {
-        CoinControlDialog::coinControl()->destChange = CNoDestination();
+        // ELEMENTS: it's a map now, should be initialized automatically
+        //CoinControlDialog::coinControl()->destChange = CNoDestination();
         ui->labelCoinControlChangeLabel->clear();
     }
     else
@@ -800,7 +802,8 @@ void SendCoinsDialog::coinControlChangeEdited(const QString& text)
     if (model && model->getAddressTableModel())
     {
         // Default to no change address until verified
-        CoinControlDialog::coinControl()->destChange = CNoDestination();
+        // ELEMENTS: it's a map now, should be initialized automatically
+        //CoinControlDialog::coinControl()->destChange = CNoDestination();
         ui->labelCoinControlChangeLabel->setStyleSheet("QLabel{color:red;}");
 
         const CTxDestination dest = DecodeDestination(text.toStdString());
@@ -822,8 +825,10 @@ void SendCoinsDialog::coinControlChangeEdited(const QString& text)
                 QMessageBox::StandardButton btnRetVal = QMessageBox::question(this, tr("Confirm custom change address"), tr("The address you selected for change is not part of this wallet. Any or all funds in your wallet may be sent to this address. Are you sure?"),
                     QMessageBox::Yes | QMessageBox::Cancel, QMessageBox::Cancel);
 
-                if(btnRetVal == QMessageBox::Yes)
-                    CoinControlDialog::coinControl()->destChange = dest;
+                if(btnRetVal == QMessageBox::Yes) {
+                    // ELEMENTS: it's a map now
+                    //CoinControlDialog::coinControl()->destChange = dest;
+                }
                 else
                 {
                     ui->lineEditCoinControlChange->setText("");
@@ -842,7 +847,8 @@ void SendCoinsDialog::coinControlChangeEdited(const QString& text)
                 else
                     ui->labelCoinControlChangeLabel->setText(tr("(no label)"));
 
-                CoinControlDialog::coinControl()->destChange = dest;
+                // ELEMENTS: it's a map now
+                //CoinControlDialog::coinControl()->destChange = dest;
             }
         }
     }
diff --git a/src/qt/signverifymessagedialog.cpp b/src/qt/signverifymessagedialog.cpp
index 487fc9ee1e823..12c4ca09ab73b 100644
--- a/src/qt/signverifymessagedialog.cpp
+++ b/src/qt/signverifymessagedialog.cpp
@@ -120,7 +120,7 @@ void SignVerifyMessageDialog::on_signMessageButton_SM_clicked()
         ui->statusLabel_SM->setText(tr("The entered address is invalid.") + QString(" ") + tr("Please check the address and try again."));
         return;
     }
-    const CKeyID* keyID = boost::get<CKeyID>(&destination);
+    const PKHash* keyID = boost::get<PKHash>(&destination);
     if (!keyID) {
         ui->addressIn_SM->setValid(false);
         ui->statusLabel_SM->setStyleSheet("QLabel { color: red; }");
@@ -137,7 +137,7 @@ void SignVerifyMessageDialog::on_signMessageButton_SM_clicked()
     }
 
     CKey key;
-    if (!model->wallet().getPrivKey(*keyID, key))
+    if (!model->wallet().getPrivKey(CKeyID(*keyID), key))
     {
         ui->statusLabel_SM->setStyleSheet("QLabel { color: red; }");
         ui->statusLabel_SM->setText(tr("Private key for the entered address is not available."));
@@ -198,7 +198,7 @@ void SignVerifyMessageDialog::on_verifyMessageButton_VM_clicked()
         ui->statusLabel_VM->setText(tr("The entered address is invalid.") + QString(" ") + tr("Please check the address and try again."));
         return;
     }
-    if (!boost::get<CKeyID>(&destination)) {
+    if (!boost::get<PKHash>(&destination)) {
         ui->addressIn_VM->setValid(false);
         ui->statusLabel_VM->setStyleSheet("QLabel { color: red; }");
         ui->statusLabel_VM->setText(tr("The entered address does not refer to a key.") + QString(" ") + tr("Please check the address and try again."));
@@ -229,7 +229,7 @@ void SignVerifyMessageDialog::on_verifyMessageButton_VM_clicked()
         return;
     }
 
-    if (!(CTxDestination(pubkey.GetID()) == destination)) {
+    if (!(CTxDestination(PKHash(pubkey.GetID())) == destination)) {
         ui->statusLabel_VM->setStyleSheet("QLabel { color: red; }");
         ui->statusLabel_VM->setText(QString("<nobr>") + tr("Message verification failed.") + QString("</nobr>"));
         return;
diff --git a/src/qt/test/wallettests.cpp b/src/qt/test/wallettests.cpp
index a0cfe8ae8786c..701295ac5d7ea 100644
--- a/src/qt/test/wallettests.cpp
+++ b/src/qt/test/wallettests.cpp
@@ -13,6 +13,7 @@
 #include <qt/transactionview.h>
 #include <qt/walletmodel.h>
 #include <key_io.h>
+#include <policy/policy.h>
 #include <test/test_bitcoin.h>
 #include <validation.h>
 #include <wallet/wallet.h>
@@ -164,8 +165,8 @@ void TestGUI()
     // Send two transactions, and verify they are added to transaction list.
     TransactionTableModel* transactionTableModel = walletModel.getTransactionTableModel();
     QCOMPARE(transactionTableModel->rowCount({}), 105);
-    uint256 txid1 = SendCoins(*wallet.get(), sendCoinsDialog, CKeyID(), 5 * COIN, false /* rbf */);
-    uint256 txid2 = SendCoins(*wallet.get(), sendCoinsDialog, CKeyID(), 10 * COIN, true /* rbf */);
+    uint256 txid1 = SendCoins(*wallet.get(), sendCoinsDialog, PKHash(), 5 * COIN, false /* rbf */);
+    uint256 txid2 = SendCoins(*wallet.get(), sendCoinsDialog, PKHash(), 10 * COIN, true /* rbf */);
     QCOMPARE(transactionTableModel->rowCount({}), 107);
     QVERIFY(FindTx(*transactionTableModel, txid1).isValid());
     QVERIFY(FindTx(*transactionTableModel, txid2).isValid());
@@ -182,7 +183,7 @@ void TestGUI()
     QLabel* balanceLabel = overviewPage.findChild<QLabel*>("labelBalance");
     QString balanceText = balanceLabel->text();
     int unit = walletModel.getOptionsModel()->getDisplayUnit();
-    CAmount balance = walletModel.wallet().getBalance();
+    CAmount balance = valueFor(walletModel.wallet().getBalance(), ::policyAsset);
     QString balanceComparison = BitcoinUnits::formatWithUnit(unit, balance, false, BitcoinUnits::separatorAlways);
     QCOMPARE(balanceText, balanceComparison);
 
diff --git a/src/qt/transactiondesc.cpp b/src/qt/transactiondesc.cpp
index 59332be7547f0..00ba85dcbdf54 100644
--- a/src/qt/transactiondesc.cpp
+++ b/src/qt/transactiondesc.cpp
@@ -61,8 +61,8 @@ QString TransactionDesc::toHTML(interfaces::Node& node, interfaces::Wallet& wall
     strHTML += "<html><font face='verdana, arial, helvetica, sans-serif'>";
 
     int64_t nTime = wtx.time;
-    CAmount nCredit = wtx.credit;
-    CAmount nDebit = wtx.debit;
+    CAmount nCredit = valueFor(wtx.credit, ::policyAsset);
+    CAmount nDebit = valueFor(wtx.debit, ::policyAsset);
     CAmount nNet = nCredit - nDebit;
 
     strHTML += "<b>" + tr("Status") + ":</b> " + FormatTxStatus(wtx, status, inMempool, numBlocks, adjustedTime);
@@ -134,7 +134,7 @@ QString TransactionDesc::toHTML(interfaces::Node& node, interfaces::Wallet& wall
         //
         CAmount nUnmatured = 0;
         for (const CTxOut& txout : wtx.tx->vout)
-            nUnmatured += wallet.getCredit(txout, ISMINE_ALL);
+            nUnmatured += valueFor(wallet.getCredit(txout, ISMINE_ALL), ::policyAsset);
         strHTML += "<b>" + tr("Credit") + ":</b> ";
         if (status.is_in_main_chain)
             strHTML += BitcoinUnits::formatHtmlWithUnit(unit, nUnmatured)+ " (" + tr("matures in %n more block(s)", "", status.blocks_to_maturity) + ")";
@@ -199,21 +199,21 @@ QString TransactionDesc::toHTML(interfaces::Node& node, interfaces::Wallet& wall
                     }
                 }
 
-                strHTML += "<b>" + tr("Debit") + ":</b> " + BitcoinUnits::formatHtmlWithUnit(unit, -txout.nValue) + "<br>";
+                strHTML += "<b>" + tr("Debit") + ":</b> " + BitcoinUnits::formatHtmlWithUnit(unit, -txout.nValue.GetAmount()) + "<br>";
                 if(toSelf)
-                    strHTML += "<b>" + tr("Credit") + ":</b> " + BitcoinUnits::formatHtmlWithUnit(unit, txout.nValue) + "<br>";
+                    strHTML += "<b>" + tr("Credit") + ":</b> " + BitcoinUnits::formatHtmlWithUnit(unit, txout.nValue.GetAmount()) + "<br>";
             }
 
             if (fAllToMe)
             {
                 // Payment to self
-                CAmount nChange = wtx.change;
+                CAmount nChange = valueFor(wtx.change, ::policyAsset);
                 CAmount nValue = nCredit - nChange;
                 strHTML += "<b>" + tr("Total debit") + ":</b> " + BitcoinUnits::formatHtmlWithUnit(unit, -nValue) + "<br>";
                 strHTML += "<b>" + tr("Total credit") + ":</b> " + BitcoinUnits::formatHtmlWithUnit(unit, nValue) + "<br>";
             }
 
-            CAmount nTxFee = nDebit - wtx.tx->GetValueOut();
+            CAmount nTxFee = nDebit - valueFor(wtx.tx->GetValueOutMap(), ::policyAsset);
             if (nTxFee > 0)
                 strHTML += "<b>" + tr("Transaction fee") + ":</b> " + BitcoinUnits::formatHtmlWithUnit(unit, -nTxFee) + "<br>";
         }
@@ -225,13 +225,13 @@ QString TransactionDesc::toHTML(interfaces::Node& node, interfaces::Wallet& wall
             auto mine = wtx.txin_is_mine.begin();
             for (const CTxIn& txin : wtx.tx->vin) {
                 if (*(mine++)) {
-                    strHTML += "<b>" + tr("Debit") + ":</b> " + BitcoinUnits::formatHtmlWithUnit(unit, -wallet.getDebit(txin, ISMINE_ALL)) + "<br>";
+                    strHTML += "<b>" + tr("Debit") + ":</b> " + BitcoinUnits::formatHtmlWithUnit(unit, -valueFor(wallet.getDebit(txin, ISMINE_ALL), ::policyAsset)) + "<br>";
                 }
             }
             mine = wtx.txout_is_mine.begin();
             for (const CTxOut& txout : wtx.tx->vout) {
                 if (*(mine++)) {
-                    strHTML += "<b>" + tr("Credit") + ":</b> " + BitcoinUnits::formatHtmlWithUnit(unit, wallet.getCredit(txout, ISMINE_ALL)) + "<br>";
+                    strHTML += "<b>" + tr("Credit") + ":</b> " + BitcoinUnits::formatHtmlWithUnit(unit, valueFor(wallet.getCredit(txout, ISMINE_ALL), ::policyAsset)) + "<br>";
                 }
             }
         }
@@ -286,10 +286,10 @@ QString TransactionDesc::toHTML(interfaces::Node& node, interfaces::Wallet& wall
         strHTML += "<hr><br>" + tr("Debug information") + "<br><br>";
         for (const CTxIn& txin : wtx.tx->vin)
             if(wallet.txinIsMine(txin))
-                strHTML += "<b>" + tr("Debit") + ":</b> " + BitcoinUnits::formatHtmlWithUnit(unit, -wallet.getDebit(txin, ISMINE_ALL)) + "<br>";
+                strHTML += "<b>" + tr("Debit") + ":</b> " + BitcoinUnits::formatHtmlWithUnit(unit, -valueFor(wallet.getDebit(txin, ISMINE_ALL), ::policyAsset)) + "<br>";
         for (const CTxOut& txout : wtx.tx->vout)
             if(wallet.txoutIsMine(txout))
-                strHTML += "<b>" + tr("Credit") + ":</b> " + BitcoinUnits::formatHtmlWithUnit(unit, wallet.getCredit(txout, ISMINE_ALL)) + "<br>";
+                strHTML += "<b>" + tr("Credit") + ":</b> " + BitcoinUnits::formatHtmlWithUnit(unit, valueFor(wallet.getCredit(txout, ISMINE_ALL), ::policyAsset)) + "<br>";
 
         strHTML += "<br><b>" + tr("Transaction") + ":</b><br>";
         strHTML += GUIUtil::HtmlEscape(wtx.tx->ToString(), true);
@@ -315,7 +315,7 @@ QString TransactionDesc::toHTML(interfaces::Node& node, interfaces::Wallet& wall
                             strHTML += GUIUtil::HtmlEscape(name) + " ";
                         strHTML += QString::fromStdString(EncodeDestination(address));
                     }
-                    strHTML = strHTML + " " + tr("Amount") + "=" + BitcoinUnits::formatHtmlWithUnit(unit, vout.nValue);
+                    strHTML = strHTML + " " + tr("Amount") + "=" + BitcoinUnits::formatHtmlWithUnit(unit, vout.nValue.GetAmount());
                     strHTML = strHTML + " IsMine=" + (wallet.txoutIsMine(vout) & ISMINE_SPENDABLE ? tr("true") : tr("false")) + "</li>";
                     strHTML = strHTML + " IsWatchOnly=" + (wallet.txoutIsMine(vout) & ISMINE_WATCH_ONLY ? tr("true") : tr("false")) + "</li>";
                 }
diff --git a/src/qt/transactionrecord.cpp b/src/qt/transactionrecord.cpp
index d1a7527ac77cd..5dd1f9190206f 100644
--- a/src/qt/transactionrecord.cpp
+++ b/src/qt/transactionrecord.cpp
@@ -7,6 +7,7 @@
 #include <consensus/consensus.h>
 #include <interfaces/wallet.h>
 #include <key_io.h>
+#include <policy/policy.h>
 #include <timedata.h>
 #include <validation.h>
 
@@ -29,8 +30,8 @@ QList<TransactionRecord> TransactionRecord::decomposeTransaction(const interface
 {
     QList<TransactionRecord> parts;
     int64_t nTime = wtx.time;
-    CAmount nCredit = wtx.credit;
-    CAmount nDebit = wtx.debit;
+    CAmount nCredit = valueFor(wtx.credit, ::policyAsset);
+    CAmount nDebit = valueFor(wtx.debit, ::policyAsset);
     CAmount nNet = nCredit - nDebit;
     uint256 hash = wtx.tx->GetHash();
     std::map<std::string, std::string> mapValue = wtx.value_map;
@@ -49,7 +50,7 @@ QList<TransactionRecord> TransactionRecord::decomposeTransaction(const interface
                 TransactionRecord sub(hash, nTime);
                 CTxDestination address;
                 sub.idx = i; // vout index
-                sub.credit = txout.nValue;
+                sub.credit = txout.nValue.GetAmount();
                 sub.involvesWatchAddress = mine & ISMINE_WATCH_ONLY;
                 if (wtx.txout_address_is_mine[i])
                 {
@@ -93,7 +94,7 @@ QList<TransactionRecord> TransactionRecord::decomposeTransaction(const interface
         if (fAllFromMe && fAllToMe)
         {
             // Payment to self
-            CAmount nChange = wtx.change;
+            CAmount nChange = valueFor(wtx.change, ::policyAsset);
 
             parts.append(TransactionRecord(hash, nTime, TransactionRecord::SendToSelf, "",
                             -(nDebit - nChange), nCredit - nChange));
@@ -104,7 +105,7 @@ QList<TransactionRecord> TransactionRecord::decomposeTransaction(const interface
             //
             // Debit
             //
-            CAmount nTxFee = nDebit - wtx.tx->GetValueOut();
+            CAmount nTxFee = nDebit - wtx.tx->GetValueOutMap()[::policyAsset];
 
             for (unsigned int nOut = 0; nOut < wtx.tx->vout.size(); nOut++)
             {
@@ -133,7 +134,7 @@ QList<TransactionRecord> TransactionRecord::decomposeTransaction(const interface
                     sub.address = mapValue["to"];
                 }
 
-                CAmount nValue = txout.nValue;
+                CAmount nValue = txout.nValue.GetAmount();
                 /* Add fee to first output */
                 if (nTxFee > 0)
                 {
diff --git a/src/qt/walletmodel.cpp b/src/qt/walletmodel.cpp
index f7cc94ae32c81..5a6e650aba104 100644
--- a/src/qt/walletmodel.cpp
+++ b/src/qt/walletmodel.cpp
@@ -15,6 +15,7 @@
 #include <interfaces/handler.h>
 #include <interfaces/node.h>
 #include <key_io.h>
+#include <policy/policy.h>
 #include <ui_interface.h>
 #include <util.h> // for GetBoolArg
 #include <wallet/coincontrol.h>
@@ -154,7 +155,7 @@ WalletModel::SendCoinsReturn WalletModel::prepareTransaction(WalletModelTransact
                 const unsigned char* scriptStr = (const unsigned char*)out.script().data();
                 CScript scriptPubKey(scriptStr, scriptStr+out.script().size());
                 CAmount nAmount = out.amount();
-                CRecipient recipient = {scriptPubKey, nAmount, rcp.fSubtractFeeFromAmount};
+                CRecipient recipient = {scriptPubKey, nAmount, ::policyAsset, CPubKey(), rcp.fSubtractFeeFromAmount};
                 vecSend.push_back(recipient);
             }
             if (subtotal <= 0)
@@ -177,7 +178,7 @@ WalletModel::SendCoinsReturn WalletModel::prepareTransaction(WalletModelTransact
             ++nAddresses;
 
             CScript scriptPubKey = GetScriptForDestination(DecodeDestination(rcp.address.toStdString()));
-            CRecipient recipient = {scriptPubKey, rcp.amount, rcp.fSubtractFeeFromAmount};
+            CRecipient recipient = {scriptPubKey, rcp.amount, ::policyAsset, CPubKey(), rcp.fSubtractFeeFromAmount};
             vecSend.push_back(recipient);
 
             total += rcp.amount;
@@ -188,7 +189,7 @@ WalletModel::SendCoinsReturn WalletModel::prepareTransaction(WalletModelTransact
         return DuplicateAddress;
     }
 
-    CAmount nBalance = m_wallet->getAvailableBalance(coinControl);
+    CAmount nBalance = m_wallet->getAvailableBalance(coinControl)[::policyAsset];
 
     if(total > nBalance)
     {
diff --git a/src/qt/walletmodeltransaction.cpp b/src/qt/walletmodeltransaction.cpp
index de506164994fd..821b158a4fdd4 100644
--- a/src/qt/walletmodeltransaction.cpp
+++ b/src/qt/walletmodeltransaction.cpp
@@ -56,7 +56,7 @@ void WalletModelTransaction::reassignAmounts(int nChangePosRet)
                 if (out.amount() <= 0) continue;
                 if (i == nChangePosRet)
                     i++;
-                subtotal += walletTransaction->vout[i].nValue;
+                subtotal += walletTransaction->vout[i].nValue.GetAmount();
                 i++;
             }
             rcp.amount = subtotal;
@@ -65,7 +65,7 @@ void WalletModelTransaction::reassignAmounts(int nChangePosRet)
         {
             if (i == nChangePosRet)
                 i++;
-            rcp.amount = walletTransaction->vout[i].nValue;
+            rcp.amount = walletTransaction->vout[i].nValue.GetAmount();
             i++;
         }
     }
diff --git a/src/random.h b/src/random.h
index 3d5421eb3e565..5b0085f1c8ee0 100644
--- a/src/random.h
+++ b/src/random.h
@@ -150,4 +150,29 @@ bool Random_SanityCheck();
 /** Initialize the RNG. */
 void RandomInit();
 
+/** Shuffle function Poached from upstream: #14624 **/
+
+/** More efficient than using std::shuffle on a FastRandomContext.
+ *
+ * This is more efficient as std::shuffle will consume entropy in groups of
+ * 64 bits at the time and throw away most.
+ *
+ * This also works around a bug in libstdc++ std::shuffle that may cause
+ * type::operator=(type&&) to be invoked on itself, which the library's
+ * debug mode detects and panics on. This is a known issue, see
+ * https://stackoverflow.com/questions/22915325/avoiding-self-assignment-in-stdshuffle
+ */
+template<typename I, typename R>
+void Shuffle(I first, I last, R&& rng)
+{
+    while (first != last) {
+        size_t j = rng.randrange(last - first);
+        if (j) {
+            using std::swap;
+            swap(*first, *(first + j));
+        }
+        ++first;
+    }
+}
+
 #endif // BITCOIN_RANDOM_H
diff --git a/src/rest.cpp b/src/rest.cpp
index 6ba15172fa082..c0b200b1a5f13 100644
--- a/src/rest.cpp
+++ b/src/rest.cpp
@@ -555,7 +555,9 @@ static bool rest_getutxos(HTTPRequest* req, const std::string& strURIPart)
         for (const CCoin& coin : outs) {
             UniValue utxo(UniValue::VOBJ);
             utxo.pushKV("height", (int32_t)coin.nHeight);
-            utxo.pushKV("value", ValueFromAmount(coin.out.nValue));
+            if (coin.out.nValue.IsExplicit()) {
+                utxo.pushKV("value", ValueFromAmount(coin.out.nValue.GetAmount()));
+            }
 
             // include the script in a json output
             UniValue o(UniValue::VOBJ);
diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
index 04b34973e2ceb..4e19c64ff2820 100644
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -889,9 +889,13 @@ static void ApplyStats(CCoinsStats &stats, CHashWriter& ss, const uint256& hash,
     for (const auto& output : outputs) {
         ss << VARINT(output.first + 1);
         ss << output.second.out.scriptPubKey;
-        ss << VARINT(output.second.out.nValue, VarIntMode::NONNEGATIVE_SIGNED);
+        ss << output.second.out.nValue;
+        ss << output.second.out.nAsset;
+        ss << output.second.out.nNonce;
         stats.nTransactionOutputs++;
-        stats.nTotalAmount += output.second.out.nValue;
+        if (output.second.out.nValue.IsExplicit()) {
+            stats.nTotalAmount += output.second.out.nValue.GetAmount();
+        }
         stats.nBogoSize += 32 /* txid */ + 4 /* vout index */ + 4 /* height + coinbase */ + 8 /* amount */ +
                            2 /* scriptPubKey len */ + output.second.out.scriptPubKey.size() /* scriptPubKey */;
     }
@@ -1098,7 +1102,20 @@ UniValue gettxout(const JSONRPCRequest& request)
     } else {
         ret.pushKV("confirmations", (int64_t)(pindex->nHeight - coin.nHeight + 1));
     }
-    ret.pushKV("value", ValueFromAmount(coin.out.nValue));
+    if (coin.out.nValue.IsExplicit()) {
+        ret.pushKV("value", ValueFromAmount(coin.out.nValue.GetAmount()));
+    } else {
+        ret.pushKV("valuecommitment", coin.out.nValue.GetHex());
+    }
+    if (g_con_elementsmode) {
+        if (coin.out.nAsset.IsExplicit()) {
+            ret.pushKV("asset", coin.out.nAsset.GetAsset().GetHex());
+        } else {
+            ret.pushKV("assetcommitment", coin.out.nAsset.GetHex());
+        }
+
+        ret.pushKV("commitmentnonce", coin.out.nNonce.GetHex());
+    }
     UniValue o(UniValue::VOBJ);
     ScriptPubKeyToUniv(coin.out.scriptPubKey, o, true);
     ret.pushKV("scriptPubKey", o);
@@ -1819,6 +1836,9 @@ static UniValue getblockstats(const JSONRPCRequest& request)
         }
     }
 
+    // ELEMENTS:
+    const CAsset asset = policyAsset; // TODO Make configurable
+
     const CBlock block = GetBlockChecked(pindex);
 
     const bool do_all = stats.size() == 0; // Calculate everything if nothing selected (default)
@@ -1857,10 +1877,25 @@ static UniValue getblockstats(const JSONRPCRequest& request)
         outputs += tx->vout.size();
 
         CAmount tx_total_out = 0;
-        if (loop_outputs) {
-            for (const CTxOut& out : tx->vout) {
-                tx_total_out += out.nValue;
-                utxo_size_inc += GetSerializeSize(out, PROTOCOL_VERSION) + PER_UTXO_OVERHEAD;
+        // ELEMENTS:
+        CAmount elements_txfee = 0;
+        if (g_con_elementsmode) {
+            if (loop_outputs) {
+                for (const CTxOut& out : tx->vout) {
+                    if (out.IsFee() && out.nAsset.GetAsset() == asset) {
+                        elements_txfee += out.nValue.GetAmount();
+                    }
+                    if (out.nValue.IsExplicit() && out.nAsset.IsExplicit() && out.nAsset.GetAsset() == asset) {
+                        tx_total_out += out.nValue.GetAmount();
+                    }
+                }
+            }
+        } else {
+            if (loop_outputs) {
+                for (const CTxOut& out : tx->vout) {
+                    tx_total_out += out.nValue.GetAmount();
+                    utxo_size_inc += GetSerializeSize(out, PROTOCOL_VERSION) + PER_UTXO_OVERHEAD;
+                }
             }
         }
 
@@ -1900,7 +1935,7 @@ static UniValue getblockstats(const JSONRPCRequest& request)
             if (!g_txindex) {
                 throw JSONRPCError(RPC_INVALID_PARAMETER, "One or more of the selected stats requires -txindex enabled");
             }
-            CAmount tx_total_in = 0;
+            CAmount tx_total_in = 0; // Only needed for bitcoin serialization
             for (const CTxIn& in : tx->vin) {
                 if (in.m_is_pegin) {
                     continue;
@@ -1913,12 +1948,11 @@ static UniValue getblockstats(const JSONRPCRequest& request)
                 }
 
                 CTxOut prevoutput = tx_in->vout[in.prevout.n];
-
-                tx_total_in += prevoutput.nValue;
+                tx_total_in += g_con_elementsmode ? 0 : prevoutput.nValue.GetAmount();
                 utxo_size_inc -= GetSerializeSize(prevoutput, PROTOCOL_VERSION) + PER_UTXO_OVERHEAD;
             }
 
-            CAmount txfee = tx_total_in - tx_total_out;
+            CAmount txfee = g_con_elementsmode ? elements_txfee : (tx_total_in - tx_total_out);
             assert(MoneyRange(txfee));
             if (do_medianfee) {
                 fee_array.push_back(txfee);
@@ -2114,10 +2148,11 @@ UniValue scantxoutset(const JSONRPCRequest& request)
             "    \"vout\": n,                    (numeric) the vout value\n"
             "    \"scriptPubKey\" : \"script\",    (string) the script key\n"
             "    \"amount\" : x.xxx,             (numeric) The total amount in " + CURRENCY_UNIT + " of the unspent output\n"
+            "    \"asset\" : \"asset\",           (hex) The asset ID\n"
             "    \"height\" : n,                 (numeric) Height of the unspent transaction output\n"
             "   }\n"
             "   ,...], \n"
-            " \"total_amount\" : x.xxx,          (numeric) The total amount of all found unspent outputs in " + CURRENCY_UNIT + "\n"
+            " \"total_unblinded_bitcoin_amount\" : x.xxx, (numeric) The total amount of all found unspent unblinded outputs in " + CURRENCY_UNIT + "\n"
             "]\n"
         );
 
@@ -2201,24 +2236,57 @@ UniValue scantxoutset(const JSONRPCRequest& request)
         result.pushKV("success", res);
         result.pushKV("searched_items", count);
 
-        for (const auto& it : coins) {
-            const COutPoint& outpoint = it.first;
-            const Coin& coin = it.second;
-            const CTxOut& txo = coin.out;
-            input_txos.push_back(txo);
-            total_in += txo.nValue;
-
-            UniValue unspent(UniValue::VOBJ);
-            unspent.pushKV("txid", outpoint.hash.GetHex());
-            unspent.pushKV("vout", (int32_t)outpoint.n);
-            unspent.pushKV("scriptPubKey", HexStr(txo.scriptPubKey.begin(), txo.scriptPubKey.end()));
-            unspent.pushKV("amount", ValueFromAmount(txo.nValue));
-            unspent.pushKV("height", (int32_t)coin.nHeight);
-
-            unspents.push_back(unspent);
+        if (!g_con_elementsmode) {
+            for (const auto& it : coins) {
+                const COutPoint& outpoint = it.first;
+                const Coin& coin = it.second;
+                const CTxOut& txo = coin.out;
+                input_txos.push_back(txo);
+                total_in += txo.nValue.GetAmount();
+
+                UniValue unspent(UniValue::VOBJ);
+                unspent.pushKV("txid", outpoint.hash.GetHex());
+                unspent.pushKV("vout", (int32_t)outpoint.n);
+                unspent.pushKV("scriptPubKey", HexStr(txo.scriptPubKey.begin(), txo.scriptPubKey.end()));
+                unspent.pushKV("amount", ValueFromAmount(txo.nValue.GetAmount()));
+                unspent.pushKV("height", (int32_t)coin.nHeight);
+
+                unspents.push_back(unspent);
+            }
+            result.pushKV("unspents", unspents);
+            result.pushKV("total_amount", ValueFromAmount(total_in));
+        } else {
+            CAmount total_in_explicit_parent = 0;
+            for (const auto& it : coins) {
+                const COutPoint& outpoint = it.first;
+                const Coin& coin = it.second;
+                const CTxOut& txo = coin.out;
+                input_txos.push_back(txo);
+                if (txo.nValue.IsExplicit() && txo.nAsset.IsExplicit() && txo.nAsset.GetAsset() == Params().GetConsensus().pegged_asset) {
+                    total_in_explicit_parent += txo.nValue.GetAmount();
+                }
+
+                UniValue unspent(UniValue::VOBJ);
+                unspent.pushKV("txid", outpoint.hash.GetHex());
+                unspent.pushKV("vout", (int32_t)outpoint.n);
+                unspent.pushKV("scriptPubKey", HexStr(txo.scriptPubKey.begin(), txo.scriptPubKey.end()));
+                if (txo.nValue.IsExplicit()) {
+                    unspent.pushKV("amount", ValueFromAmount(txo.nValue.GetAmount()));
+                } else {
+                    unspent.pushKV("amountcommitment", HexStr(txo.nValue.vchCommitment));
+                }
+                if (txo.nAsset.IsExplicit()) {
+                    unspent.pushKV("asset", txo.nAsset.GetAsset().GetHex());
+                } else {
+                    unspent.pushKV("assetcommitment", HexStr(txo.nAsset.vchCommitment));
+                }
+                unspent.pushKV("height", (int32_t)coin.nHeight);
+
+                unspents.push_back(unspent);
+            }
+            result.pushKV("unspents", unspents);
+            result.pushKV("total_unblinded_bitcoin_amount", ValueFromAmount(total_in_explicit_parent));
         }
-        result.pushKV("unspents", unspents);
-        result.pushKV("total_amount", ValueFromAmount(total_in));
     } else {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid command");
     }
@@ -2258,8 +2326,7 @@ UniValue getsidechaininfo(const JSONRPCRequest& request)
 
     UniValue obj(UniValue::VOBJ);
     obj.pushKV("fedpegscript", HexStr(consensus.fedpegScript.begin(), consensus.fedpegScript.end()));
-    //TODO(rebase) CA
-    //obj.pushKV("pegged_asset", consensus.pegged_asset.GetHex());
+    obj.pushKV("pegged_asset", consensus.pegged_asset.GetHex());
     obj.pushKV("min_peg_diff", consensus.parentChainPowLimit.GetHex());
     obj.pushKV("parent_blockhash", parent_blockhash.GetHex());
     obj.pushKV("parent_chain_has_pow", consensus.ParentChainHasPow());
@@ -2267,8 +2334,7 @@ UniValue getsidechaininfo(const JSONRPCRequest& request)
     if (!consensus.ParentChainHasPow()) {
         obj.pushKV("parent_chain_signblockscript_asm", ScriptToAsmStr(consensus.parent_chain_signblockscript));
         obj.pushKV("parent_chain_signblockscript_hex", HexStr(consensus.parent_chain_signblockscript));
-        //TODO(stevenroose) rebase CA
-        //obj.pushKV("parent_pegged_asset", HexStr(consensus.parent_pegged_asset));
+        obj.pushKV("parent_pegged_asset", HexStr(consensus.parent_pegged_asset));
     }
     return obj;
 }
diff --git a/src/rpc/client.cpp b/src/rpc/client.cpp
index a907456d9cade..8758195cff4ac 100644
--- a/src/rpc/client.cpp
+++ b/src/rpc/client.cpp
@@ -149,7 +149,6 @@ static const CRPCConvertParam vRPCConvertParams[] =
     { "logging", 1, "exclude" },
     { "disconnectnode", 1, "nodeid" },
     { "addwitnessaddress", 1, "p2sh" },
-    { "initpegoutwallet", 1, "bip32_counter"},
     // Echo with conversion (For testing only)
     { "echojson", 0, "arg0" },
     { "echojson", 1, "arg1" },
@@ -161,12 +160,39 @@ static const CRPCConvertParam vRPCConvertParams[] =
     { "echojson", 7, "arg7" },
     { "echojson", 8, "arg8" },
     { "echojson", 9, "arg9" },
-    { "rescanblockchain", 0, "start_height"},
-    { "rescanblockchain", 1, "stop_height"},
-    { "createwallet", 1, "disable_private_keys"},
-    { "combineblocksigs", 1, "signatures"},
+    // ELEMENTS:
+    { "rescanblockchain", 0, "start_height" },
+    { "rescanblockchain", 1, "stop_height" },
+    { "createwallet", 1, "disable_private_keys" },
+    { "combineblocksigs", 1, "signatures" },
     { "sendtomainchain", 1, "amount" },
     { "sendtomainchain", 2, "subtractfeefromamount" },
+    { "dumpissuanceblindingkey", 1, "vin" },
+    { "importissuanceblindingkey", 1, "vin" },
+    { "rawissueasset", 1, "issuances" },
+    { "rawreissueasset", 1, "reissuances" },
+    { "getnewblockhex", 0, "min_tx_age" },
+    { "testproposedblock", 1, "acceptnonstd" },
+    { "issueasset", 0, "assetamount" },
+    { "issueasset", 1, "tokenamount" },
+    { "issueasset", 2, "blind" },
+    { "reissueasset", 1, "assetamount" },
+    { "initpegoutwallet", 1, "bip32_counter"},
+    { "rawblindrawtransaction", 1, "inputblinder" },
+    { "rawblindrawtransaction", 2, "inputamount" },
+    { "rawblindrawtransaction", 3, "inputasset" },
+    { "rawblindrawtransaction", 4, "inputassetblinder" },
+    { "rawblindrawtransaction", 6, "ignoreblindfail" },
+    { "blindrawtransaction", 1, "ignoreblindfail" },
+    { "blindrawtransaction", 2, "asset_commitments" },
+    { "blindrawtransaction", 3, "blind_issuances" },
+    { "destroyamount", 1, "amount" },
+    { "sendmany", 8 , "output_assets" },
+    { "sendmany", 9 , "ignoreblindfail" },
+    { "sendtoaddress", 9 , "ignoreblindfail" },
+    { "importblindingkey", 2, "key_is_master"},
+    { "createrawtransaction", 4, "output_assets" },
+
 };
 // clang-format on
 
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
index c7e35b1abced5..2023520ead487 100644
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -659,7 +659,7 @@ static UniValue getblocktemplate(const JSONRPCRequest& request)
     result.pushKV("previousblockhash", pblock->hashPrevBlock.GetHex());
     result.pushKV("transactions", transactions);
     result.pushKV("coinbaseaux", aux);
-    result.pushKV("coinbasevalue", (int64_t)pblock->vtx[0]->vout[0].nValue);
+    result.pushKV("coinbasevalue", (int64_t)pblock->vtx[0]->vout[0].nValue.GetAmount());
     result.pushKV("longpollid", chainActive.Tip()->GetBlockHash().GetHex() + i64tostr(nTransactionsUpdatedLast));
     result.pushKV("target", hashTarget.GetHex());
     result.pushKV("mintime", (int64_t)pindexPrev->GetMedianTimePast()+1);
@@ -981,7 +981,7 @@ UniValue getnewblockhex(const JSONRPCRequest& request)
 {
     if (request.fHelp || request.params.size() > 1)
         throw std::runtime_error(
-            "getnewblockhex\n"
+            "getnewblockhex ( min_tx_age )\n"
             "\nGets hex representation of a proposed, unmined new block\n"
             "\nArguments:\n"
             "1. min_tx_age    (numeric, optional, default=0) How many seconds a transaction must have been in the mempool to be inluded in the block proposal. This may help with faster block convergence among functionaries using compact blocks.\n"
diff --git a/src/rpc/misc.cpp b/src/rpc/misc.cpp
index 5bf4c4fce4b34..9d51ab978c8c3 100644
--- a/src/rpc/misc.cpp
+++ b/src/rpc/misc.cpp
@@ -30,6 +30,8 @@
 
 #include <univalue.h>
 
+#include <assetsdir.h>
+
 static UniValue validateaddress(const JSONRPCRequest& request)
 {
     if (request.fHelp || request.params.size() != 1)
@@ -52,6 +54,8 @@ static UniValue validateaddress(const JSONRPCRequest& request)
             "  \"iswitness\" : true|false,     (boolean) If the address is a witness address\n"
             "  \"witness_version\" : version   (numeric, optional) The version number of the witness program\n"
             "  \"witness_program\" : \"hex\"     (string, optional) The hex value of the witness program\n"
+            "  \"confidential_key\" : \"hex\", (string) The hex value of the raw blinding public key for that address, if any. \"\" if none.\n"
+            "  \"unconfidential\" : \"address\", (string) The address without confidentiality key.\n"
             "}\n"
             "\nExamples:\n"
             + HelpExampleCli("validateaddress", "\"1PSSGeFHDnKNxiEyFrD1wcEaHr9hrQDDWc\"")
@@ -75,6 +79,8 @@ static UniValue validateaddress(const JSONRPCRequest& request)
 
         UniValue detail = DescribeAddress(dest);
         ret.pushKVs(detail);
+        UniValue blind_detail = DescribeBlindAddress(dest);
+        ret.pushKVs(blind_detail);
     }
     return ret;
 }
@@ -177,8 +183,8 @@ static UniValue verifymessage(const JSONRPCRequest& request)
         throw JSONRPCError(RPC_TYPE_ERROR, "Invalid address");
     }
 
-    const CKeyID *keyID = boost::get<CKeyID>(&destination);
-    if (!keyID) {
+    const PKHash *pkhash = boost::get<PKHash>(&destination);
+    if (!pkhash) {
         throw JSONRPCError(RPC_TYPE_ERROR, "Address does not refer to key");
     }
 
@@ -196,7 +202,7 @@ static UniValue verifymessage(const JSONRPCRequest& request)
     if (!pubkey.RecoverCompact(ss.GetHash(), vchSig))
         return false;
 
-    return (pubkey.GetID() == *keyID);
+    return (pubkey.GetID() == *pkhash);
 }
 
 static UniValue signmessagewithprivkey(const JSONRPCRequest& request)
@@ -470,7 +476,7 @@ UniValue tweakfedpegscript(const JSONRPCRequest& request)
     std::vector<unsigned char> scriptData = ParseHex(request.params[0].get_str());
     CScript claim_script = CScript(scriptData.begin(), scriptData.end());
     CScript tweaked_script = calculate_contract(Params().GetConsensus().fedpegScript, claim_script);
-    CTxDestination parent_addr(CScriptID(GetScriptForWitness(tweaked_script)));
+    CTxDestination parent_addr(ScriptHash(GetScriptForWitness(tweaked_script)));
 
     UniValue ret(UniValue::VOBJ);
     ret.pushKV("script", HexStr(tweaked_script));
@@ -542,6 +548,103 @@ UniValue calcfastmerkleroot(const JSONRPCRequest& request)
     return ret;
 }
 
+UniValue dumpassetlabels(const JSONRPCRequest& request)
+{
+    if (request.fHelp || request.params.size() != 0)
+        throw std::runtime_error(
+            "dumpassetlabels\n"
+            "\nLists all known asset id/label pairs in this wallet. This list can be modified with `-assetdir` configuration argument.\n"
+            + HelpExampleCli("dumpassetlabels", "" )
+            + HelpExampleRpc("dumpassetlabels", "" )
+        );
+    UniValue obj(UniValue::VOBJ);
+    for (const auto& as : gAssetsDir.GetKnownAssets()) {
+        obj.pushKV(gAssetsDir.GetLabel(as), as.GetHex());
+    }
+    return obj;
+}
+
+class BlindingPubkeyAdderVisitor : public boost::static_visitor<>
+{
+public:
+    CPubKey blind_key;
+    explicit BlindingPubkeyAdderVisitor(const CPubKey& blind_key_in) : blind_key(blind_key_in) {}
+
+    void operator()(const CNoDestination& dest) const {}
+
+    void operator()(PKHash& keyID) const
+    {
+        keyID.blinding_pubkey = blind_key;
+    }
+
+    void operator()(ScriptHash& scriptID) const
+    {
+        scriptID.blinding_pubkey = blind_key;
+    }
+
+    void operator()(WitnessV0KeyHash& id) const
+    {
+        id.blinding_pubkey = blind_key;
+    }
+
+    void operator()(WitnessV0ScriptHash& id) const
+    {
+        id.blinding_pubkey = blind_key;
+    }
+
+    void operator()(WitnessUnknown& id) const
+    {
+        id.blinding_pubkey = blind_key;
+    }
+
+    void operator()(const NullData& id) const {}
+};
+
+
+UniValue createblindedaddress(const JSONRPCRequest& request)
+{
+    if (request.fHelp || request.params.size() != 2)
+    {
+        throw std::runtime_error(
+            "createblindedaddress address blinding_key\n"
+            "\nCreates a blinded address using the provided blinding key.\n"
+            "\nArguments:\n"
+            "1. \"address\"        (string, required) The unblinded address to be blinded.\n"
+            "2. \"blinding_key\"            (string, required) The blinding public key. This can be obtained for a given address using `validateaddress`.\n"
+            "\nResult:\n"
+            "\"blinded_address\"   (string) The blinded address.\n"
+            "\nExamples:\n"
+            "\nCreate a multisig address from 2 addresses\n"
+            + HelpExampleCli("createblindedaddress", "HEZk3iQi1jC49bxUriTtynnXgWWWdAYx16 ec09811118b6febfa5ebe68642e5091c418fbace07e655da26b4a845a691fc2d") +
+            "\nAs a json rpc call\n"
+            + HelpExampleRpc("createblindedaddress", "HEZk3iQi1jC49bxUriTtynnXgWWWdAYx16, ec09811118b6febfa5ebe68642e5091c418fbace07e655da26b4a845a691fc2d")
+            );
+    }
+
+    CTxDestination address = DecodeDestination(request.params[0].get_str());
+    if (!IsValidDestination(address)) {
+        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Bitcoin address or script");
+    }
+    if (IsBlindDestination(address)) {
+        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Not an unblinded address");
+    }
+
+    if (!IsHex(request.params[1].get_str())) {
+        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid hexadecimal for key");
+    }
+    std::vector<unsigned char> keydata = ParseHex(request.params[1].get_str());
+    if (keydata.size() != 33) {
+        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid hexadecimal key length, must be length 66.");
+    }
+
+    CPubKey key;
+    key.Set(keydata.begin(), keydata.end());
+
+    // Append blinding key and return
+    boost::apply_visitor(BlindingPubkeyAdderVisitor(key), address);
+    return EncodeDestination(address);
+}
+
 
 // END ELEMENTS CALLS
 //
@@ -560,6 +663,8 @@ static const CRPCCommand commands[] =
     // ELEMENTS:
     { "util",               "getpakinfo",             &getpakinfo,             {}},
     { "util",               "tweakfedpegscript",      &tweakfedpegscript,      {"claim_script"} },
+    { "util",               "createblindedaddress",   &createblindedaddress,   {"address", "blinding_key"}},
+    { "util",               "dumpassetlabels",        &dumpassetlabels,        {}},
     { "hidden",             "calcfastmerkleroot",     &calcfastmerkleroot,     {"leaves"} },
 
     /* Not shown in help */
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
index 7fc722e8018d8..f228b648b6563 100644
--- a/src/rpc/rawtransaction.cpp
+++ b/src/rpc/rawtransaction.cpp
@@ -3,6 +3,7 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <asset.h>
 #include <chain.h>
 #include <coins.h>
 #include <compat/byteswap.h>
@@ -27,7 +28,11 @@
 #include <uint256.h>
 #include <utilstrencodings.h>
 #include <validation.h>
+#include <confidential_validation.h>
 #include <validationinterface.h>
+#include <blind.h>
+#include <issuance.h>
+#include <rpc/util.h>
 
 #include <future>
 #include <stdint.h>
@@ -342,7 +347,7 @@ static UniValue verifytxoutproof(const JSONRPCRequest& request)
     return res;
 }
 
-CMutableTransaction ConstructTransaction(const UniValue& inputs_in, const UniValue& outputs_in, const UniValue& locktime, const UniValue& rbf)
+CMutableTransaction ConstructTransaction(const UniValue& inputs_in, const UniValue& outputs_in, const UniValue& locktime, const UniValue& rbf, const UniValue& assets_in)
 {
     if (inputs_in.isNull() || outputs_in.isNull())
         throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, arguments 1 and 2 must be non-null");
@@ -362,6 +367,11 @@ CMutableTransaction ConstructTransaction(const UniValue& inputs_in, const UniVal
 
     bool rbfOptIn = rbf.isTrue();
 
+    UniValue assets;
+    if (!assets_in.isNull()) {
+        assets = assets_in.get_obj();
+    }
+
     for (unsigned int idx = 0; idx < inputs.size(); idx++) {
         const UniValue& input = inputs[idx];
         const UniValue& o = input.get_obj();
@@ -416,11 +426,22 @@ CMutableTransaction ConstructTransaction(const UniValue& inputs_in, const UniVal
         }
         outputs = std::move(outputs_dict);
     }
+    // Keep track of the fee output so we can add it in the very end of the transaction.
+    CTxOut fee_out;
     for (const std::string& name_ : outputs.getKeys()) {
+        // ELEMENTS:
+        // Asset defaults to policyAsset
+        CAsset asset(::policyAsset);
+        if (!assets.isNull()) {
+            if (!find_value(assets, name_).isNull()) {
+                asset = CAsset(ParseHashO(assets, name_));
+            }
+        }
+
         if (name_ == "data") {
             std::vector<unsigned char> data = ParseHexV(outputs[name_].getValStr(), "Data");
 
-            CTxOut out(0, CScript() << OP_RETURN << data);
+            CTxOut out(asset, 0, CScript() << OP_RETURN << data);
             rawTx.vout.push_back(out);
         } else if (name_ == "vdata") {
             // ELEMENTS: support multi-push OP_RETURN
@@ -431,9 +452,12 @@ CMutableTransaction ConstructTransaction(const UniValue& inputs_in, const UniVal
                 datascript << data;
             }
 
-            //TODO(rebase) CA asset
-            CTxOut out(0, datascript);
+            CTxOut out(asset, 0, datascript);
             rawTx.vout.push_back(out);
+        } else if (name_ == "fee") {
+            // ELEMENTS: explicit fee outputs
+            CAmount nAmount = AmountFromValue(outputs[name_]);
+            fee_out = CTxOut(asset, nAmount, CScript());
         } else {
             CTxDestination destination = DecodeDestination(name_);
             if (!IsValidDestination(destination)) {
@@ -447,11 +471,20 @@ CMutableTransaction ConstructTransaction(const UniValue& inputs_in, const UniVal
             CScript scriptPubKey = GetScriptForDestination(destination);
             CAmount nAmount = AmountFromValue(outputs[name_]);
 
-            CTxOut out(nAmount, scriptPubKey);
+            CTxOut out(asset, nAmount, scriptPubKey);
+            if (IsBlindDestination(destination)) {
+                CPubKey blind_pub = GetDestinationBlindingKey(destination);
+                out.nNonce.vchCommitment = std::vector<unsigned char>(blind_pub.begin(), blind_pub.end());
+            }
             rawTx.vout.push_back(out);
         }
     }
 
+    // Add fee output in the end.
+    if (!fee_out.nValue.IsNull() && fee_out.nValue.GetAmount() > 0) {
+        rawTx.vout.push_back(fee_out);
+    }
+
     if (!rbf.isNull() && rawTx.vin.size() > 0 && rbfOptIn != SignalsOptInRBF(rawTx)) {
         throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter combination: Sequence number(s) contradict replaceable option");
     }
@@ -461,10 +494,10 @@ CMutableTransaction ConstructTransaction(const UniValue& inputs_in, const UniVal
 
 static UniValue createrawtransaction(const JSONRPCRequest& request)
 {
-    if (request.fHelp || request.params.size() < 2 || request.params.size() > 4) {
+    if (request.fHelp || request.params.size() < 2 || request.params.size() > 5) {
         throw std::runtime_error(
             // clang-format off
-            "createrawtransaction [{\"txid\":\"id\",\"vout\":n},...] [{\"address\":amount},{\"data\":\"hex\"},...] ( locktime ) ( replaceable )\n"
+            "createrawtransaction [{\"txid\":\"id\",\"vout\":n},...] [{\"address\":amount},{\"data\":\"hex\"},...] ( locktime ) ( replaceable ) ( {\"address\":\"asset\"} )\n"
             "\nCreate a transaction spending the given inputs and creating new outputs.\n"
             "Outputs can be addresses or data.\n"
             "Returns hex-encoded raw transaction.\n"
@@ -489,6 +522,9 @@ static UniValue createrawtransaction(const JSONRPCRequest& request)
             "    {\n"
             "      \"data\": \"hex\" ,    (obj, optional) A key-value pair. The key must be \"data\", the value is hex encoded data\n"
             "      \"vdata\": [\"hex\"]   (string, optional) The key is \"vdata\", the value is an array of hex encoded data\n"
+            "    },\n"
+            "    {\n"
+            "      \"fee\": x.xxx         (numeric or string, optional) The key is \"fee\", the value the fee output you want to add.\n"
             "    }\n"
             "    ,...                     More key-value pairs of the above form. For compatibility reasons, a dictionary, which holds the key-value pairs directly, is also\n"
             "                             accepted as second parameter.\n"
@@ -496,6 +532,12 @@ static UniValue createrawtransaction(const JSONRPCRequest& request)
             "3. locktime                  (numeric, optional, default=0) Raw locktime. Non-0 value also locktime-activates inputs\n"
             "4. replaceable               (boolean, optional, default=false) Marks this transaction as BIP125 replaceable.\n"
             "                             Allows this transaction to be replaced by a transaction with higher fees. If provided, it is an error if explicit sequence numbers are incompatible.\n"
+            "5. \"output_assets\"           (strings, optional, default=bitcoin) A json object of assets to addresses\n"
+            "   {\n"
+            "       \"address\": \"hex\" \n"
+            "       \"fee\": \"hex\" \n"
+            "       ...\n"
+            "   }\n"
             "\nResult:\n"
             "\"transaction\"              (string) hex string of the transaction\n"
 
@@ -512,11 +554,12 @@ static UniValue createrawtransaction(const JSONRPCRequest& request)
         UniValue::VARR,
         UniValueType(), // ARR or OBJ, checked later
         UniValue::VNUM,
-        UniValue::VBOOL
+        UniValue::VBOOL,
+        UniValue::VOBJ
         }, true
     );
 
-    CMutableTransaction rawTx = ConstructTransaction(request.params[0], request.params[1], request.params[2], request.params[3]);
+    CMutableTransaction rawTx = ConstructTransaction(request.params[0], request.params[1], request.params[2], request.params[3], request.params[4]);
 
     return EncodeHexTx(rawTx);
 }
@@ -639,7 +682,7 @@ static UniValue decodescript(const JSONRPCRequest& request)
     if (type.isStr() && type.get_str() != "scripthash") {
         // P2SH cannot be wrapped in a P2SH. If this script is already a P2SH,
         // don't return the address for a P2SH of the P2SH.
-        r.pushKV("p2sh", EncodeDestination(CScriptID(script)));
+        r.pushKV("p2sh", EncodeDestination(ScriptHash(CScriptID(script))));
         // P2SH and witness programs cannot be wrapped in P2WSH, if this script
         // is a witness program, don't return addresses for a segwit programs.
         if (type.get_str() == "pubkey" || type.get_str() == "pubkeyhash" || type.get_str() == "multisig" || type.get_str() == "nonstandard") {
@@ -666,7 +709,7 @@ static UniValue decodescript(const JSONRPCRequest& request)
                 segwitScr = GetScriptForDestination(WitnessV0ScriptHash(script));
             }
             ScriptPubKeyToUniv(segwitScr, sr, true);
-            sr.pushKV("p2sh-segwit", EncodeDestination(CScriptID(segwitScr)));
+            sr.pushKV("p2sh-segwit", EncodeDestination(ScriptHash(CScriptID(segwitScr))));
             r.pushKV("segwit", sr);
         }
     }
@@ -833,9 +876,13 @@ UniValue SignTransaction(CMutableTransaction& mtx, const UniValue& prevTxsUnival
                 }
                 Coin newcoin;
                 newcoin.out.scriptPubKey = scriptPubKey;
-                newcoin.out.nValue = MAX_MONEY;
+                newcoin.out.nValue = CConfidentialValue(MAX_MONEY);
                 if (prevOut.exists("amount")) {
-                    newcoin.out.nValue = AmountFromValue(find_value(prevOut, "amount"));
+                    newcoin.out.nValue = CConfidentialValue(AmountFromValue(find_value(prevOut, "amount")));
+                } else if (prevOut.exists("amountcommitment")) {
+                    // Segwit sigs require the amount commitment to be sighashed
+                    uint256 asset_commit = uint256S(prevOut["amountcommitment"].get_str());
+                    newcoin.out.nValue.vchCommitment = std::vector<unsigned char>(asset_commit.begin(), asset_commit.end());
                 }
                 newcoin.nHeight = 1;
                 view.AddCoin(out, std::move(newcoin), true);
@@ -895,9 +942,7 @@ UniValue SignTransaction(CMutableTransaction& mtx, const UniValue& prevTxsUnival
         }
 
         const CScript& prevPubKey = txin.m_is_pegin ? GetPeginOutputFromWitness(txConst.witness.vtxinwit[i].m_pegin_witness).scriptPubKey : coin.out.scriptPubKey;
-        //TODO(rebase) CT
-        //const CConfidentialValue& amount = txin.m_is_pegin ? GetPeginOutputFromWitness(txConst.witness.vtxinwit[i].m_pegin_witness).nValue : coin.out.nValue;
-        const CAmount& amount = txin.m_is_pegin ? GetPeginOutputFromWitness(txConst.witness.vtxinwit[i].m_pegin_witness).nValue : coin.out.nValue;
+        const CConfidentialValue& amount = txin.m_is_pegin ? GetPeginOutputFromWitness(txConst.witness.vtxinwit[i].m_pegin_witness).nValue : coin.out.nValue;
 
         SignatureData sigdata = DataFromTransaction(mtx, i, coin.out);
         // Only sign SIGHASH_SINGLE if there's a corresponding output:
@@ -908,7 +953,7 @@ UniValue SignTransaction(CMutableTransaction& mtx, const UniValue& prevTxsUnival
         UpdateTransaction(mtx, i, sigdata);
 
         // amount must be specified for valid segwit signature
-        if (amount == MAX_MONEY && !inWitness.scriptWitness.IsNull()) {
+        if (amount.IsExplicit() && amount.GetAmount() == MAX_MONEY && !mtx.witness.vtxinwit[i].scriptWitness.IsNull()) {
             throw JSONRPCError(RPC_TYPE_ERROR, strprintf("Missing amount for %s", coin.out.ToString()));
         }
 
@@ -962,7 +1007,8 @@ static UniValue signrawtransactionwithkey(const JSONRPCRequest& request)
             "         \"vout\":n,                  (numeric, required) The output number\n"
             "         \"scriptPubKey\": \"hex\",     (string, required) script key\n"
             "         \"redeemScript\": \"hex\",     (string, required for P2SH or P2WSH) redeem script\n"
-            "         \"amount\": value            (numeric, required) The amount spent\n"
+            "         \"amount\": value            (numeric, required if non-confidential segwit output) The amount spent\n"
+            "         \"amountcommitment\": \"hex\", (string, required if confidential segiwt output) The amount commitment spent\n"
             "       }\n"
             "       ,...\n"
             "    ]\n"
@@ -1335,6 +1381,7 @@ UniValue decodepsbt(const JSONRPCRequest& request)
     UniValue tx_univ(UniValue::VOBJ);
     TxToUniv(CTransaction(*psbtx.tx), uint256(), tx_univ, false);
     result.pushKV("tx", tx_univ);
+    result.pushKV("fees", AmountMapToUniv(GetFeeMap(CTransaction(*psbtx.tx)), ""));
 
     // Unknown data
     UniValue unknowns(UniValue::VOBJ);
@@ -1344,8 +1391,6 @@ UniValue decodepsbt(const JSONRPCRequest& request)
     result.pushKV("unknown", unknowns);
 
     // inputs
-    CAmount total_in = 0;
-    bool have_all_utxos = true;
     UniValue inputs(UniValue::VARR);
     for (unsigned int i = 0; i < psbtx.inputs.size(); ++i) {
         const PSBTInput& input = psbtx.inputs[i];
@@ -1356,8 +1401,11 @@ UniValue decodepsbt(const JSONRPCRequest& request)
 
             UniValue out(UniValue::VOBJ);
 
-            out.pushKV("amount", ValueFromAmount(txout.nValue));
-            total_in += txout.nValue;
+            if (txout.nValue.IsExplicit()) {
+                out.pushKV("amount", ValueFromAmount(txout.nValue.GetAmount()));
+            } else {
+                out.pushKV("amountcommitment", txout.nValue.GetHex());
+            }
 
             UniValue o(UniValue::VOBJ);
             ScriptToUniv(txout.scriptPubKey, o, true);
@@ -1367,9 +1415,6 @@ UniValue decodepsbt(const JSONRPCRequest& request)
             UniValue non_wit(UniValue::VOBJ);
             TxToUniv(*input.non_witness_utxo, uint256(), non_wit, false);
             in.pushKV("non_witness_utxo", non_wit);
-            total_in += input.non_witness_utxo->vout[psbtx.tx->vin[i].prevout.n].nValue;
-        } else {
-            have_all_utxos = false;
         }
 
         // Partial sigs
@@ -1441,7 +1486,6 @@ UniValue decodepsbt(const JSONRPCRequest& request)
     result.pushKV("inputs", inputs);
 
     // outputs
-    CAmount output_value = 0;
     UniValue outputs(UniValue::VARR);
     for (unsigned int i = 0; i < psbtx.outputs.size(); ++i) {
         const PSBTOutput& output = psbtx.outputs[i];
@@ -1481,14 +1525,8 @@ UniValue decodepsbt(const JSONRPCRequest& request)
         }
 
         outputs.push_back(out);
-
-        // Fee calculation
-        output_value += psbtx.tx->vout[i].nValue;
     }
     result.pushKV("outputs", outputs);
-    if (have_all_utxos) {
-        result.pushKV("fee", ValueFromAmount(total_in - output_value));
-    }
 
     return result;
 }
@@ -1641,6 +1679,12 @@ UniValue createpsbt(const JSONRPCRequest& request)
                             "3. locktime                  (numeric, optional, default=0) Raw locktime. Non-0 value also locktime-activates inputs\n"
                             "4. replaceable               (boolean, optional, default=false) Marks this transaction as BIP125 replaceable.\n"
                             "                             Allows this transaction to be replaced by a transaction with higher fees. If provided, it is an error if explicit sequence numbers are incompatible.\n"
+                            "5. \"output_assets\"           (strings, optional, default=bitcoin) A json object of assets to addresses\n"
+                            "   {\n"
+                            "       \"address\": \"hex\" \n"
+                            "       \"fee\": \"hex\" \n"
+                            "       ...\n"
+                            "   }\n"
                             "\nResult:\n"
                             "  \"psbt\"        (string)  The resulting raw transaction (base64-encoded string)\n"
                             "\nExamples:\n"
@@ -1656,7 +1700,7 @@ UniValue createpsbt(const JSONRPCRequest& request)
         }, true
     );
 
-    CMutableTransaction rawTx = ConstructTransaction(request.params[0], request.params[1], request.params[2], request.params[3]);
+    CMutableTransaction rawTx = ConstructTransaction(request.params[0], request.params[1], request.params[2], request.params[3], request.params[4]);
 
     // Make a blank psbt
     PartiallySignedTransaction psbtx;
@@ -1744,12 +1788,483 @@ UniValue converttopsbt(const JSONRPCRequest& request)
     return EncodeBase64((unsigned char*)ssTx.data(), ssTx.size());
 }
 
+UniValue rawblindrawtransaction(const JSONRPCRequest& request)
+{
+    if (request.fHelp || (request.params.size() < 5 || request.params.size() > 7))
+        throw std::runtime_error(
+            "rawblindrawtransaction \"hexstring\" [\"inputblinder\",...] [\"inputamount\",...] [\"inputasset\",...] [\"inputassetblinder\",...] ( totalblinder, ignoreblindfail )\n"
+            "\nConvert one or more outputs of a raw transaction into confidential ones.\n"
+            "Returns the hex-encoded raw transaction.\n"
+            "The input raw transaction cannot have already-blinded outputs.\n"
+            "The output keys used can be specified by using a confidential address in createrawtransaction.\n"
+            "If an additional blinded output is required to make a balanced blinding, a 0-value unspendable output will be added. Since there is no access to the wallet the blinding pubkey from the last output with blinding key will be repeated.\n"
+            "You can not blind issuances with this call.\n"
+
+            "\nArguments:\n"
+            "1. \"hexstring\",          (string, required) A hex-encoded raw transaction.\n"
+            "2. [                       (array, required) An array with one entry per transaction input.\n"
+            "    \"inputamountblinder\" (string, required) A hex-encoded blinding factor, one for each input.\n"
+            "                           Blinding factors can be found in the \"blinder\" output of listunspent.\n"
+            "   ],\n"
+            "3. [                       (array, required) An array with one entry per transaction input.\n"
+            "   \"inputamount\"         (numeric, required) An amount for each input.\n"
+            "   ],\n"
+            "4. [                       (array, required) An array with one entry per transaction input.\n"
+            "   \"inputasset\"          (string, required) A hex-encoded asset id, one for each input.\n"
+            "   ],\n"
+            "5. [                       (array, required) An array with one entry per transaction input.\n"
+            "   \"inputassetblinder\"   (string, required) A hex-encoded asset blinding factor, one for each input.\n"
+            "   ],\n"
+            "6. \"totalblinder\"        (string, optional) Ignored for now.\n"
+            "7. \"ignoreblindfail\"\"   (bool, optional, default=true) Return a transaction even when a blinding attempt fails due to number of blinded inputs/outputs.\n"
+
+            "\nResult:\n"
+            "\"transaction\"              (string) hex string of the transaction\n"
+        );
+
+    std::vector<unsigned char> txData(ParseHexV(request.params[0], "argument 1"));
+    CDataStream ssData(txData, SER_NETWORK, PROTOCOL_VERSION);
+    CMutableTransaction tx;
+    try {
+        ssData >> tx;
+    } catch (const std::exception &) {
+        throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
+    }
+
+    UniValue inputBlinds = request.params[1].get_array();
+    UniValue inputAmounts = request.params[2].get_array();
+    UniValue inputAssets = request.params[3].get_array();
+    UniValue inputAssetBlinds = request.params[4].get_array();
+
+    bool fIgnoreBlindFail = true;
+    if (!request.params[6].isNull()) {
+        fIgnoreBlindFail = request.params[6].get_bool();
+    }
+
+    int n_blinded_ins = 0;
+
+    if (inputBlinds.size() != tx.vin.size()) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER,
+            "Invalid parameter: one (potentially empty) input blind for each input must be provided");
+    }
+    if (inputAmounts.size() != tx.vin.size()) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER,
+            "Invalid parameter: one (potentially empty) input blind for each input must be provided");
+    }
+    if (inputAssets.size() != tx.vin.size()) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER,
+            "Invalid parameter: one (potentially empty) input asset id for each input must be provided");
+    }
+    if (inputAssetBlinds.size() != tx.vin.size()) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER,
+            "Invalid parameter: one (potentially empty) input asset blind for each input must be provided");
+    }
+
+    std::vector<CAmount> input_amounts;
+    std::vector<uint256> input_blinds;
+    std::vector<uint256> input_asset_blinds;
+    std::vector<CAsset> input_assets;
+    std::vector<uint256> output_value_blinds;
+    std::vector<uint256> output_asset_blinds;
+    std::vector<CAsset> output_assets;
+    std::vector<CPubKey> output_pubkeys;
+    for (size_t nIn = 0; nIn < tx.vin.size(); nIn++) {
+        if (!inputBlinds[nIn].isStr())
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "input blinds must be an array of hex strings");
+        if (!inputAssetBlinds[nIn].isStr())
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "input asset blinds must be an array of hex strings");
+        if (!inputAssets[nIn].isStr())
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "input asset ids must be an array of hex strings");
+
+        std::string blind(inputBlinds[nIn].get_str());
+        std::string assetblind(inputAssetBlinds[nIn].get_str());
+        std::string asset(inputAssets[nIn].get_str());
+        if (!IsHex(blind) || blind.length() != 32*2)
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "input blinds must be an array of 32-byte hex-encoded strings");
+        if (!IsHex(assetblind) || assetblind.length() != 32*2)
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "input asset blinds must be an array of 32-byte hex-encoded strings");
+        if (!IsHex(asset) || asset.length() != 32*2)
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "input asset blinds must be an array of 32-byte hex-encoded strings");
+
+        input_blinds.push_back(uint256S(blind));
+        input_asset_blinds.push_back(uint256S(assetblind));
+        input_assets.push_back(CAsset(uint256S(asset)));
+        input_amounts.push_back(AmountFromValue(inputAmounts[nIn]));
+
+        if (!input_blinds.back().IsNull()) {
+            n_blinded_ins++;
+        }
+    }
+
+    RawFillBlinds(tx, output_value_blinds, output_asset_blinds, output_pubkeys);
+
+    // How many are we trying to blind?
+    int num_pubkeys = 0;
+    unsigned int keyIndex = -1;
+    for (unsigned int i = 0; i < output_pubkeys.size(); i++) {
+        const CPubKey& key = output_pubkeys[i];
+        if (key.IsValid()) {
+            num_pubkeys++;
+            keyIndex = i;
+        }
+    }
+
+    if (num_pubkeys == 0 && n_blinded_ins == 0) {
+        // Vacuous, just return the transaction
+        return EncodeHexTx(tx);
+    } else if (n_blinded_ins > 0 && num_pubkeys == 0) {
+        // No notion of wallet, cannot complete this blinding without passed-in pubkey
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "Unable to blind transaction: Add another output to blind in order to complete the blinding.");
+    } else if (n_blinded_ins == 0 && num_pubkeys == 1) {
+        if (fIgnoreBlindFail) {
+            // Just get rid of the ECDH key in the nonce field and return
+            tx.vout[keyIndex].nNonce.SetNull();
+            return EncodeHexTx(tx);
+        } else {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "Unable to blind transaction: Add another output to blind in order to complete the blinding.");
+        }
+    }
+
+    int ret = BlindTransaction(input_blinds, input_asset_blinds, input_assets, input_amounts, output_value_blinds, output_asset_blinds, output_pubkeys, std::vector<CKey>(), std::vector<CKey>(), tx);
+    if (ret != num_pubkeys) {
+        // TODO Have more rich return values, communicating to user what has been blinded
+        // User may be ok not blinding something that for instance has no corresponding type on input
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "Unable to blind transaction: Are you sure each asset type to blind is represented in the inputs?");
+    }
+
+    return EncodeHexTx(tx);
+}
+
+struct RawIssuanceDetails
+{
+    int input_index;
+    uint256 entropy;
+    CAsset asset;
+    CAsset token;
+};
+
+// Appends a single issuance to the first input that doesn't have one, and includes
+// a single output per asset type in shuffled positions.
+void issueasset_base(CMutableTransaction& mtx, RawIssuanceDetails& issuance_details, const CAmount asset_amount, const CAmount token_amount, const std::string& asset_address_str, const std::string& token_address_str, const bool blind_issuance, const uint256& contract_hash)
+{
+
+    CTxDestination asset_address(DecodeDestination(asset_address_str));
+    CTxDestination token_address(DecodeDestination(token_address_str));
+    CScript asset_destination = GetScriptForDestination(asset_address);
+    CScript token_destination = GetScriptForDestination(token_address);
+
+    // Find an input with no issuance field
+    size_t issuance_input_index = 0;
+    for (; issuance_input_index < mtx.vin.size(); issuance_input_index++) {
+        if (mtx.vin[issuance_input_index].assetIssuance.IsNull()) {
+            break;
+        }
+    }
+    // Can't add another one, exit
+    if (issuance_input_index == mtx.vin.size()) {
+        issuance_details.input_index = -1;
+        return;
+    }
+
+    uint256 entropy;
+    CAsset asset;
+    CAsset token;
+    GenerateAssetEntropy(entropy, mtx.vin[issuance_input_index].prevout, contract_hash);
+    CalculateAsset(asset, entropy);
+    CalculateReissuanceToken(token, entropy, blind_issuance);
+
+    issuance_details.input_index = issuance_input_index;
+    issuance_details.entropy = entropy;
+    issuance_details.asset = asset;
+    issuance_details.token = token;
+
+    mtx.vin[issuance_input_index].assetIssuance.assetEntropy = contract_hash;
+
+    // Place assets into randomly placed output slots, just insert in place
+    // -1 due to fee output being at the end no matter what.
+    int asset_place = GetRandInt(mtx.vout.size()-1);
+    int token_place = GetRandInt(mtx.vout.size()); // Don't bias insertion
+
+    CTxOut asset_out(asset, asset_amount, asset_destination);
+    // If blinded address, insert the pubkey into the nonce field for later substitution by blinding
+    if (IsBlindDestination(asset_address)) {
+        CPubKey asset_blind = GetDestinationBlindingKey(asset_address);
+        asset_out.nNonce.vchCommitment = std::vector<unsigned char>(asset_blind.begin(), asset_blind.end());
+    }
+    // Explicit 0 is represented by a null value, don't set to non-null in that case
+    if (blind_issuance || asset_amount != 0) {
+        mtx.vin[issuance_input_index].assetIssuance.nAmount = asset_amount;
+    }
+    // Don't make zero value output(impossible by consensus)
+    if (asset_amount > 0) {
+        mtx.vout.insert(mtx.vout.begin()+asset_place, asset_out);
+    }
+
+    CTxOut token_out(token, token_amount, token_destination);
+    // If blinded address, insert the pubkey into the nonce field for later substitution by blinding
+    if (IsBlindDestination(token_address)) {
+        CPubKey token_blind = GetDestinationBlindingKey(token_address);
+        token_out.nNonce.vchCommitment = std::vector<unsigned char>(token_blind.begin(), token_blind.end());
+    }
+    // Explicit 0 is represented by a null value, don't set to non-null in that case
+    if (blind_issuance || token_amount != 0) {
+        mtx.vin[issuance_input_index].assetIssuance.nInflationKeys = token_amount;
+    }
+    // Don't make zero value output(impossible by consensus)
+    if (token_amount > 0) {
+        mtx.vout.insert(mtx.vout.begin()+token_place, token_out);
+    }
+}
+
+// Appends a single reissuance to the specified input if none exists,
+// and the corresponding output in a shuffled position. Errors otherwise.
+void reissueasset_base(CMutableTransaction& mtx, int& issuance_input_index, const CAmount asset_amount, const std::string& asset_address_str, const uint256& asset_blinder, const uint256& entropy)
+{
+
+    CTxDestination asset_address(DecodeDestination(asset_address_str));
+    CScript asset_destination = GetScriptForDestination(asset_address);
+
+    // Check if issuance already exists, error if already exists
+    if ((size_t)issuance_input_index >= mtx.vin.size() || !mtx.vin[issuance_input_index].assetIssuance.IsNull()) {
+        issuance_input_index = -1;
+        return;
+    }
+
+    CAsset asset;
+    CalculateAsset(asset, entropy);
+
+    mtx.vin[issuance_input_index].assetIssuance.assetEntropy = entropy;
+    mtx.vin[issuance_input_index].assetIssuance.assetBlindingNonce = asset_blinder;
+    mtx.vin[issuance_input_index].assetIssuance.nAmount = asset_amount;
+
+    // Place assets into randomly placed output slots, before change output, inserted in place
+    assert(mtx.vout.size() >= 1);
+    int asset_place = GetRandInt(mtx.vout.size()-1);
+
+    CTxOut asset_out(asset, asset_amount, asset_destination);
+    // If blinded address, insert the pubkey into the nonce field for later substitution by blinding
+    if (IsBlindDestination(asset_address)) {
+        CPubKey asset_blind = GetDestinationBlindingKey(asset_address);
+        asset_out.nNonce.vchCommitment = std::vector<unsigned char>(asset_blind.begin(), asset_blind.end());
+    }
+    assert(asset_amount > 0);
+    mtx.vout.insert(mtx.vout.begin()+asset_place, asset_out);
+    mtx.vin[issuance_input_index].assetIssuance.nAmount = asset_amount;
+}
+
+UniValue rawissueasset(const JSONRPCRequest& request)
+{
+    if (request.fHelp || request.params.size() != 2)
+        throw std::runtime_error(
+            "rawissueasset transaction [{\"asset_amount\":x.xxx, \"asset_address\":\"address\", \"token_amount\":x.xxx, \"token_address\":\"address\", \"blind\":bool, ( \"contract_hash\":\"hash\" )}, ...]\n"
+            "\nCreate an asset by attaching issuances to transaction inputs. Returns the transaction hex. There must be as many inputs as issuances requested. The final transaction hex is the final version of the transaction appended to the last object in the array.\n"
+            "\nArguments:\n"
+            "1. \"transaction\"           (string, required) Transaction in hex in which to include an issuance input.\n"
+            "2. \"issuances\"              (list, required) List of issuances to create. Each issuance must have one non-zero amount. \n"
+            "[\n"
+            "   {\n"
+            "       \"asset_amount\":x.xxx (numeric or string, optional) Amount of asset to generate, if any.\n"
+            "       \"asset_address\":addr  (string, optional) Destination address of generated asset. Required if `asset_amount` given.\n"
+            "       \"token_amount\":x.xxx (numeric or string, optional) Amount of reissuance token to generate, if any.\n"
+            "       \"token_address\":addr  (string, optional) Destination address of generated reissuance tokens. Required if `token_amount` given.\n"
+            "       \"blind\":bool          (bool, optional, default=true) Whether to mark the issuance input for blinding or not. Only affects issuances with re-issuance tokens."
+            "       \"contract_hash\":str   (string, optional, default=00..00) Contract hash that is put into issuance definition. Must be 32 bytes worth in hex string form. This will affect the asset id."
+            "   }\n"
+            "   ...\n"
+            "]\n"
+            "\nResult:\n"
+            "[                           (json array) Results of issuances, in the order of `issuances` argument\n"
+            "  {                           (json object)\n"
+            "    \"hex\":<hex>,            (string) The transaction with issuances appended. Only appended to final index in returned array.\n"
+            "    \"vin\":\"n\",            (numeric) The input position of the issuance in the transaction.\n"
+            "    \"entropy\":\"<entropy>\" (string) Entropy of the asset type.\n"
+            "    \"asset\":\"<asset>\",    (string) Asset type for issuance if known.\n"
+            "    \"token\":\"<token>\",    (string) Token type for issuance.\n"
+            "  },\n"
+            "  ...\n"
+            "]"
+        );
+
+    CMutableTransaction mtx;
+
+    if (!DecodeHexTx(mtx, request.params[0].get_str()))
+        throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
+
+    UniValue issuances = request.params[1].get_array();
+
+    std::string asset_address_str = "";
+    std::string token_address_str = "";
+
+    UniValue ret(UniValue::VARR);
+
+    // Count issuances, only append hex to final one
+    unsigned int issuances_til_now = 0;
+
+    for (unsigned int idx = 0; idx < issuances.size(); idx++) {
+        const UniValue& issuance = issuances[idx];
+        const UniValue& issuance_o = issuance.get_obj();
+
+        CAmount asset_amount = 0;
+        const UniValue& asset_amount_uni = issuance_o["asset_amount"];
+        if (asset_amount_uni.isNum()) {
+            asset_amount = AmountFromValue(asset_amount_uni);
+            if (asset_amount <= 0) {
+                throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, asset_amount must be positive");
+            }
+            const UniValue& asset_address_uni = issuance_o["asset_address"];
+            if (!asset_address_uni.isStr()) {
+                throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, missing corresponding asset_address");
+            }
+            asset_address_str = asset_address_uni.get_str();
+        }
+
+        CAmount token_amount = 0;
+        const UniValue& token_amount_uni = issuance_o["token_amount"];
+        if (token_amount_uni.isNum()) {
+            token_amount = AmountFromValue(token_amount_uni);
+            if (token_amount <= 0) {
+                throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, token_amount must be positive");
+            }
+            const UniValue& token_address_uni = issuance_o["token_address"];
+            if (!token_address_uni.isStr()) {
+                throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, missing corresponding token_address");
+            }
+            token_address_str = token_address_uni.get_str();
+        }
+        if (asset_amount == 0 && token_amount == 0) {
+            throw JSONRPCError(RPC_TYPE_ERROR, "Issuance must have one non-zero component");
+        }
+
+        // If we have issuances, check if reissuance tokens will be generated via blinding path
+        const UniValue blind_uni = issuance_o["blind"];
+        const bool blind_issuance = !blind_uni.isBool() || blind_uni.get_bool();
+
+        // Check for optional contract to hash into definition
+        uint256 contract_hash;
+        if (!issuance_o["contract_hash"].isNull()) {
+            contract_hash = ParseHashV(issuance_o["contract_hash"], "contract_hash");
+        }
+
+        RawIssuanceDetails details;
+
+        issueasset_base(mtx, details, asset_amount, token_amount, asset_address_str, token_address_str, blind_issuance, contract_hash);
+        if (details.input_index == -1) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "Failed to find enough blank inputs for listed issuances.");
+        }
+
+        issuances_til_now++;
+
+        UniValue obj(UniValue::VOBJ);
+        if (issuances_til_now == issuances.size()) {
+            obj.pushKV("hex", EncodeHexTx(mtx, RPCSerializationFlags()));
+        }
+        obj.pushKV("vin", details.input_index);
+        obj.pushKV("entropy", details.entropy.GetHex());
+        obj.pushKV("asset", details.asset.GetHex());
+        obj.pushKV("token", details.token.GetHex());
+
+        ret.push_back(obj);
+    }
+
+    return ret;
+}
+
+UniValue rawreissueasset(const JSONRPCRequest& request)
+{
+    if (request.fHelp || request.params.size() != 2)
+        throw std::runtime_error(
+            "rawreissueasset transaction {\"vin\":\"n\", \"asset_amount\":x.xxx, \"asset_address\":\"address\", \"asset_blinder\":<hex>, \"entropy\":<hex>, ( \"contract_hash\":<hex> )}\n"
+            "\nRe-issue an asset by attaching pseudo-inputs to transaction inputs, revealing the underlying reissuance token of the input. Returns the transaction hex.\n"
+            "\nArguments:\n"
+            "1. \"transaction\"           (string, required) Transaction in hex in which to include an issuance input.\n"
+            "2. \"reissuances\"              (list, required) List of re-issuances to create. Each issuance must have one non-zero amount.\n"
+            "[\n"
+            "   {\n"
+            "       \"input_index\":\"n\",            (numeric, required) The input position of the reissuance in the transaction.\n"
+            "       \"asset_amount\":x.xxx, (numeric or string, required) Amount of asset to generate, if any.\n"
+            "       \"asset_address\":addr,  (string, required) Destination address of generated asset. Required if `asset_amount` given.\n"
+            "       \"asset_blinder\":<hex>, (string, required) The blinding factor of the reissuance token output being spent.\n"
+            "       \"entropy\":<hex>,  (string, required) The `entropy` returned during initial issuance for the asset being reissued."
+            "   }\n"
+            "\nResult:\n"
+            "{                             (json object)\n"
+            "    \"hex\":<hex>,            (string) The transaction with reissuances appended.\n"
+            "}\n"
+        );
+
+    CMutableTransaction mtx;
+
+    if (!DecodeHexTx(mtx, request.params[0].get_str()))
+        throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
+
+    if (mtx.vout.empty()) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "Transaction must have at least one output.");
+    }
+
+    UniValue issuances = request.params[1].get_array();
+
+    unsigned int num_issuances = 0;
+
+    for (unsigned int idx = 0; idx < issuances.size(); idx++) {
+        const UniValue& issuance = issuances[idx];
+        const UniValue& issuance_o = issuance.get_obj();
+
+        CAmount asset_amount = 0;
+        const UniValue& asset_amount_uni = issuance_o["asset_amount"];
+        if (asset_amount_uni.isNum()) {
+            asset_amount = AmountFromValue(asset_amount_uni);
+            if (asset_amount <= 0) {
+                throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, asset_amount must be positive");
+            }
+        } else {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "Asset amount must be given for each reissuance.");
+        }
+
+        const UniValue& asset_address_uni = issuance_o["asset_address"];
+        if (!asset_address_uni.isStr()) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "Reissuance missing asset_address");
+        }
+        std::string asset_address_str = asset_address_uni.get_str();
+
+        int input_index = -1;
+        const UniValue& input_index_o = issuance_o["input_index"];
+        if (input_index_o.isNum()) {
+            input_index = input_index_o.get_int();
+            if (input_index < 0) {
+                throw JSONRPCError(RPC_INVALID_PARAMETER, "Input index must be non-negative.");
+            }
+        } else {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "Input indexes for all reissuances are required.");
+        }
+
+        uint256 asset_blinder = ParseHashV(issuance_o["asset_blinder"], "asset_blinder");
+
+        uint256 entropy = ParseHashV(issuance_o["entropy"], "entropy");
+
+        reissueasset_base(mtx, input_index, asset_amount, asset_address_str, asset_blinder, entropy);
+        if (input_index == -1) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "Selected transaction input already has issuance data.");
+        }
+
+        num_issuances++;
+    }
+
+    if (num_issuances != issuances.size()) {
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "Failed to find enough blank inputs for listed issuances.");
+    }
+
+    UniValue ret(UniValue::VOBJ);
+    ret.pushKV("hex", EncodeHexTx(mtx, RPCSerializationFlags()));
+    return ret;
+}
+
+
 // clang-format off
 static const CRPCCommand commands[] =
 { //  category              name                            actor (function)            argNames
   //  --------------------- ------------------------        -----------------------     ----------
     { "rawtransactions",    "getrawtransaction",            &getrawtransaction,         {"txid","verbose","blockhash"} },
-    { "rawtransactions",    "createrawtransaction",         &createrawtransaction,      {"inputs","outputs","locktime","replaceable"} },
+    { "rawtransactions",    "createrawtransaction",         &createrawtransaction,      {"inputs","outputs","locktime","replaceable", "output_assets"} },
     { "rawtransactions",    "decoderawtransaction",         &decoderawtransaction,      {"hexstring","iswitness"} },
     { "rawtransactions",    "decodescript",                 &decodescript,              {"hexstring"} },
     { "rawtransactions",    "sendrawtransaction",           &sendrawtransaction,        {"hexstring","allowhighfees"} },
@@ -1762,9 +2277,12 @@ static const CRPCCommand commands[] =
     { "rawtransactions",    "finalizepsbt",                 &finalizepsbt,              {"psbt", "extract"} },
     { "rawtransactions",    "createpsbt",                   &createpsbt,                {"inputs","outputs","locktime","replaceable"} },
     { "rawtransactions",    "converttopsbt",                &converttopsbt,             {"hexstring","permitsigdata","iswitness"} },
+    { "rawtransactions",    "rawblindrawtransaction",       &rawblindrawtransaction,    {"hexstring", "inputblinder", "inputamount", "inputasset", "inputassetblinder", "totalblinder", "ignoreblindfail"} },
 
     { "blockchain",         "gettxoutproof",                &gettxoutproof,             {"txids", "blockhash"} },
     { "blockchain",         "verifytxoutproof",             &verifytxoutproof,          {"proof"} },
+    { "rawtransactions",    "rawissueasset",                &rawissueasset,             {"transaction", "issuances"}},
+    { "rawtransactions",    "rawreissueasset",              &rawreissueasset,           {"transaction", "reissuances"}},
 };
 // clang-format on
 
diff --git a/src/rpc/rawtransaction.h b/src/rpc/rawtransaction.h
index 924611ed5a538..7a433bb9351ac 100644
--- a/src/rpc/rawtransaction.h
+++ b/src/rpc/rawtransaction.h
@@ -13,6 +13,6 @@ class UniValue;
 UniValue SignTransaction(CMutableTransaction& mtx, const UniValue& prevTxs, CBasicKeyStore *keystore, bool tempKeystore, const UniValue& hashType);
 
 /** Create a transaction from univalue parameters */
-CMutableTransaction ConstructTransaction(const UniValue& inputs_in, const UniValue& outputs_in, const UniValue& locktime, const UniValue& rbf);
+CMutableTransaction ConstructTransaction(const UniValue& inputs_in, const UniValue& outputs_in, const UniValue& locktime, const UniValue& rbf, const UniValue& assets_in);
 
 #endif // BITCOIN_RPC_RAWTRANSACTION_H
diff --git a/src/rpc/util.cpp b/src/rpc/util.cpp
index b4925c9583d1d..d5219bc505c6d 100644
--- a/src/rpc/util.cpp
+++ b/src/rpc/util.cpp
@@ -8,6 +8,9 @@
 #include <rpc/util.h>
 #include <tinyformat.h>
 #include <utilstrencodings.h>
+#include <policy/policy.h>
+#include <assetsdir.h>
+#include <core_io.h>
 
 // Converts a hex string to a public key if possible
 CPubKey HexToPubKey(const std::string& hex_in)
@@ -76,7 +79,7 @@ class DescribeAddressVisitor : public boost::static_visitor<UniValue>
         return UniValue(UniValue::VOBJ);
     }
 
-    UniValue operator()(const CKeyID& keyID) const
+    UniValue operator()(const PKHash& keyID) const
     {
         UniValue obj(UniValue::VOBJ);
         obj.pushKV("isscript", false);
@@ -84,7 +87,7 @@ class DescribeAddressVisitor : public boost::static_visitor<UniValue>
         return obj;
     }
 
-    UniValue operator()(const CScriptID& scriptID) const
+    UniValue operator()(const ScriptHash& scriptID) const
     {
         UniValue obj(UniValue::VOBJ);
         obj.pushKV("isscript", true);
@@ -134,3 +137,172 @@ UniValue DescribeAddress(const CTxDestination& dest)
 {
     return boost::apply_visitor(DescribeAddressVisitor(), dest);
 }
+
+// ELEMENTS
+
+class BlindingPubkeyVisitor : public boost::static_visitor<CPubKey>
+{
+public:
+    explicit BlindingPubkeyVisitor() {}
+
+    CPubKey operator()(const CNoDestination& dest) const
+    {
+        return CPubKey();
+    }
+
+    CPubKey operator()(const PKHash& keyID) const
+    {
+        return keyID.blinding_pubkey;
+    }
+
+    CPubKey operator()(const ScriptHash& scriptID) const
+    {
+        return scriptID.blinding_pubkey;
+    }
+
+    CPubKey operator()(const WitnessV0KeyHash& id) const
+    {
+        return id.blinding_pubkey;
+    }
+
+    CPubKey operator()(const WitnessV0ScriptHash& id) const
+    {
+        return id.blinding_pubkey;
+    }
+
+    CPubKey operator()(const WitnessUnknown& id) const
+    {
+        return id.blinding_pubkey;
+    }
+
+    CPubKey operator()(const NullData& id) const
+    {
+        return CPubKey();
+    }
+};
+
+CPubKey GetDestinationBlindingKey(const CTxDestination& dest) {
+    return boost::apply_visitor(BlindingPubkeyVisitor(), dest);
+}
+
+bool IsBlindDestination(const CTxDestination& dest) {
+    return GetDestinationBlindingKey(dest).IsFullyValid();
+}
+
+class DescribeBlindAddressVisitor : public boost::static_visitor<UniValue>
+{
+public:
+
+    explicit DescribeBlindAddressVisitor() {}
+
+    UniValue operator()(const CNoDestination& dest) const { return UniValue(UniValue::VOBJ); }
+
+    UniValue operator()(const PKHash& pkhash) const
+    {
+        UniValue obj(UniValue::VOBJ);
+        const CPubKey& blind_pub = pkhash.blinding_pubkey;
+        if (IsBlindDestination(pkhash)) {
+            obj.pushKV("confidential_key", HexStr(blind_pub.begin(), blind_pub.end()));
+            PKHash unblinded(pkhash);
+            unblinded.blinding_pubkey = CPubKey();
+            obj.pushKV("unconfidential", EncodeDestination(unblinded));
+        } else {
+            obj.pushKV("confidential_key", "");
+            obj.pushKV("unconfidential", EncodeDestination(pkhash));
+        }
+        return obj;
+    }
+
+    UniValue operator()(const ScriptHash& scripthash) const
+    {
+        UniValue obj(UniValue::VOBJ);
+        const CPubKey& blind_pub = scripthash.blinding_pubkey;
+        if (IsBlindDestination(scripthash)) {
+            obj.pushKV("confidential_key", HexStr(blind_pub.begin(), blind_pub.end()));
+            ScriptHash unblinded(scripthash);
+            unblinded.blinding_pubkey = CPubKey();
+            obj.pushKV("unconfidential", EncodeDestination(unblinded));
+        } else {
+            obj.pushKV("confidential_key", "");
+            obj.pushKV("unconfidential", EncodeDestination(scripthash));
+        }
+
+        return obj;
+    }
+
+    UniValue operator()(const WitnessV0KeyHash& id) const
+    {
+        UniValue obj(UniValue::VOBJ);
+        const CPubKey& blind_pub = id.blinding_pubkey;
+        if (IsBlindDestination(id)) {
+            obj.pushKV("confidential_key", HexStr(blind_pub.begin(), blind_pub.end()));
+            WitnessV0KeyHash unblinded(id);
+            unblinded.blinding_pubkey = CPubKey();
+            obj.pushKV("unconfidential", EncodeDestination(unblinded));
+        } else {
+            obj.pushKV("confidential_key", "");
+            obj.pushKV("unconfidential", EncodeDestination(id));
+        }
+
+        return obj;
+    }
+
+    UniValue operator()(const WitnessV0ScriptHash& id) const
+    {
+        UniValue obj(UniValue::VOBJ);
+        const CPubKey& blind_pub = id.blinding_pubkey;
+        if (IsBlindDestination(id)) {
+            obj.pushKV("confidential_key", HexStr(blind_pub.begin(), blind_pub.end()));
+            WitnessV0ScriptHash unblinded(id);
+            unblinded.blinding_pubkey = CPubKey();
+            obj.pushKV("unconfidential", EncodeDestination(unblinded));
+        } else {
+            obj.pushKV("confidential_key", "");
+            obj.pushKV("unconfidential", EncodeDestination(id));
+        }
+        return obj;
+    }
+
+    UniValue operator()(const WitnessUnknown& id) const { return UniValue(UniValue::VOBJ); }
+    UniValue operator()(const NullData& id) const { return NullUniValue; }
+};
+
+UniValue DescribeBlindAddress(const CTxDestination& dest)
+{
+    UniValue ret(UniValue::VOBJ);
+    ret.pushKVs(boost::apply_visitor(DescribeBlindAddressVisitor(), dest));
+    return ret;
+}
+
+// Attaches labeled balance reports to UniValue obj with asset filter
+// "" displays *all* assets as VOBJ pairs, while named assets must have
+// been entered via -assetdir configuration argument and are returned as VNUM.
+UniValue AmountMapToUniv(const CAmountMap& balanceOrig, std::string strasset)
+{
+    // Make sure the policyAsset is always present in the balance map.
+    CAmountMap balance = balanceOrig;
+    balance[::policyAsset] += 0;
+
+    // If we don't do assets or a specific asset is given, we filter out once asset.
+    if (!g_con_elementsmode || strasset != "") {
+        if (g_con_elementsmode) {
+            return ValueFromAmount(balance[GetAssetFromString(strasset)]);
+        } else {
+            return ValueFromAmount(balance[::policyAsset]);
+        }
+    }
+
+    UniValue obj(UniValue::VOBJ);
+    for(std::map<CAsset, CAmount>::const_iterator it = balance.begin(); it != balance.end(); ++it) {
+        // Unknown assets
+        if (it->first.IsNull())
+            continue;
+        UniValue pair(UniValue::VOBJ);
+        std::string label = gAssetsDir.GetLabel(it->first);
+        if (label == "") {
+            label = it->first.GetHex();
+        }
+        obj.pushKV(label, ValueFromAmount(it->second));
+    }
+    return obj;
+}
diff --git a/src/rpc/util.h b/src/rpc/util.h
index 0a3a156e4574a..b01e94e171f77 100644
--- a/src/rpc/util.h
+++ b/src/rpc/util.h
@@ -23,5 +23,10 @@ CPubKey AddrToPubKey(CKeyStore* const keystore, const std::string& addr_in);
 CScript CreateMultisigRedeemscript(const int required, const std::vector<CPubKey>& pubkeys);
 
 UniValue DescribeAddress(const CTxDestination& dest);
+UniValue DescribeBlindAddress(const CTxDestination& dest);
+CPubKey GetDestinationBlindingKey(const CTxDestination& dest);
+bool IsBlindDestination(const CTxDestination& dest);
+
+UniValue AmountMapToUniv(const CAmountMap& balanceOrig, std::string strasset);
 
 #endif // BITCOIN_RPC_UTIL_H
diff --git a/src/script/bitcoinconsensus.cpp b/src/script/bitcoinconsensus.cpp
index 33844a54ec18a..a6240afa69ac2 100644
--- a/src/script/bitcoinconsensus.cpp
+++ b/src/script/bitcoinconsensus.cpp
@@ -76,7 +76,7 @@ static bool verify_flags(unsigned int flags)
     return (flags & ~(bitcoinconsensus_SCRIPT_FLAGS_VERIFY_ALL)) == 0;
 }
 
-static int verify_script(const unsigned char *scriptPubKey, unsigned int scriptPubKeyLen, CAmount amount,
+static int verify_script(const unsigned char *scriptPubKey, unsigned int scriptPubKeyLen, CConfidentialValue amount,
                                     const unsigned char *txTo        , unsigned int txToLen,
                                     unsigned int nIn, unsigned int flags, bitcoinconsensus_error* err)
 {
@@ -102,12 +102,20 @@ static int verify_script(const unsigned char *scriptPubKey, unsigned int scriptP
     }
 }
 
-int bitcoinconsensus_verify_script_with_amount(const unsigned char *scriptPubKey, unsigned int scriptPubKeyLen, int64_t amount,
+int bitcoinconsensus_verify_script_with_amount(const unsigned char *scriptPubKey, unsigned int scriptPubKeyLen,
+                                    const unsigned char *amount, unsigned int amountLen,
                                     const unsigned char *txTo        , unsigned int txToLen,
                                     unsigned int nIn, unsigned int flags, bitcoinconsensus_error* err)
 {
-    CAmount am(amount);
-    return ::verify_script(scriptPubKey, scriptPubKeyLen, am, txTo, txToLen, nIn, flags, err);
+    try {
+        TxInputStream stream(SER_NETWORK, PROTOCOL_VERSION, amount, amountLen);
+        CConfidentialValue am;
+        stream >> am;
+
+        return ::verify_script(scriptPubKey, scriptPubKeyLen, am, txTo, txToLen, nIn, flags, err);
+    } catch (const std::exception&) {
+        return set_error(err, bitcoinconsensus_ERR_TX_DESERIALIZE); // Error deserializing
+    }
 }
 
 
@@ -119,7 +127,7 @@ int bitcoinconsensus_verify_script(const unsigned char *scriptPubKey, unsigned i
         return set_error(err, bitcoinconsensus_ERR_AMOUNT_REQUIRED);
     }
 
-    CAmount am(0);
+    CConfidentialValue am(0);
     return ::verify_script(scriptPubKey, scriptPubKeyLen, am, txTo, txToLen, nIn, flags, err);
 }
 
diff --git a/src/script/bitcoinconsensus.h b/src/script/bitcoinconsensus.h
index c5dceac84849e..5eeed7be06d0a 100644
--- a/src/script/bitcoinconsensus.h
+++ b/src/script/bitcoinconsensus.h
@@ -68,7 +68,8 @@ EXPORT_SYMBOL int bitcoinconsensus_verify_script(const unsigned char *scriptPubK
                                                  const unsigned char *txTo        , unsigned int txToLen,
                                                  unsigned int nIn, unsigned int flags, bitcoinconsensus_error* err);
 
-EXPORT_SYMBOL int bitcoinconsensus_verify_script_with_amount(const unsigned char *scriptPubKey, unsigned int scriptPubKeyLen, int64_t amount,
+EXPORT_SYMBOL int bitcoinconsensus_verify_script_with_amount(const unsigned char *scriptPubKey, unsigned int scriptPubKeyLen,
+                                    const unsigned char *amount, unsigned int amountLen,
                                     const unsigned char *txTo        , unsigned int txToLen,
                                     unsigned int nIn, unsigned int flags, bitcoinconsensus_error* err);
 
diff --git a/src/script/descriptor.cpp b/src/script/descriptor.cpp
index 45b097dde6e14..e87981a3f3caf 100644
--- a/src/script/descriptor.cpp
+++ b/src/script/descriptor.cpp
@@ -228,7 +228,7 @@ class SingleKeyDescriptor final : public Descriptor
     }
 };
 
-CScript P2PKHGetScript(const CPubKey& pubkey) { return GetScriptForDestination(pubkey.GetID()); }
+CScript P2PKHGetScript(const CPubKey& pubkey) { return GetScriptForDestination(PKHash(pubkey)); }
 CScript P2PKGetScript(const CPubKey& pubkey) { return GetScriptForRawPubKey(pubkey); }
 CScript P2WPKHGetScript(const CPubKey& pubkey) { return GetScriptForDestination(WitnessV0KeyHash(pubkey.GetID())); }
 
@@ -320,7 +320,7 @@ class ConvertorDescriptor : public Descriptor
     }
 };
 
-CScript ConvertP2SH(const CScript& script) { return GetScriptForDestination(CScriptID(script)); }
+CScript ConvertP2SH(const CScript& script) { return GetScriptForDestination(ScriptHash(script)); }
 CScript ConvertP2WSH(const CScript& script) { return GetScriptForDestination(WitnessV0ScriptHash(script)); }
 
 /** A parsed combo(P) descriptor. */
@@ -347,14 +347,14 @@ class ComboDescriptor final : public Descriptor
         CKeyID keyid = key.GetID();
         {
             CScript p2pk = GetScriptForRawPubKey(key);
-            CScript p2pkh = GetScriptForDestination(keyid);
+            CScript p2pkh = GetScriptForDestination(PKHash(keyid));
             output_scripts = std::vector<CScript>{std::move(p2pk), std::move(p2pkh)};
             out.pubkeys.emplace(keyid, key);
         }
         if (key.IsCompressed()) {
             CScript p2wpkh = GetScriptForDestination(WitnessV0KeyHash(keyid));
             CScriptID p2wpkh_id(p2wpkh);
-            CScript p2sh_p2wpkh = GetScriptForDestination(p2wpkh_id);
+            CScript p2sh_p2wpkh = GetScriptForDestination(ScriptHash(p2wpkh_id));
             out.scripts.emplace(p2wpkh_id, p2wpkh);
             output_scripts.push_back(std::move(p2wpkh));
             output_scripts.push_back(std::move(p2sh_p2wpkh));
diff --git a/src/script/interpreter.cpp b/src/script/interpreter.cpp
index 372f83154f9fe..01be38e85a579 100644
--- a/src/script/interpreter.cpp
+++ b/src/script/interpreter.cpp
@@ -1519,6 +1519,11 @@ class CTransactionSignatureSerializer
             ::Serialize(s, (int)0);
         else
             ::Serialize(s, txTo.vin[nInput].nSequence);
+        // Serialize the asset issuance object
+        if (!txTo.vin[nInput].assetIssuance.IsNull()) {
+            assert(g_con_elementsmode);
+            ::Serialize(s, txTo.vin[nInput].assetIssuance);
+        }
     }
 
     /** Serialize an output of txTo */
@@ -1571,6 +1576,19 @@ uint256 GetSequenceHash(const T& txTo)
     return ss.GetHash();
 }
 
+template <class T>
+uint256 GetIssuanceHash(const T& txTo)
+{
+    CHashWriter ss(SER_GETHASH, 0);
+    for (const auto& txin : txTo.vin) {
+        if (txin.assetIssuance.IsNull())
+            ss << (unsigned char)0;
+        else
+            ss << txin.assetIssuance;
+    }
+    return ss.GetHash();
+}
+
 template <class T>
 uint256 GetOutputsHash(const T& txTo)
 {
@@ -1590,6 +1608,7 @@ PrecomputedTransactionData::PrecomputedTransactionData(const T& txTo)
     if (txTo.HasWitness()) {
         hashPrevouts = GetPrevoutHash(txTo);
         hashSequence = GetSequenceHash(txTo);
+        hashIssuance = GetIssuanceHash(txTo);
         hashOutputs = GetOutputsHash(txTo);
         ready = true;
     }
@@ -1600,13 +1619,14 @@ template PrecomputedTransactionData::PrecomputedTransactionData(const CTransacti
 template PrecomputedTransactionData::PrecomputedTransactionData(const CMutableTransaction& txTo);
 
 template <class T>
-uint256 SignatureHash(const CScript& scriptCode, const T& txTo, unsigned int nIn, int nHashType, const CAmount& amount, SigVersion sigversion, const PrecomputedTransactionData* cache)
+uint256 SignatureHash(const CScript& scriptCode, const T& txTo, unsigned int nIn, int nHashType, const CConfidentialValue& amount, SigVersion sigversion, const PrecomputedTransactionData* cache)
 {
     assert(nIn < txTo.vin.size());
 
     if (sigversion == SigVersion::WITNESS_V0) {
         uint256 hashPrevouts;
         uint256 hashSequence;
+        uint256 hashIssuance;
         uint256 hashOutputs;
         const bool cacheready = cache && cache->ready;
 
@@ -1618,6 +1638,9 @@ uint256 SignatureHash(const CScript& scriptCode, const T& txTo, unsigned int nIn
             hashSequence = cacheready ? cache->hashSequence : GetSequenceHash(txTo);
         }
 
+        if (!(nHashType & SIGHASH_ANYONECANPAY)) {
+            hashIssuance = cacheready ? cache->hashIssuance : GetIssuanceHash(txTo);
+        }
 
         if ((nHashType & 0x1f) != SIGHASH_SINGLE && (nHashType & 0x1f) != SIGHASH_NONE) {
             hashOutputs = cacheready ? cache->hashOutputs : GetOutputsHash(txTo);
@@ -1633,13 +1656,24 @@ uint256 SignatureHash(const CScript& scriptCode, const T& txTo, unsigned int nIn
         // Input prevouts/nSequence (none/all, depending on flags)
         ss << hashPrevouts;
         ss << hashSequence;
+        if (g_con_elementsmode) {
+            ss << hashIssuance;
+        }
         // The input being signed (replacing the scriptSig with scriptCode + amount)
         // The prevout may already be contained in hashPrevout, and the nSequence
         // may already be contain in hashSequence.
         ss << txTo.vin[nIn].prevout;
         ss << scriptCode;
-        ss << amount;
+        if (g_con_elementsmode) {
+            ss << amount;
+        } else {
+            ss << amount.GetAmount();
+        }
         ss << txTo.vin[nIn].nSequence;
+        if (!txTo.vin[nIn].assetIssuance.IsNull()) {
+            assert(g_con_elementsmode);
+            ss << txTo.vin[nIn].assetIssuance;
+        }
         // Outputs (none/one/all, depending on flags)
         ss << hashOutputs;
         // Locktime
diff --git a/src/script/interpreter.h b/src/script/interpreter.h
index a27789fc9e0b1..8801bd52af653 100644
--- a/src/script/interpreter.h
+++ b/src/script/interpreter.h
@@ -125,7 +125,7 @@ bool CheckSignatureEncoding(const std::vector<unsigned char> &vchSig, unsigned i
 
 struct PrecomputedTransactionData
 {
-    uint256 hashPrevouts, hashSequence, hashOutputs;
+    uint256 hashPrevouts, hashSequence, hashOutputs, hashIssuance;
     bool ready = false;
 
     template <class T>
@@ -143,7 +143,7 @@ static constexpr size_t WITNESS_V0_SCRIPTHASH_SIZE = 32;
 static constexpr size_t WITNESS_V0_KEYHASH_SIZE = 20;
 
 template <class T>
-uint256 SignatureHash(const CScript& scriptCode, const T& txTo, unsigned int nIn, int nHashType, const CAmount& amount, SigVersion sigversion, const PrecomputedTransactionData* cache = nullptr);
+uint256 SignatureHash(const CScript& scriptCode, const T& txTo, unsigned int nIn, int nHashType, const CConfidentialValue& amount, SigVersion sigversion, const PrecomputedTransactionData* cache = nullptr);
 
 class BaseSignatureChecker
 {
@@ -172,15 +172,15 @@ class GenericTransactionSignatureChecker : public BaseSignatureChecker
 private:
     const T* txTo;
     unsigned int nIn;
-    const CAmount amount;
+    const CConfidentialValue amount;
     const PrecomputedTransactionData* txdata;
 
 protected:
     virtual bool VerifySignature(const std::vector<unsigned char>& vchSig, const CPubKey& vchPubKey, const uint256& sighash) const;
 
 public:
-    GenericTransactionSignatureChecker(const T* txToIn, unsigned int nInIn, const CAmount& amountIn) : txTo(txToIn), nIn(nInIn), amount(amountIn), txdata(nullptr) {}
-    GenericTransactionSignatureChecker(const T* txToIn, unsigned int nInIn, const CAmount& amountIn, const PrecomputedTransactionData& txdataIn) : txTo(txToIn), nIn(nInIn), amount(amountIn), txdata(&txdataIn) {}
+    GenericTransactionSignatureChecker(const T* txToIn, unsigned int nInIn, const CConfidentialValue& amountIn) : txTo(txToIn), nIn(nInIn), amount(amountIn), txdata(nullptr) {}
+    GenericTransactionSignatureChecker(const T* txToIn, unsigned int nInIn, const CConfidentialValue& amountIn, const PrecomputedTransactionData& txdataIn) : txTo(txToIn), nIn(nInIn), amount(amountIn), txdata(&txdataIn) {}
     bool CheckSig(const std::vector<unsigned char>& scriptSig, const std::vector<unsigned char>& vchPubKey, const CScript& scriptCode, SigVersion sigversion) const override;
     bool CheckLockTime(const CScriptNum& nLockTime) const override;
     bool CheckSequence(const CScriptNum& nSequence) const override;
diff --git a/src/script/ismine.cpp b/src/script/ismine.cpp
index 926d7986bed72..1673a88c115eb 100644
--- a/src/script/ismine.cpp
+++ b/src/script/ismine.cpp
@@ -69,6 +69,7 @@ IsMineResult IsMineInner(const CKeyStore& keystore, const CScript& scriptPubKey,
     case TX_NONSTANDARD:
     case TX_NULL_DATA:
     case TX_WITNESS_UNKNOWN:
+    case TX_FEE:
         break;
     case TX_PUBKEY:
         keyID = CPubKey(vSolutions[0]).GetID();
@@ -91,7 +92,7 @@ IsMineResult IsMineInner(const CKeyStore& keystore, const CScript& scriptPubKey,
             // This also applies to the P2WSH case.
             break;
         }
-        ret = std::max(ret, IsMineInner(keystore, GetScriptForDestination(CKeyID(uint160(vSolutions[0]))), IsMineSigVersion::WITNESS_V0));
+        ret = std::max(ret, IsMineInner(keystore, GetScriptForDestination(PKHash(uint160(vSolutions[0]))), IsMineSigVersion::WITNESS_V0));
         break;
     }
     case TX_PUBKEYHASH:
diff --git a/src/script/script.h b/src/script/script.h
index bb7a0fe12c602..c6abd04e4c648 100644
--- a/src/script/script.h
+++ b/src/script/script.h
@@ -20,6 +20,9 @@
 #include <uint256.h>
 #include <vector>
 
+// IsUnspendable() compatibility
+extern bool g_con_elementsmode;
+
 // Maximum number of bytes pushable to the stack
 static const unsigned int MAX_SCRIPT_ELEMENT_SIZE = 520;
 
@@ -570,7 +573,8 @@ class CScript : public CScriptBase
      */
     bool IsUnspendable() const
     {
-        return (size() > 0 && *begin() == OP_RETURN) || (size() > MAX_SCRIPT_SIZE);
+        return (size() > 0 && *begin() == OP_RETURN) || (size() > MAX_SCRIPT_SIZE) ||
+            (g_con_elementsmode && size() == 0 /* Elements rule for fee outputs */);
     }
 
     void clear()
diff --git a/src/script/script_error.h b/src/script/script_error.h
index 400f63ff0f7f5..e04d43701921e 100644
--- a/src/script/script_error.h
+++ b/src/script/script_error.h
@@ -68,7 +68,11 @@ typedef enum ScriptError_t
     SCRIPT_ERR_OP_CODESEPARATOR,
     SCRIPT_ERR_SIG_FINDANDDELETE,
 
-    SCRIPT_ERR_ERROR_COUNT
+    SCRIPT_ERR_ERROR_COUNT,
+
+    // ELEMENTS:
+    SCRIPT_ERR_RANGEPROOF,
+    SCRIPT_ERR_PEDERSEN_TALLY
 } ScriptError;
 
 #define SCRIPT_ERR_LAST SCRIPT_ERR_ERROR_COUNT
diff --git a/src/script/sigcache.cpp b/src/script/sigcache.cpp
index 68f0542294580..f9e1718a34272 100644
--- a/src/script/sigcache.cpp
+++ b/src/script/sigcache.cpp
@@ -41,6 +41,14 @@ class CSignatureCache
         CSHA256().Write(nonce.begin(), 32).Write(hash.begin(), 32).Write(&pubkey[0], pubkey.size()).Write(&vchSig[0], vchSig.size()).Finalize(entry.begin());
     }
 
+    // ELEMENTS:
+    void ComputeEntry(uint256& entry, const std::vector<unsigned char>& proof, const std::vector<unsigned char>& commitment) {
+        CSHA256().Write(nonce.begin(), nonce.size()).Write(proof.data(), proof.size()).Write(commitment.data(), commitment.size()).Finalize(entry.begin());
+    }
+    void ComputeEntry(uint256& entry, const uint256 &hash, const std::vector<unsigned char>& proof, const std::vector<unsigned char>& commitment) {
+        CSHA256().Write(nonce.begin(), nonce.size()).Write(hash.begin(), 32).Write(proof.data(), proof.size()).Write(commitment.data(), commitment.size()).Finalize(entry.begin());
+    }
+
     bool
     Get(const uint256& entry, const bool erase)
     {
@@ -66,6 +74,11 @@ class CSignatureCache
  * signatureCache could be made local to VerifySignature.
 */
 static CSignatureCache signatureCache;
+
+// ELEMENTS:
+static CSignatureCache rangeProofCache;
+static CSignatureCache surjectionProofCache;
+
 } // namespace
 
 // To be called once in AppInitMain/BasicTestingSetup to initialize the
@@ -92,3 +105,102 @@ bool CachingTransactionSignatureChecker::VerifySignature(const std::vector<unsig
         signatureCache.Set(entry);
     return true;
 }
+
+//
+// ELEMENTS CACHES
+
+// To be called once in AppInit2/TestingSetup to initialize the rangeproof cache
+void InitRangeproofCache()
+{
+    // nMaxCacheSize is unsigned. If -maxsigcachesize is set to zero,
+    // setup_bytes creates the minimum possible cache (2 elements).
+    size_t nMaxCacheSize = std::min(std::max((int64_t)0, gArgs.GetArg("-maxsigcachesize", DEFAULT_MAX_SIG_CACHE_SIZE)), MAX_MAX_SIG_CACHE_SIZE) * ((size_t) 1 << 20);
+    size_t nElems = rangeProofCache.setup_bytes(nMaxCacheSize);
+    LogPrintf("Using %zu MiB out of %zu requested for rangeproof cache, able to store %zu elements\n",
+            (nElems*sizeof(uint256)) >>20, nMaxCacheSize>>20, nElems);
+}
+
+// To be called once in AppInit2/TestingSetup to initialize the surjectionrproof cache
+void InitSurjectionproofCache()
+{
+    // nMaxCacheSize is unsigned. If -maxsigcachesize is set to zero,
+    // setup_bytes creates the minimum possible cache (2 elements).
+    size_t nMaxCacheSize = std::min(std::max((int64_t)0, gArgs.GetArg("-maxsigcachesize", DEFAULT_MAX_SIG_CACHE_SIZE)), MAX_MAX_SIG_CACHE_SIZE) * ((size_t) 1 << 20);
+    size_t nElems = surjectionProofCache.setup_bytes(nMaxCacheSize);
+    LogPrintf("Using %zu MiB out of %zu requested for surjectionproof cache, able to store %zu elements\n",
+            (nElems*sizeof(uint256)) >>20, nMaxCacheSize>>20, nElems);
+}
+
+bool CachingRangeProofChecker::VerifyRangeProof(const std::vector<unsigned char>& vchRangeProof, const std::vector<unsigned char>& vchValueCommitment, const std::vector<unsigned char>& vchAssetCommitment, const CScript& scriptPubKey, const secp256k1_context* secp256k1_ctx_verify_amounts) const
+{
+    uint256 entry;
+    rangeProofCache.ComputeEntry(entry, vchRangeProof, vchValueCommitment);
+
+    if (rangeProofCache.Get(entry, !store)) {
+        return true;
+    }
+
+    if (vchRangeProof.size() == 0) {
+        return false;
+    }
+
+    uint64_t min_value, max_value;
+    secp256k1_pedersen_commitment commit;
+    if (secp256k1_pedersen_commitment_parse(secp256k1_ctx_verify_amounts, &commit, &vchValueCommitment[0]) != 1)
+            return false;
+
+    secp256k1_generator tag;
+    if (secp256k1_generator_parse(secp256k1_ctx_verify_amounts, &tag, &vchAssetCommitment[0]) != 1)
+        return false;
+
+    if (!secp256k1_rangeproof_verify(secp256k1_ctx_verify_amounts, &min_value, &max_value, &commit, vchRangeProof.data(), vchRangeProof.size(), scriptPubKey.size() ? &scriptPubKey.front() : NULL, scriptPubKey.size(), &tag)) {
+        return false;
+    }
+
+    // An rangeproof is not valid if the output is spendable but the minimum number
+    // is 0. This is to prevent people passing 0-value tokens around, or conjuring
+    // reissuance tokens from nothing then attempting to reissue an asset.
+    // ie reissuance doesn't require revealing value of reissuance output
+    // Issuances proofs are always "unspendable" as they commit to an empty script.
+    if (min_value == 0 && !scriptPubKey.IsUnspendable()) {
+        return false;
+    }
+
+    if (store) {
+        rangeProofCache.Set(entry);
+    }
+
+    return true;
+}
+
+bool CachingSurjectionProofChecker::VerifySurjectionProof(secp256k1_surjectionproof& proof, std::vector<secp256k1_generator>& vTags, secp256k1_generator& gen, const secp256k1_context* secp256k1_ctx_verify_amounts, const uint256& wtxid) const
+{
+
+    // Serialize proof
+    std::vector<unsigned char> vchproof;
+    size_t proof_len = secp256k1_surjectionproof_serialized_size(secp256k1_ctx_verify_amounts, &proof);
+    vchproof.resize(proof_len);
+    assert(secp256k1_surjectionproof_serialize(secp256k1_ctx_verify_amounts, vchproof.data(), &proof_len, &proof) == 1);
+
+    // wtxid commits to all data including surj targets
+    // we need to specify the proof and output asset point to be unique
+    uint256 entry;
+    surjectionProofCache.ComputeEntry(entry, wtxid, vchproof, std::vector<unsigned char>(std::begin(gen.data), std::end(gen.data)));
+
+    if (surjectionProofCache.Get(entry, !store)) {
+        return true;
+    }
+
+    if (secp256k1_surjectionproof_verify(secp256k1_ctx_verify_amounts, &proof, vTags.data(), vTags.size(), &gen) != 1) {
+        return false;
+    }
+
+    if (store) {
+        surjectionProofCache.Set(entry);
+    }
+
+    return true;
+}
+
+// END ELEMENTS
+//
diff --git a/src/script/sigcache.h b/src/script/sigcache.h
index 807b61b542fb6..a9014aa6140a9 100644
--- a/src/script/sigcache.h
+++ b/src/script/sigcache.h
@@ -8,6 +8,9 @@
 
 #include <script/interpreter.h>
 
+#include <secp256k1.h>
+#include <secp256k1_rangeproof.h>
+#include <secp256k1_surjectionproof.h>
 #include <vector>
 
 // DoS prevention: limit cache size to 32MB (over 1000000 entries on 64-bit
@@ -46,11 +49,46 @@ class CachingTransactionSignatureChecker : public TransactionSignatureChecker
     bool store;
 
 public:
-    CachingTransactionSignatureChecker(const CTransaction* txToIn, unsigned int nInIn, const CAmount& amountIn, bool storeIn, PrecomputedTransactionData& txdataIn) : TransactionSignatureChecker(txToIn, nInIn, amountIn, txdataIn), store(storeIn) {}
+    CachingTransactionSignatureChecker(const CTransaction* txToIn, unsigned int nInIn, const CConfidentialValue& amountIn, bool storeIn, PrecomputedTransactionData& txdataIn) : TransactionSignatureChecker(txToIn, nInIn, amountIn, txdataIn), store(storeIn) {}
 
     bool VerifySignature(const std::vector<unsigned char>& vchSig, const CPubKey& vchPubKey, const uint256& sighash) const override;
 };
 
 void InitSignatureCache();
 
+//
+// ELEMENTS:
+
+class CachingRangeProofChecker
+{
+private:
+    bool store;
+public:
+    CachingRangeProofChecker(bool storeIn){
+        store = storeIn;
+    };
+
+    bool VerifyRangeProof(const std::vector<unsigned char>& vchRangeProof, const std::vector<unsigned char>& vchValueCommitment, const std::vector<unsigned char>& vchAssetCommitment, const CScript& scriptPubKey, const secp256k1_context* ctx) const;
+
+};
+
+class CachingSurjectionProofChecker
+{
+private:
+    bool store;
+public:
+    CachingSurjectionProofChecker(bool storeIn){
+        store = storeIn;
+    };
+
+    bool VerifySurjectionProof(secp256k1_surjectionproof& proof, std::vector<secp256k1_generator>& vTags, secp256k1_generator& gen, const secp256k1_context* ctx, const uint256& wtxid) const;
+
+};
+
+void InitRangeproofCache();
+void InitSurjectionproofCache();
+
+// END ELEMENTS
+//
+
 #endif // BITCOIN_SCRIPT_SIGCACHE_H
diff --git a/src/script/sign.cpp b/src/script/sign.cpp
index 5434c7e9ea48f..4c8723575369f 100644
--- a/src/script/sign.cpp
+++ b/src/script/sign.cpp
@@ -15,7 +15,7 @@
 
 typedef std::vector<unsigned char> valtype;
 
-MutableTransactionSignatureCreator::MutableTransactionSignatureCreator(const CMutableTransaction* txToIn, unsigned int nInIn, const CAmount& amountIn, int nHashTypeIn) : txTo(txToIn), nIn(nInIn), nHashType(nHashTypeIn), amount(amountIn), checker(txTo, nIn, amountIn) {}
+MutableTransactionSignatureCreator::MutableTransactionSignatureCreator(const CMutableTransaction* txToIn, unsigned int nInIn, const CConfidentialValue& amountIn, int nHashTypeIn) : txTo(txToIn), nIn(nInIn), nHashType(nHashTypeIn), amount(amountIn), checker(txTo, nIn, amountIn) {}
 
 bool MutableTransactionSignatureCreator::CreateSig(const SigningProvider& provider, std::vector<unsigned char>& vchSig, const CKeyID& address, const CScript& scriptCode, SigVersion sigversion) const
 {
@@ -419,7 +419,7 @@ void SignatureData::MergeSignatureData(SignatureData sigdata)
     signatures.insert(std::make_move_iterator(sigdata.signatures.begin()), std::make_move_iterator(sigdata.signatures.end()));
 }
 
-bool SignSignature(const SigningProvider &provider, const CScript& fromPubKey, CMutableTransaction& txTo, unsigned int nIn, const CAmount& amount, int nHashType)
+bool SignSignature(const SigningProvider &provider, const CScript& fromPubKey, CMutableTransaction& txTo, unsigned int nIn, const CConfidentialValue& amount, int nHashType)
 {
     assert(nIn < txTo.vin.size());
     txTo.witness.vtxinwit.resize(txTo.vin.size());
diff --git a/src/script/sign.h b/src/script/sign.h
index b7df0e3dfbbed..e829f437fb420 100644
--- a/src/script/sign.h
+++ b/src/script/sign.h
@@ -82,11 +82,11 @@ class MutableTransactionSignatureCreator : public BaseSignatureCreator {
     const CMutableTransaction* txTo;
     unsigned int nIn;
     int nHashType;
-    CAmount amount;
+    CConfidentialValue amount;
     const MutableTransactionSignatureChecker checker;
 
 public:
-    MutableTransactionSignatureCreator(const CMutableTransaction* txToIn, unsigned int nInIn, const CAmount& amountIn, int nHashTypeIn = SIGHASH_ALL);
+    MutableTransactionSignatureCreator(const CMutableTransaction* txToIn, unsigned int nInIn, const CConfidentialValue& amountIn, int nHashTypeIn = SIGHASH_ALL);
     const BaseSignatureChecker& Checker() const override { return checker; }
     bool CreateSig(const SigningProvider& provider, std::vector<unsigned char>& vchSig, const CKeyID& keyid, const CScript& scriptCode, SigVersion sigversion) const override;
 };
@@ -703,7 +703,7 @@ struct PartiallySignedTransaction
 bool ProduceSignature(const SigningProvider& provider, const BaseSignatureCreator& creator, const CScript& scriptPubKey, SignatureData& sigdata, unsigned int additional_flags=0);
 
 /** Produce a script signature for a transaction. */
-bool SignSignature(const SigningProvider &provider, const CScript& fromPubKey, CMutableTransaction& txTo, unsigned int nIn, const CAmount& amount, int nHashType);
+bool SignSignature(const SigningProvider &provider, const CScript& fromPubKey, CMutableTransaction& txTo, unsigned int nIn, const CConfidentialValue& amount, int nHashType);
 bool SignSignature(const SigningProvider &provider, const CTransaction& txFrom, CMutableTransaction& txTo, unsigned int nIn, int nHashType);
 
 /** Signs a PSBTInput, verifying that all provided data matches what is being signed. */
diff --git a/src/script/standard.cpp b/src/script/standard.cpp
index baf0e6681b717..badb9c61ddebb 100644
--- a/src/script/standard.cpp
+++ b/src/script/standard.cpp
@@ -21,11 +21,26 @@ unsigned nMaxDatacarrierBytes = MAX_OP_RETURN_RELAY;
 
 CScriptID::CScriptID(const CScript& in) : uint160(Hash160(in.begin(), in.end())) {}
 
+ScriptHash::ScriptHash(const CScript& in) : uint160(Hash160(in.begin(), in.end())) {}
+ScriptHash::ScriptHash(const CScript& in, const CPubKey& blinding_pubkey_in) : uint160(Hash160(in.begin(), in.end())), blinding_pubkey(blinding_pubkey_in) {}
+ScriptHash::ScriptHash(const uint160& hash, const CPubKey& blinding_pubkey_in) : uint160(hash), blinding_pubkey(blinding_pubkey_in) {}
+
+PKHash::PKHash(const CPubKey& pubkey) : uint160(pubkey.GetID()) {}
+PKHash::PKHash(const CPubKey& pubkey, const CPubKey& blinding_pubkey_in) : uint160(pubkey.GetID()), blinding_pubkey(blinding_pubkey_in) {}
+PKHash::PKHash(const uint160& hash, const CPubKey& blinding_pubkey_in) : uint160(hash), blinding_pubkey(blinding_pubkey_in) {}
+
 WitnessV0ScriptHash::WitnessV0ScriptHash(const CScript& in)
 {
     CSHA256().Write(in.data(), in.size()).Finalize(begin());
 }
 
+WitnessV0ScriptHash::WitnessV0ScriptHash(const CScript& in, const CPubKey& blinding_pubkey_in)
+{
+    CSHA256().Write(in.data(), in.size()).Finalize(begin());
+    blinding_pubkey = blinding_pubkey_in;
+}
+
+
 const char* GetTxnOutputType(txnouttype t)
 {
     switch (t)
@@ -40,6 +55,7 @@ const char* GetTxnOutputType(txnouttype t)
     case TX_WITNESS_V0_SCRIPTHASH: return "witness_v0_scripthash";
     case TX_WITNESS_UNKNOWN: return "witness_unknown";
     case TX_TRUE: return "true";
+    case TX_FEE: return "fee";
     }
     return nullptr;
 }
@@ -98,6 +114,11 @@ txnouttype Solver(const CScript& scriptPubKey, std::vector<std::vector<unsigned
         return TX_TRUE;
     }
 
+    // Fee outputs are for elements-style transactions only
+    if (g_con_elementsmode && scriptPubKey == CScript()) {
+        return TX_FEE;
+    }
+
     // Shortcut for pay-to-script-hash, which are more constrained than the other types:
     // it is always OP_HASH160 20 [20 byte hash] OP_EQUAL
     if (scriptPubKey.IsPayToScriptHash())
@@ -174,17 +195,17 @@ bool ExtractDestination(const CScript& scriptPubKey, CTxDestination& addressRet)
         if (!pubKey.IsValid())
             return false;
 
-        addressRet = pubKey.GetID();
+        addressRet = PKHash(pubKey);
         return true;
     }
     else if (whichType == TX_PUBKEYHASH)
     {
-        addressRet = CKeyID(uint160(vSolutions[0]));
+        addressRet = PKHash(uint160(vSolutions[0]));
         return true;
     }
     else if (whichType == TX_SCRIPTHASH)
     {
-        addressRet = CScriptID(uint160(vSolutions[0]));
+        addressRet = ScriptHash(uint160(vSolutions[0]));
         return true;
     } else if (whichType == TX_WITNESS_V0_KEYHASH) {
         WitnessV0KeyHash hash;
@@ -229,7 +250,7 @@ bool ExtractDestinations(const CScript& scriptPubKey, txnouttype& typeRet, std::
             if (!pubKey.IsValid())
                 continue;
 
-            CTxDestination address = pubKey.GetID();
+            CTxDestination address = PKHash(pubKey);
             addressRet.push_back(address);
         }
 
@@ -262,13 +283,13 @@ class CScriptVisitor : public boost::static_visitor<bool>
         return false;
     }
 
-    bool operator()(const CKeyID &keyID) const {
+    bool operator()(const PKHash &keyID) const {
         script->clear();
         *script << OP_DUP << OP_HASH160 << ToByteVector(keyID) << OP_EQUALVERIFY << OP_CHECKSIG;
         return true;
     }
 
-    bool operator()(const CScriptID &scriptID) const {
+    bool operator()(const ScriptHash &scriptID) const {
         script->clear();
         *script << OP_HASH160 << ToByteVector(scriptID) << OP_EQUAL;
         return true;
diff --git a/src/script/standard.h b/src/script/standard.h
index db1e082a0aae8..92ebc7da0ffac 100644
--- a/src/script/standard.h
+++ b/src/script/standard.h
@@ -13,6 +13,8 @@
 
 #include <stdint.h>
 
+#include <pubkey.h> // blinding_pubkey
+
 static const bool DEFAULT_ACCEPT_DATACARRIER = true;
 
 class CKeyID;
@@ -66,6 +68,8 @@ enum txnouttype
     TX_WITNESS_V0_KEYHASH,
     TX_WITNESS_UNKNOWN, //!< Only for Witness versions not already defined above
     TX_TRUE, // For testing purposes only
+    // ELEMENTS:
+    TX_FEE,
 };
 
 class CNoDestination {
@@ -74,19 +78,45 @@ class CNoDestination {
     friend bool operator<(const CNoDestination &a, const CNoDestination &b) { return true; }
 };
 
+struct PKHash : public uint160
+{
+    PKHash() : uint160() {}
+    explicit PKHash(const uint160& hash) : uint160(hash) {}
+    explicit PKHash(const CPubKey& pubkey);
+    explicit PKHash(const CPubKey& pubkey, const CPubKey& blinding_pubkey);
+    explicit PKHash(const uint160& hash, const CPubKey& blinding_pubkey);
+    using uint160::uint160;
+    CPubKey blinding_pubkey;
+};
+
+struct ScriptHash : public uint160
+{
+    ScriptHash() : uint160() {}
+    explicit ScriptHash(const uint160& hash) : uint160(hash) {}
+    explicit ScriptHash(const CScript& script);
+    explicit ScriptHash(const CScript& script, const CPubKey& blinding_pubkey);
+    explicit ScriptHash(const uint160& hash, const CPubKey& blinding_pubkey);
+    using uint160::uint160;
+    CPubKey blinding_pubkey;
+};
+
 struct WitnessV0ScriptHash : public uint256
 {
     WitnessV0ScriptHash() : uint256() {}
     explicit WitnessV0ScriptHash(const uint256& hash) : uint256(hash) {}
     explicit WitnessV0ScriptHash(const CScript& script);
+    explicit WitnessV0ScriptHash(const CScript& script, const CPubKey& blinding_pubkey);
     using uint256::uint256;
+    CPubKey blinding_pubkey;
 };
 
 struct WitnessV0KeyHash : public uint160
 {
     WitnessV0KeyHash() : uint160() {}
     explicit WitnessV0KeyHash(const uint160& hash) : uint160(hash) {}
+    explicit WitnessV0KeyHash(const uint160& hash, const CPubKey& blinding_pubkey_in) : uint160(hash), blinding_pubkey(blinding_pubkey_in) {}
     using uint160::uint160;
+    CPubKey blinding_pubkey;
 };
 
 //! CTxDestination subtype to encode any future Witness version
@@ -95,6 +125,7 @@ struct WitnessUnknown
     unsigned int version;
     unsigned int length;
     unsigned char program[40];
+    CPubKey blinding_pubkey;
 
     friend bool operator==(const WitnessUnknown& w1, const WitnessUnknown& w2) {
         if (w1.version != w2.version) return false;
@@ -129,15 +160,15 @@ class NullData
 /**
  * A txout script template with a specific destination. It is either:
  *  * CNoDestination: no destination set
- *  * CKeyID: TX_PUBKEYHASH destination (P2PKH)
- *  * CScriptID: TX_SCRIPTHASH destination (P2SH)
+ *  * PKHash: TX_PUBKEYHASH destination (P2PKH)
+ *  * ScriptHash: TX_SCRIPTHASH destination (P2SH)
  *  * WitnessV0ScriptHash: TX_WITNESS_V0_SCRIPTHASH destination (P2WSH)
  *  * WitnessV0KeyHash: TX_WITNESS_V0_KEYHASH destination (P2WPKH)
  *  * WitnessUnknown: TX_WITNESS_UNKNOWN destination (P2W???)
  *  * NullData: TX_NULL_DATA destination (OP_RETURN)
  *  A CTxDestination is the internal data type encoded in a bitcoin address
  */
-typedef boost::variant<CNoDestination, CKeyID, CScriptID, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessUnknown, NullData> CTxDestination;
+typedef boost::variant<CNoDestination, PKHash, ScriptHash, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessUnknown, NullData> CTxDestination;
 
 /** Check whether a CTxDestination is a CNoDestination. */
 bool IsValidDestination(const CTxDestination& dest);
diff --git a/src/test/blind_tests.cpp b/src/test/blind_tests.cpp
new file mode 100644
index 0000000000000..e7066678616ab
--- /dev/null
+++ b/src/test/blind_tests.cpp
@@ -0,0 +1,370 @@
+// Copyright (c) 2013-2019 The Elements Core developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <arith_uint256.h>
+#include <blind.h>
+#include <coins.h>
+#include <uint256.h>
+#include <validation.h>
+
+#include <test/test_bitcoin.h>
+
+#include <boost/test/unit_test.hpp>
+
+#include <secp256k1.h>
+
+// For elements serialization rules
+struct ElementsSetup : public TestingSetup {
+        ElementsSetup() : TestingSetup("custom") {}
+};
+
+BOOST_FIXTURE_TEST_SUITE(blind_tests, ElementsSetup)
+
+// TODO: Make deterministic blinding wrapper function, test caching more exactly
+
+BOOST_AUTO_TEST_CASE(naive_blinding_test)
+{
+    CKey key1;
+    CKey key2;
+    CKey keyDummy;
+
+    // Any asset id will do
+    CAsset bitcoinID(GetRandHash());
+    CAsset otherID(GetRandHash());
+    CAsset unblinded_id;
+    uint256 asset_blind;
+    CScript op_true(OP_TRUE);
+    std::vector<CKey> vDummy;
+
+    unsigned char k1[32] = {1,2,3};
+    unsigned char k2[32] = {22,33,44};
+    unsigned char kDummy[32] = {133,144,155};
+    key1.Set(&k1[0], &k1[32], true);
+    key2.Set(&k2[0], &k2[32], true);
+    keyDummy.Set(&kDummy[0], &kDummy[32], true);
+    CPubKey pubkey1 = key1.GetPubKey();
+    CPubKey pubkey2 = key2.GetPubKey();
+    CPubKey pubkeyDummy = keyDummy.GetPubKey();
+
+    uint256 blind3, blind4, blindDummy;
+
+    std::vector<CTxOut> inputs;
+    CTxOut btc_oo(bitcoinID, 11, CScript());
+    CTxOut btc_ooo(bitcoinID, 111, CScript());
+    CTxOut other_fzz(otherID, 500, CScript());
+    CTxOut blind_ozz; // Will be computed later
+
+    {
+        inputs.clear();
+        inputs.push_back(btc_oo);
+        inputs.push_back(btc_ooo);
+
+        // Build a transaction that spends 2 unblinded coins (11, 111), and produces a single blinded one (100) and fee (22).
+        CMutableTransaction tx3;
+        tx3.vin.resize(2);
+        tx3.vin[0].prevout.hash = ArithToUint256(1);
+
+        tx3.vin[0].prevout.n = 0;
+        tx3.vin[1].prevout.hash = ArithToUint256(2);
+        tx3.vin[1].prevout.n = 0;
+        tx3.vout.resize(0);
+        tx3.vout.push_back(CTxOut(bitcoinID, 100, CScript() << OP_TRUE));
+        // Fee outputs are blank scriptpubkeys, and unblinded value/asset
+        tx3.vout.push_back(CTxOut(bitcoinID, 22, CScript()));
+        BOOST_CHECK(VerifyAmounts(inputs, tx3, nullptr, false));
+
+        // Malleate the output and check for correct handling of bad commitments
+        // These will fail IsValid checks
+        std::vector<unsigned char> asset_copy(tx3.vout[0].nAsset.vchCommitment);
+        std::vector<unsigned char> value_copy(tx3.vout[0].nValue.vchCommitment);
+        tx3.vout[0].nAsset.vchCommitment[0] = 122;
+        BOOST_CHECK(!VerifyAmounts(inputs, tx3, nullptr, false));
+        tx3.vout[0].nAsset.vchCommitment = asset_copy;
+        tx3.vout[0].nValue.vchCommitment[0] = 122;
+        BOOST_CHECK(!VerifyAmounts(inputs, tx3, nullptr, false));
+        tx3.vout[0].nValue.vchCommitment = value_copy;
+
+        // Make sure null values are handled correctly
+        tx3.vout[0].nAsset.SetNull();
+        BOOST_CHECK(!VerifyAmounts(inputs, tx3, nullptr, false));
+        tx3.vout[0].nAsset.vchCommitment = asset_copy;
+        tx3.vout[0].nValue.SetNull();
+        BOOST_CHECK(!VerifyAmounts(inputs, tx3, nullptr, false));
+        tx3.vout[0].nValue.vchCommitment = value_copy;
+
+        // Bad nonce values will result in failure to deserialize
+        tx3.vout[0].nNonce.SetNull();
+        BOOST_CHECK(VerifyAmounts(inputs, tx3, nullptr, false));
+        tx3.vout[0].nNonce.vchCommitment = tx3.vout[0].nValue.vchCommitment;
+        BOOST_CHECK(!VerifyAmounts(inputs, tx3, nullptr, false));
+
+        // Try to blind with a single non-fee output, which fails as its blinding factor ends up being zero.
+        std::vector<uint256> input_blinds;
+        std::vector<uint256> input_asset_blinds;
+        std::vector<CAsset> input_assets;
+        std::vector<CAmount> input_amounts;
+        std::vector<uint256> output_blinds;
+        std::vector<uint256> output_asset_blinds;
+        std::vector<CPubKey> output_pubkeys;
+        input_blinds.push_back(uint256());
+        input_blinds.push_back(uint256());
+        input_asset_blinds.push_back(uint256());
+        input_asset_blinds.push_back(uint256());
+        input_assets.push_back(bitcoinID);
+        input_assets.push_back(bitcoinID);
+        input_amounts.push_back(11);
+        input_amounts.push_back(111);
+        output_pubkeys.push_back(pubkey1);
+        output_pubkeys.push_back(CPubKey());
+        BOOST_CHECK(BlindTransaction(input_blinds, input_asset_blinds, input_assets, input_amounts, output_blinds, output_asset_blinds, output_pubkeys, vDummy, vDummy, tx3) == 0);
+
+        // Add a dummy output. Must be unspendable since it's 0-valued.
+        tx3.vout.push_back(CTxOut(bitcoinID, 0, CScript() << OP_RETURN));
+        output_pubkeys.push_back(pubkeyDummy);
+        BOOST_CHECK(BlindTransaction(input_blinds, input_asset_blinds, input_assets, input_amounts, output_blinds, output_asset_blinds, output_pubkeys, vDummy, vDummy, tx3) == 2);
+        BOOST_CHECK(!tx3.vout[0].nValue.IsExplicit());
+        BOOST_CHECK(!tx3.vout[2].nValue.IsExplicit());
+        BOOST_CHECK(VerifyAmounts(inputs, tx3, nullptr, false));
+
+        CAmount unblinded_amount;
+        BOOST_CHECK(UnblindConfidentialPair(key2, tx3.vout[0].nValue, tx3.vout[0].nAsset, tx3.vout[0].nNonce, op_true, tx3.witness.vtxoutwit[0].vchRangeproof, unblinded_amount, blind3, unblinded_id, asset_blind) == 0);
+        // Saving unblinded_id and asset_blind for later since we need for input
+        BOOST_CHECK(UnblindConfidentialPair(key1, tx3.vout[0].nValue, tx3.vout[0].nAsset, tx3.vout[0].nNonce, op_true, tx3.witness.vtxoutwit[0].vchRangeproof, unblinded_amount, blind3, unblinded_id, asset_blind) == 1);
+        BOOST_CHECK(unblinded_amount == 100);
+        BOOST_CHECK(unblinded_id == bitcoinID);
+        CAsset temp_asset;
+        uint256 temp_asset_blinder;
+        BOOST_CHECK(UnblindConfidentialPair(keyDummy, tx3.vout[2].nValue, tx3.vout[2].nAsset, tx3.vout[2].nNonce, CScript() << OP_RETURN, tx3.witness.vtxoutwit[2].vchRangeproof, unblinded_amount, blindDummy, temp_asset, temp_asset_blinder) == 1);
+        BOOST_CHECK(unblinded_amount == 0);
+
+        // Storing for next section
+        BOOST_CHECK(tx3.vout[0].nValue.IsCommitment());
+        BOOST_CHECK(tx3.vout[0].nAsset.IsCommitment());
+        blind_ozz = tx3.vout[0];
+
+        tx3.vout[1].nValue = CConfidentialValue(tx3.vout[1].nValue.GetAmount() - 1);
+        BOOST_CHECK(!VerifyAmounts(inputs, tx3, nullptr, false));
+    }
+
+    {
+        inputs.clear();
+        inputs.push_back(btc_ooo);
+        inputs.push_back(blind_ozz);
+
+        // Build a transactions that spends an unblinded (111) and blinded (100) coin, and produces only unblinded coins (impossible)
+        CMutableTransaction tx4;
+        tx4.vin.resize(2);
+        tx4.vin[0].prevout.hash = ArithToUint256(2);
+        tx4.vin[0].prevout.n = 0;
+        tx4.vin[1].prevout.hash = ArithToUint256(3);
+        tx4.vin[1].prevout.n = 0;
+        tx4.vout.push_back(CTxOut(bitcoinID, 30, CScript() << OP_TRUE));
+        tx4.vout.push_back(CTxOut(bitcoinID, 40, CScript() << OP_TRUE));
+        tx4.vout.push_back(CTxOut(bitcoinID, 111+100-30-40, CScript()));
+        BOOST_CHECK(!VerifyAmounts(inputs, tx4, nullptr, false)); // Spends a blinded coin with no blinded outputs to compensate.
+
+        std::vector<uint256> input_blinds;
+        std::vector<uint256> input_asset_blinds;
+        std::vector<CAsset> input_assets;
+        std::vector<CAmount> input_amounts;
+        std::vector<uint256> output_blinds;
+        std::vector<uint256> output_asset_blinds;
+        std::vector<CPubKey> output_pubkeys;
+        input_blinds.push_back(uint256());
+        input_blinds.push_back(blind3);
+        input_asset_blinds.push_back(uint256());
+        input_asset_blinds.push_back(asset_blind);
+        input_amounts.push_back(111);
+        input_amounts.push_back(100);
+        input_assets.push_back(unblinded_id);
+        input_assets.push_back(unblinded_id);
+        output_pubkeys.push_back(CPubKey());
+        output_pubkeys.push_back(CPubKey());
+        output_pubkeys.push_back(CPubKey());
+        BOOST_CHECK(BlindTransaction(input_blinds, input_asset_blinds, input_assets, input_amounts, output_blinds, output_asset_blinds, output_pubkeys, vDummy, vDummy, tx4) == 0); // Blinds nothing
+    }
+
+    {
+        inputs.clear();
+        inputs.push_back(btc_ooo);
+        inputs.push_back(blind_ozz);
+
+        // Build a transactions that spends an unblinded (111) and blinded (100) coin, and produces a blinded (30), unblinded (40), and blinded (50) coin and fee (91)
+        CMutableTransaction tx4;
+        tx4.vin.resize(2);
+        tx4.vin[0].prevout.hash = ArithToUint256(2);
+        tx4.vin[0].prevout.n = 0;
+        tx4.vin[1].prevout.hash = ArithToUint256(3);
+        tx4.vin[1].prevout.n = 0;
+        tx4.vout.push_back(CTxOut(bitcoinID, 30, CScript() << OP_TRUE));
+        tx4.vout.push_back(CTxOut(bitcoinID, 40, CScript() << OP_TRUE));
+        tx4.vout.push_back(CTxOut(bitcoinID, 50, CScript() << OP_TRUE));
+        // Fee
+        tx4.vout.push_back(CTxOut(bitcoinID, 111+100-30-40-50, CScript()));
+        BOOST_CHECK(!VerifyAmounts(inputs, tx4, nullptr, false)); // Spends a blinded coin with no blinded outputs to compensate.
+
+        std::vector<uint256> input_blinds;
+        std::vector<uint256> input_asset_blinds;
+        std::vector<CAsset> input_assets;
+        std::vector<CAmount> input_amounts;
+        std::vector<uint256> output_blinds;
+        std::vector<uint256> output_asset_blinds;
+        std::vector<CPubKey> output_pubkeys;
+
+        input_blinds.push_back(uint256());
+        input_blinds.push_back(blind3);
+        input_asset_blinds.push_back(uint256());
+        input_asset_blinds.push_back(asset_blind);
+        input_amounts.push_back(111);
+        input_amounts.push_back(100);
+        input_assets.push_back(unblinded_id);
+        input_assets.push_back(unblinded_id);
+
+        output_pubkeys.push_back(pubkey2);
+        output_pubkeys.push_back(CPubKey());
+        output_pubkeys.push_back(pubkey2);
+        output_pubkeys.push_back(CPubKey());
+
+        BOOST_CHECK(BlindTransaction(input_blinds, input_asset_blinds, input_assets, input_amounts, output_blinds, output_asset_blinds, output_pubkeys, vDummy, vDummy, tx4) == 2);
+        BOOST_CHECK(!tx4.vout[0].nValue.IsExplicit());
+        BOOST_CHECK(tx4.vout[1].nValue.IsExplicit());
+        BOOST_CHECK(!tx4.vout[2].nValue.IsExplicit());
+        // This one broken
+        BOOST_CHECK(VerifyAmounts(inputs, tx4, nullptr, false));
+
+        CAmount unblinded_amount;
+        CAsset asset_out;
+        uint256 asset_blinder_out;
+        BOOST_CHECK(UnblindConfidentialPair(key1, tx4.vout[0].nValue, tx4.vout[0].nAsset, tx4.vout[0].nNonce, op_true, tx4.witness.vtxoutwit[0].vchRangeproof, unblinded_amount, blind4, asset_out, asset_blinder_out) == 0);
+        BOOST_CHECK(UnblindConfidentialPair(key2, tx4.vout[0].nValue, tx4.vout[0].nAsset, tx4.vout[0].nNonce, op_true, tx4.witness.vtxoutwit[0].vchRangeproof, unblinded_amount, blind4, asset_out, asset_blinder_out) == 1);
+        BOOST_CHECK(unblinded_amount == 30);
+        BOOST_CHECK(asset_out == unblinded_id);
+        BOOST_CHECK(UnblindConfidentialPair(key2, tx4.vout[2].nValue, tx4.vout[2].nAsset, tx4.vout[2].nNonce, op_true, tx4.witness.vtxoutwit[2].vchRangeproof, unblinded_amount, blind4, asset_out, asset_blinder_out) == 1);
+        BOOST_CHECK(asset_out == unblinded_id);
+        BOOST_CHECK(unblinded_amount == 50);
+
+        // Commit to the wrong script in the rangeproof
+        BOOST_CHECK(UnblindConfidentialPair(key2, tx4.vout[2].nValue, tx4.vout[2].nAsset, tx4.vout[2].nNonce, CScript() << OP_FALSE, tx4.witness.vtxoutwit[2].vchRangeproof, unblinded_amount, blind4, asset_out, asset_blinder_out) == 0);
+
+        // Make invalid public keys in nonce commitment, first of right size
+        tx4.vout[2].nNonce.vchCommitment = std::vector<unsigned char>(33, 0);
+        tx4.vout[2].nNonce.vchCommitment[0] = 0x03;
+        BOOST_CHECK(UnblindConfidentialPair(key2, tx4.vout[2].nValue, tx4.vout[2].nAsset, tx4.vout[2].nNonce, op_true, tx4.witness.vtxoutwit[2].vchRangeproof, unblinded_amount, blind4, asset_out, asset_blinder_out) == 0);
+
+        // Next, leading byte claiming to be 33 bytes in size
+        tx4.vout[2].nNonce.vchCommitment.resize(1);
+        BOOST_CHECK(UnblindConfidentialPair(key2, tx4.vout[2].nValue, tx4.vout[2].nAsset, tx4.vout[2].nNonce, op_true, tx4.witness.vtxoutwit[2].vchRangeproof, unblinded_amount, blind4, asset_out, asset_blinder_out) == 0);
+
+        // Last, blank nonce commitment
+        tx4.vout[2].nNonce.vchCommitment.clear();
+        BOOST_CHECK(UnblindConfidentialPair(key2, tx4.vout[2].nValue, tx4.vout[2].nAsset, tx4.vout[2].nNonce, op_true, tx4.witness.vtxoutwit[2].vchRangeproof, unblinded_amount, blind4, asset_out, asset_blinder_out) == 0);
+
+        tx4.vout[3].nValue = CConfidentialValue(tx4.vout[3].nValue.GetAmount() - 1);
+        BOOST_CHECK(!VerifyAmounts(inputs, tx4, nullptr, false));
+
+        // Check wallet borromean-based rangeproof results against expected args
+        size_t proof_size = DEFAULT_RANGEPROOF_SIZE;
+        BOOST_CHECK(tx4.witness.vtxoutwit[2].vchRangeproof.size() == proof_size);
+        secp256k1_context *ctx = secp256k1_context_create(SECP256K1_CONTEXT_VERIFY);
+        int exp = 0;
+        int mantissa = 0;
+        uint64_t min_value = 0;
+        uint64_t max_value = 0;
+        BOOST_CHECK(secp256k1_rangeproof_info(ctx, &exp, &mantissa, &min_value, &max_value, tx4.witness.vtxoutwit[2].vchRangeproof.data(), proof_size) == 1);
+        BOOST_CHECK(exp == 0);
+        BOOST_CHECK(mantissa == 36); // 36 bit default
+        BOOST_CHECK(min_value == 1);
+        BOOST_CHECK(max_value == 68719476736);
+    }
+    {
+        inputs.clear();
+        inputs.push_back(blind_ozz);
+        inputs.push_back(other_fzz);
+
+        // Spends 100 blinded bitcoin, 500 of unblinded "other"
+        CMutableTransaction tx5;
+        tx5.vin.resize(0);
+        tx5.vout.resize(0);
+        tx5.vin.push_back(CTxIn(COutPoint(ArithToUint256(3), 0)));
+        tx5.vin.push_back(CTxIn(COutPoint(ArithToUint256(5), 0)));
+        tx5.vout.push_back(CTxOut(bitcoinID, 29, CScript() << OP_TRUE));
+        tx5.vout.push_back(CTxOut(bitcoinID, 70, CScript() << OP_TRUE));
+        tx5.vout.push_back(CTxOut(otherID, 250, CScript() << OP_TRUE));
+        tx5.vout.push_back(CTxOut(otherID, 249, CScript() << OP_TRUE));
+        // Fees
+        tx5.vout.push_back(CTxOut(bitcoinID, 1, CScript()));
+        tx5.vout.push_back(CTxOut(otherID, 1, CScript()));
+
+        // Blinds don't balance
+        BOOST_CHECK(!VerifyAmounts(inputs, tx5, nullptr, false));
+
+        // Blinding setup stuff
+        std::vector<uint256> input_blinds;
+        std::vector<uint256> input_asset_blinds;
+        std::vector<CAsset> input_assets;
+        std::vector<CAmount> input_amounts;
+        std::vector<uint256> output_blinds;
+        std::vector<uint256> output_asset_blinds;
+        std::vector<CPubKey> output_pubkeys;
+        input_blinds.push_back(blind3);
+        input_blinds.push_back(uint256()); //
+        input_asset_blinds.push_back(asset_blind);
+        input_asset_blinds.push_back(uint256());
+        input_amounts.push_back(100);
+        input_amounts.push_back(500);
+        input_assets.push_back(bitcoinID);
+        input_assets.push_back(otherID);
+        for (unsigned int i = 0; i < 6; i++) {
+            output_pubkeys.push_back(pubkey2);
+        }
+
+        CMutableTransaction txtemp(tx5);
+
+        // No blinding keys for fees, bails out blinding nothing, still invalid due to imbalance
+        BOOST_CHECK(BlindTransaction(input_blinds, input_asset_blinds, input_assets, input_amounts, output_blinds, output_asset_blinds, output_pubkeys, vDummy, vDummy, txtemp) == -1);
+        BOOST_CHECK(!VerifyAmounts(inputs, txtemp, nullptr, false));
+        // Last will be implied blank keys
+        output_pubkeys.resize(4);
+
+        // Blind transaction, verify amounts
+        txtemp = tx5;
+        BOOST_CHECK(BlindTransaction(input_blinds, input_asset_blinds, input_assets, input_amounts, output_blinds, output_asset_blinds, output_pubkeys, vDummy, vDummy, txtemp) == 4);
+        BOOST_CHECK(VerifyAmounts(inputs, txtemp, nullptr, false));
+
+        // Transaction may not have spendable 0-value output
+        txtemp.vout.push_back(CTxOut(CAsset(), 0, CScript() << OP_TRUE));
+        BOOST_CHECK(!VerifyAmounts(inputs, txtemp, nullptr, false));
+
+        // Create imbalance by removing fees, should still be able to blind
+        txtemp = tx5;
+        txtemp.vout.resize(5);
+        BOOST_CHECK(!VerifyAmounts(inputs, txtemp, nullptr, false));
+        txtemp.vout.resize(4);
+        BOOST_CHECK(!VerifyAmounts(inputs, txtemp, nullptr, false));
+        BOOST_CHECK(BlindTransaction(input_blinds, input_asset_blinds, input_assets, input_amounts, output_blinds, output_asset_blinds, output_pubkeys, vDummy, vDummy, txtemp) == 4);
+        BOOST_CHECK(!VerifyAmounts(inputs, txtemp, nullptr, false));
+
+        txtemp = tx5;
+        // Remove other input, make surjection proof impossible for 2 "otherID" outputs
+        std::vector<uint256> t_input_blinds;
+        std::vector<uint256> t_input_asset_blinds;
+        std::vector<CAsset> t_input_assets;
+        std::vector<CAmount> t_input_amounts;
+
+        t_input_blinds = input_blinds;
+        t_input_asset_blinds = input_asset_blinds;
+        t_input_assets = input_assets;
+        t_input_amounts = input_amounts;
+        txtemp.vin.resize(1);
+        inputs.resize(1);
+        t_input_blinds.resize(1);
+        t_input_asset_blinds.resize(1);
+        t_input_assets.resize(1);
+        t_input_amounts.resize(1);
+        BOOST_CHECK(!VerifyAmounts(inputs, txtemp, nullptr, false));
+        BOOST_CHECK(BlindTransaction(t_input_blinds, t_input_asset_blinds, t_input_assets, t_input_amounts, output_blinds, output_asset_blinds, output_pubkeys, vDummy, vDummy, txtemp) == 2);
+        BOOST_CHECK(!VerifyAmounts(inputs, txtemp, nullptr, false));
+    }
+}
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/blockfilter_tests.cpp b/src/test/blockfilter_tests.cpp
index 773de343eaefc..6fa06a1852079 100644
--- a/src/test/blockfilter_tests.cpp
+++ b/src/test/blockfilter_tests.cpp
@@ -5,6 +5,7 @@
 #include <test/data/blockfilters.json.h>
 #include <test/test_bitcoin.h>
 
+#include <asset.h>
 #include <blockfilter.h>
 #include <core_io.h>
 #include <serialize.h>
@@ -61,13 +62,13 @@ BOOST_AUTO_TEST_CASE(blockfilter_basic_test)
     excluded_scripts[1] << std::vector<unsigned char>(5, 33) << OP_CHECKSIG;
 
     CMutableTransaction tx_1;
-    tx_1.vout.emplace_back(100, included_scripts[0]);
-    tx_1.vout.emplace_back(200, included_scripts[1]);
+    tx_1.vout.emplace_back(CTxOut(CAsset(), 100, included_scripts[0]));
+    tx_1.vout.emplace_back(CTxOut(CAsset(), 200, included_scripts[1]));
 
     CMutableTransaction tx_2;
-    tx_2.vout.emplace_back(300, included_scripts[2]);
-    tx_2.vout.emplace_back(0, excluded_scripts[0]);
-    tx_2.vout.emplace_back(400, excluded_scripts[2]); // Script is empty
+    tx_2.vout.emplace_back(CTxOut(CAsset(), 300, included_scripts[2]));
+    tx_2.vout.emplace_back(CTxOut(CAsset(), 0, excluded_scripts[0]));
+    tx_2.vout.emplace_back(CTxOut(CAsset(), 400, excluded_scripts[2])); // Script is empty
 
     CBlock block;
     block.vtx.push_back(MakeTransactionRef(tx_1));
@@ -75,9 +76,9 @@ BOOST_AUTO_TEST_CASE(blockfilter_basic_test)
 
     CBlockUndo block_undo;
     block_undo.vtxundo.emplace_back();
-    block_undo.vtxundo.back().vprevout.emplace_back(CTxOut(500, included_scripts[3]), 1000, true);
-    block_undo.vtxundo.back().vprevout.emplace_back(CTxOut(600, included_scripts[4]), 10000, false);
-    block_undo.vtxundo.back().vprevout.emplace_back(CTxOut(700, excluded_scripts[2]), 100000, false);
+    block_undo.vtxundo.back().vprevout.emplace_back(CTxOut(CAsset(), 500, included_scripts[3]), 1000, true);
+    block_undo.vtxundo.back().vprevout.emplace_back(CTxOut(CAsset(), 600, included_scripts[4]), 10000, false);
+    block_undo.vtxundo.back().vprevout.emplace_back(CTxOut(CAsset(), 700, excluded_scripts[2]), 100000, false);
 
     BlockFilter block_filter(BlockFilterType::BASIC, block, block_undo);
     const GCSFilter& filter = block_filter.GetFilter();
@@ -125,7 +126,7 @@ BOOST_AUTO_TEST_CASE(blockfilters_json_test)
         const UniValue& prev_scripts = test[pos++].get_array();
         for (unsigned int ii = 0; ii < prev_scripts.size(); ii++) {
             std::vector<unsigned char> raw_script = ParseHex(prev_scripts[ii].get_str());
-            CTxOut txout(0, CScript(raw_script.begin(), raw_script.end()));
+            CTxOut txout(CAsset(), 0, CScript(raw_script.begin(), raw_script.end()));
             tx_undo.vprevout.emplace_back(txout, 0, false);
         }
 
diff --git a/src/test/checkqueue_tests.cpp b/src/test/checkqueue_tests.cpp
index 2732598b4f434..69590aab43132 100644
--- a/src/test/checkqueue_tests.cpp
+++ b/src/test/checkqueue_tests.cpp
@@ -154,7 +154,7 @@ static void Correct_Queue_range(std::vector<size_t> range)
        tg.create_thread([&]{small_queue->Thread();});
     }
     // Make vChecks here to save on malloc (this test can be slow...)
-    std::vector<FakeCheckCheckCompletion> vChecks;
+    std::vector<FakeCheckCheckCompletion*> vChecks;
     for (const size_t i : range) {
         size_t total = i;
         FakeCheckCheckCompletion::n_calls = 0;
@@ -226,10 +226,10 @@ BOOST_AUTO_TEST_CASE(test_CheckQueue_Catches_Failure)
         while (remaining) {
             size_t r = InsecureRandRange(10);
 
-            std::vector<FailingCheck> vChecks;
-            vChecks.reserve(r);
-            for (size_t k = 0; k < r && remaining; k++, remaining--)
-                vChecks.emplace_back(remaining == 1);
+            std::vector<FailingCheck*> vChecks;
+            for (size_t k = 0; k < r && remaining; k++, remaining--) {
+                vChecks.push_back(new FailingCheck(remaining == 1));
+            }
             control.Add(vChecks);
         }
         bool success = control.Wait();
@@ -256,9 +256,11 @@ BOOST_AUTO_TEST_CASE(test_CheckQueue_Recovers_From_Failure)
         for (const bool end_fails : {true, false}) {
             CCheckQueueControl<FailingCheck> control(fail_queue.get());
             {
-                std::vector<FailingCheck> vChecks;
-                vChecks.resize(100, false);
-                vChecks[99] = end_fails;
+                std::vector<FailingCheck*> vChecks;
+                for (size_t i = 0; i < 100; i++) {
+                    vChecks.push_back(new FailingCheck(false));
+                }
+                vChecks[99] = new FailingCheck(end_fails);
                 control.Add(vChecks);
             }
             bool r =control.Wait();
@@ -287,9 +289,10 @@ BOOST_AUTO_TEST_CASE(test_CheckQueue_UniqueCheck)
         CCheckQueueControl<UniqueCheck> control(queue.get());
         while (total) {
             size_t r = InsecureRandRange(10);
-            std::vector<UniqueCheck> vChecks;
-            for (size_t k = 0; k < r && total; k++)
-                vChecks.emplace_back(--total);
+            std::vector<UniqueCheck*> vChecks;
+            for (size_t k = 0; k < r && total; k++) {
+                vChecks.emplace_back(new UniqueCheck(--total));
+            }
             control.Add(vChecks);
         }
     }
@@ -321,12 +324,12 @@ BOOST_AUTO_TEST_CASE(test_CheckQueue_Memory)
             CCheckQueueControl<MemoryCheck> control(queue.get());
             while (total) {
                 size_t r = InsecureRandRange(10);
-                std::vector<MemoryCheck> vChecks;
+                std::vector<MemoryCheck*> vChecks;
                 for (size_t k = 0; k < r && total; k++) {
                     total--;
                     // Each iteration leaves data at the front, back, and middle
                     // to catch any sort of deallocation failure
-                    vChecks.emplace_back(total == 0 || total == i || total == i/2);
+                    vChecks.emplace_back(new MemoryCheck(total == 0 || total == i || total == i/2));
                 }
                 control.Add(vChecks);
             }
@@ -349,11 +352,12 @@ BOOST_AUTO_TEST_CASE(test_CheckQueue_FrozenCleanup)
     }
     std::thread t0([&]() {
         CCheckQueueControl<FrozenCleanupCheck> control(queue.get());
-        std::vector<FrozenCleanupCheck> vChecks(1);
+        std::vector<FrozenCleanupCheck*> vChecks;
         // Freezing can't be the default initialized behavior given how the queue
         // swaps in default initialized Checks (otherwise freezing destructor
         // would get called twice).
-        vChecks[0].should_freeze = true;
+        vChecks.push_back(new FrozenCleanupCheck());
+        vChecks[0]->should_freeze = true;
         control.Add(vChecks);
         control.Wait(); // Hangs here
     });
diff --git a/src/test/coins_tests.cpp b/src/test/coins_tests.cpp
index 14ab6828f186a..a4ae89805707a 100644
--- a/src/test/coins_tests.cpp
+++ b/src/test/coins_tests.cpp
@@ -481,8 +481,8 @@ BOOST_AUTO_TEST_CASE(ccoins_serialization)
     ss1 >> cc1;
     BOOST_CHECK_EQUAL(cc1.fCoinBase, false);
     BOOST_CHECK_EQUAL(cc1.nHeight, 203998U);
-    BOOST_CHECK_EQUAL(cc1.out.nValue, CAmount{60000000000});
-    BOOST_CHECK_EQUAL(HexStr(cc1.out.scriptPubKey), HexStr(GetScriptForDestination(CKeyID(uint160(ParseHex("816115944e077fe7c803cfa57f29b36bf87c1d35"))))));
+    BOOST_CHECK_EQUAL(cc1.out.nValue.GetAmount(), 60000000000);
+    BOOST_CHECK_EQUAL(HexStr(cc1.out.scriptPubKey), HexStr(GetScriptForDestination(PKHash(uint160(ParseHex("816115944e077fe7c803cfa57f29b36bf87c1d35"))))));
 
     // Good example
     CDataStream ss2(ParseHex("8ddf77bbd123008c988f1a4a4de2161e0f50aac7f17e7f9555caa4"), SER_DISK, CLIENT_VERSION);
@@ -490,8 +490,8 @@ BOOST_AUTO_TEST_CASE(ccoins_serialization)
     ss2 >> cc2;
     BOOST_CHECK_EQUAL(cc2.fCoinBase, true);
     BOOST_CHECK_EQUAL(cc2.nHeight, 120891U);
-    BOOST_CHECK_EQUAL(cc2.out.nValue, 110397);
-    BOOST_CHECK_EQUAL(HexStr(cc2.out.scriptPubKey), HexStr(GetScriptForDestination(CKeyID(uint160(ParseHex("8c988f1a4a4de2161e0f50aac7f17e7f9555caa4"))))));
+    BOOST_CHECK_EQUAL(cc2.out.nValue.GetAmount(), 110397);
+    BOOST_CHECK_EQUAL(HexStr(cc2.out.scriptPubKey), HexStr(GetScriptForDestination(PKHash(uint160(ParseHex("8c988f1a4a4de2161e0f50aac7f17e7f9555caa4"))))));
 
     // Smallest possible example
     CDataStream ss3(ParseHex("000006"), SER_DISK, CLIENT_VERSION);
@@ -499,7 +499,7 @@ BOOST_AUTO_TEST_CASE(ccoins_serialization)
     ss3 >> cc3;
     BOOST_CHECK_EQUAL(cc3.fCoinBase, false);
     BOOST_CHECK_EQUAL(cc3.nHeight, 0U);
-    BOOST_CHECK_EQUAL(cc3.out.nValue, 0);
+    BOOST_CHECK_EQUAL(cc3.out.nValue.GetAmount(), 0);
     BOOST_CHECK_EQUAL(cc3.out.scriptPubKey.size(), 0U);
 
     // scriptPubKey that ends beyond the end of the stream
@@ -577,7 +577,7 @@ void GetCoinsMapEntry(const CCoinsMap& map, CAmount& value, char& flags)
         if (it->second.coin.IsSpent()) {
             value = PRUNED;
         } else {
-            value = it->second.coin.out.nValue;
+            value = it->second.coin.out.nValue.GetAmount();
         }
         flags = it->second.flags;
         assert(flags != NO_ENTRY);
diff --git a/src/test/denialofservice_tests.cpp b/src/test/denialofservice_tests.cpp
index 52bbe96b96e3e..4948fe50e2f3d 100644
--- a/src/test/denialofservice_tests.cpp
+++ b/src/test/denialofservice_tests.cpp
@@ -349,7 +349,7 @@ BOOST_AUTO_TEST_CASE(DoS_mapOrphans)
         tx.vin[0].scriptSig << OP_1;
         tx.vout.resize(1);
         tx.vout[0].nValue = 1*CENT;
-        tx.vout[0].scriptPubKey = GetScriptForDestination(key.GetPubKey().GetID());
+        tx.vout[0].scriptPubKey = GetScriptForDestination(PKHash(key.GetPubKey()));
 
         AddOrphanTx(MakeTransactionRef(tx), i);
     }
@@ -365,7 +365,7 @@ BOOST_AUTO_TEST_CASE(DoS_mapOrphans)
         tx.vin[0].prevout.hash = txPrev->GetHash();
         tx.vout.resize(1);
         tx.vout[0].nValue = 1*CENT;
-        tx.vout[0].scriptPubKey = GetScriptForDestination(key.GetPubKey().GetID());
+        tx.vout[0].scriptPubKey = GetScriptForDestination(PKHash(key.GetPubKey()));
         SignSignature(keystore, *txPrev, tx, 0, SIGHASH_ALL);
 
         AddOrphanTx(MakeTransactionRef(tx), i);
@@ -379,7 +379,7 @@ BOOST_AUTO_TEST_CASE(DoS_mapOrphans)
         CMutableTransaction tx;
         tx.vout.resize(1);
         tx.vout[0].nValue = 1*CENT;
-        tx.vout[0].scriptPubKey = GetScriptForDestination(key.GetPubKey().GetID());
+        tx.vout[0].scriptPubKey = GetScriptForDestination(PKHash(key.GetPubKey()));
         tx.vin.resize(2777);
         for (unsigned int j = 0; j < tx.vin.size(); j++)
         {
diff --git a/src/test/key_tests.cpp b/src/test/key_tests.cpp
index 61db70decbf28..cae9b43562406 100644
--- a/src/test/key_tests.cpp
+++ b/src/test/key_tests.cpp
@@ -68,10 +68,10 @@ BOOST_AUTO_TEST_CASE(key_test1)
     BOOST_CHECK(!key2C.VerifyPubKey(pubkey2));
     BOOST_CHECK(key2C.VerifyPubKey(pubkey2C));
 
-    BOOST_CHECK(DecodeDestination(addr1)  == CTxDestination(pubkey1.GetID()));
-    BOOST_CHECK(DecodeDestination(addr2)  == CTxDestination(pubkey2.GetID()));
-    BOOST_CHECK(DecodeDestination(addr1C) == CTxDestination(pubkey1C.GetID()));
-    BOOST_CHECK(DecodeDestination(addr2C) == CTxDestination(pubkey2C.GetID()));
+    BOOST_CHECK(DecodeDestination(addr1)  == CTxDestination(PKHash(pubkey1)));
+    BOOST_CHECK(DecodeDestination(addr2)  == CTxDestination(PKHash(pubkey2)));
+    BOOST_CHECK(DecodeDestination(addr1C) == CTxDestination(PKHash(pubkey1C)));
+    BOOST_CHECK(DecodeDestination(addr2C) == CTxDestination(PKHash(pubkey2C)));
 
     for (int n=0; n<16; n++)
     {
diff --git a/src/test/miner_tests.cpp b/src/test/miner_tests.cpp
index 3eb8aa14fd419..6b2efb4d3db52 100644
--- a/src/test/miner_tests.cpp
+++ b/src/test/miner_tests.cpp
@@ -160,7 +160,7 @@ static void TestPackageSelection(const CChainParams& chainparams, const CScript&
     // of the transactions is below the min relay fee
     // Remove the low fee transaction and replace with a higher fee transaction
     mempool.removeRecursive(tx);
-    tx.vout[0].nValue -= 2; // Now we should be just over the min relay fee
+    tx.vout[0].nValue = tx.vout[0].nValue.GetAmount() - 2; // Now we should be just over the min relay fee
     hashLowFeeTx = tx.GetHash();
     mempool.addUnchecked(entry.Fee(feeToUse+2).FromTx(tx));
     pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey);
@@ -273,7 +273,7 @@ BOOST_AUTO_TEST_CASE(CreateNewBlock_validity)
     tx.vout[0].nValue = BLOCKSUBSIDY;
     for (unsigned int i = 0; i < 1001; ++i)
     {
-        tx.vout[0].nValue -= LOWFEE;
+        tx.vout[0].nValue = tx.vout[0].nValue.GetAmount() - LOWFEE;
         hash = tx.GetHash();
         bool spendsCoinbase = i == 0; // only first tx spends coinbase
         // If we don't set the # of sig ops in the CTxMemPoolEntry, template creation fails
@@ -288,7 +288,7 @@ BOOST_AUTO_TEST_CASE(CreateNewBlock_validity)
     tx.vout[0].nValue = BLOCKSUBSIDY;
     for (unsigned int i = 0; i < 1001; ++i)
     {
-        tx.vout[0].nValue -= LOWFEE;
+        tx.vout[0].nValue = tx.vout[0].nValue.GetAmount() - LOWFEE;
         hash = tx.GetHash();
         bool spendsCoinbase = i == 0; // only first tx spends coinbase
         // If we do set the # of sig ops in the CTxMemPoolEntry, template creation passes
@@ -309,7 +309,7 @@ BOOST_AUTO_TEST_CASE(CreateNewBlock_validity)
     tx.vout[0].nValue = BLOCKSUBSIDY;
     for (unsigned int i = 0; i < 128; ++i)
     {
-        tx.vout[0].nValue -= LOWFEE;
+        tx.vout[0].nValue = tx.vout[0].nValue.GetAmount() - LOWFEE;
         hash = tx.GetHash();
         bool spendsCoinbase = i == 0; // only first tx spends coinbase
         mempool.addUnchecked(entry.Fee(LOWFEE).Time(GetTime()).SpendsCoinbase(spendsCoinbase).FromTx(tx));
@@ -335,7 +335,7 @@ BOOST_AUTO_TEST_CASE(CreateNewBlock_validity)
     tx.vin[1].scriptSig = CScript() << OP_1;
     tx.vin[1].prevout.hash = txFirst[0]->GetHash();
     tx.vin[1].prevout.n = 0;
-    tx.vout[0].nValue = tx.vout[0].nValue+BLOCKSUBSIDY-HIGHERFEE; //First txn output + fresh coinbase - new txn fee
+    tx.vout[0].nValue = tx.vout[0].nValue.GetAmount() + BLOCKSUBSIDY - HIGHERFEE; //First txn output + fresh coinbase - new txn fee
     hash = tx.GetHash();
     mempool.addUnchecked(entry.Fee(HIGHERFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
     BOOST_CHECK(pblocktemplate = AssemblerForTest(chainparams).CreateNewBlock(scriptPubKey));
@@ -399,12 +399,12 @@ BOOST_AUTO_TEST_CASE(CreateNewBlock_validity)
     tx.vin[0].scriptSig = CScript() << OP_1;
     tx.vout[0].nValue = BLOCKSUBSIDY-LOWFEE;
     script = CScript() << OP_0;
-    tx.vout[0].scriptPubKey = GetScriptForDestination(CScriptID(script));
+    tx.vout[0].scriptPubKey = GetScriptForDestination(ScriptHash(script));
     hash = tx.GetHash();
     mempool.addUnchecked(entry.Fee(LOWFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
     tx.vin[0].prevout.hash = hash;
     tx.vin[0].scriptSig = CScript() << std::vector<unsigned char>(script.begin(), script.end());
-    tx.vout[0].nValue -= LOWFEE;
+    tx.vout[0].nValue = tx.vout[0].nValue.GetAmount() - LOWFEE;
     hash = tx.GetHash();
     mempool.addUnchecked(entry.Fee(LOWFEE).Time(GetTime()).SpendsCoinbase(false).FromTx(tx));
     // Should throw block-validation-failed
diff --git a/src/test/pegin_witness_tests.cpp b/src/test/pegin_witness_tests.cpp
index 7e29205c1291c..ea76bbc64fc89 100644
--- a/src/test/pegin_witness_tests.cpp
+++ b/src/test/pegin_witness_tests.cpp
@@ -25,16 +25,14 @@
 
 std::vector<std::vector<unsigned char> > witness_stack = {
     ParseHex("00ca9a3b00000000"),
-    ParseHex("e48a1a02a8f799892fda58347c2d794144311d4307dbfd10f77ffe28088c60be"),
+    ParseHex("ef4699c160d014d5ff79636d8a4cb990b9df4ebab649f144d19f5c495c585e47"),
     ParseHex("06226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f"),
     ParseHex("00141eef6361cd1507a303834285d1521d6baf1b19ae"),
     ParseHex("0200000001b399292c8100b8a1b66eb23896f799c1712390d560af0f70e81acd2d17a3b06e0000000049483045022100c3c749623486ea57ea93dfaf78d85590d78c7590a25768fe80f0ea4d6047419002202a0a00a90392b86c53c0fdda908c4591ba28040c16c25734c23b7df3c8b70acd01feffffff0228196bee000000001976a914470dd41542ee1a1bd75f1a838878648c8d65622488ac00ca9a3b0000000017a914cb60b1d7f76ba12b45a116c482c165a74c5d7e388765000000"),
     ParseHex("000000205e3913a320cd2e3a2efa141e47419f54cb9e82320cf8dbc812fc19b9a1b2413a57f5e9fb4fa22de191454a241387f5d10cc794ee0fbf72ae2841baf3129a4eab8133025affff7f20000000000200000002f9d0be670007d38fceece999cb6144658a99c307ccc37f6d8f69129ed0f4545ff321df9790633bc33c67239c4174df8142ee616ee6a2e2788fe4820fe70e9bce0105")
 };
 
-//std::vector<unsigned char> pegin_transaction = ParseHex("020000000101f321df9790633bc33c67239c4174df8142ee616ee6a2e2788fe4820fe70e9bce0100004000ffffffff0201e48a1a02a8f799892fda58347c2d794144311d4307dbfd10f77ffe28088c60be01000000003b9ab2e0001976a914809326f7628dc976fbe63806479a1b8dfcc8c4b988ac01e48a1a02a8f799892fda58347c2d794144311d4307dbfd10f77ffe28088c60be010000000000001720000000000000000002483045022100ae17064745d80650a6a5cbcbe15c8c45ba498d1c6f45a7c0f5f32d871b463fc60220799f2836471702c21f7cfe124651727b530ad41f7af4dc213c65f5030a2f6fc4012103a9d3c6c7c161a565a76113632fe13330cf2c0207ba79a76d1154cdc3cb94d940060800ca9a3b0000000020e48a1a02a8f799892fda58347c2d794144311d4307dbfd10f77ffe28088c60be2006226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f1600141eef6361cd1507a303834285d1521d6baf1b19aebe0200000001b399292c8100b8a1b66eb23896f799c1712390d560af0f70e81acd2d17a3b06e0000000049483045022100c3c749623486ea57ea93dfaf78d85590d78c7590a25768fe80f0ea4d6047419002202a0a00a90392b86c53c0fdda908c4591ba28040c16c25734c23b7df3c8b70acd01feffffff0228196bee000000001976a914470dd41542ee1a1bd75f1a838878648c8d65622488ac00ca9a3b0000000017a914cb60b1d7f76ba12b45a116c482c165a74c5d7e38876500000097000000205e3913a320cd2e3a2efa141e47419f54cb9e82320cf8dbc812fc19b9a1b2413a57f5e9fb4fa22de191454a241387f5d10cc794ee0fbf72ae2841baf3129a4eab8133025affff7f20000000000200000002f9d0be670007d38fceece999cb6144658a99c307ccc37f6d8f69129ed0f4545ff321df9790633bc33c67239c4174df8142ee616ee6a2e2788fe4820fe70e9bce010500000000");
-std::vector<unsigned char> pegin_transaction = ParseHex("020000000101f321df9790633bc33c67239c4174df8142ee616ee6a2e2788fe4820fe70e9bce0100004000ffffffff02e0b29a3b000000001976a914809326f7628dc976fbe63806479a1b8dfcc8c4b988ac2017000000000000000000000002483045022100ae17064745d80650a6a5cbcbe15c8c45ba498d1c6f45a7c0f5f32d871b463fc60220799f2836471702c21f7cfe124651727b530ad41f7af4dc213c65f5030a2f6fc4012103a9d3c6c7c161a565a76113632fe13330cf2c0207ba79a76d1154cdc3cb94d940060800ca9a3b0000000020e48a1a02a8f799892fda58347c2d794144311d4307dbfd10f77ffe28088c60be2006226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f1600141eef6361cd1507a303834285d1521d6baf1b19aebe0200000001b399292c8100b8a1b66eb23896f799c1712390d560af0f70e81acd2d17a3b06e0000000049483045022100c3c749623486ea57ea93dfaf78d85590d78c7590a25768fe80f0ea4d6047419002202a0a00a90392b86c53c0fdda908c4591ba28040c16c25734c23b7df3c8b70acd01feffffff0228196bee000000001976a914470dd41542ee1a1bd75f1a838878648c8d65622488ac00ca9a3b0000000017a914cb60b1d7f76ba12b45a116c482c165a74c5d7e38876500000097000000205e3913a320cd2e3a2efa141e47419f54cb9e82320cf8dbc812fc19b9a1b2413a57f5e9fb4fa22de191454a241387f5d10cc794ee0fbf72ae2841baf3129a4eab8133025affff7f20000000000200000002f9d0be670007d38fceece999cb6144658a99c307ccc37f6d8f69129ed0f4545ff321df9790633bc33c67239c4174df8142ee616ee6a2e2788fe4820fe70e9bce0105");
-
+std::vector<unsigned char> pegin_transaction = ParseHex("020000000101f321df9790633bc33c67239c4174df8142ee616ee6a2e2788fe4820fe70e9bce0100004000ffffffff0201ef4699c160d014d5ff79636d8a4cb990b9df4ebab649f144d19f5c495c585e4701000000003b9ab2e0001976a914809326f7628dc976fbe63806479a1b8dfcc8c4b988ac01ef4699c160d014d5ff79636d8a4cb990b9df4ebab649f144d19f5c495c585e47010000000000001720000000000000000002483045022100ae17064745d80650a6a5cbcbe15c8c45ba498d1c6f45a7c0f5f32d871b463fc60220799f2836471702c21f7cfe124651727b530ad41f7af4dc213c65f5030a2f6fc4012103a9d3c6c7c161a565a76113632fe13330cf2c0207ba79a76d1154cdc3cb94d940060800ca9a3b0000000020ef4699c160d014d5ff79636d8a4cb990b9df4ebab649f144d19f5c495c585e472006226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f1600141eef6361cd1507a303834285d1521d6baf1b19aebe0200000001b399292c8100b8a1b66eb23896f799c1712390d560af0f70e81acd2d17a3b06e0000000049483045022100c3c749623486ea57ea93dfaf78d85590d78c7590a25768fe80f0ea4d6047419002202a0a00a90392b86c53c0fdda908c4591ba28040c16c25734c23b7df3c8b70acd01feffffff0228196bee000000001976a914470dd41542ee1a1bd75f1a838878648c8d65622488ac00ca9a3b0000000017a914cb60b1d7f76ba12b45a116c482c165a74c5d7e38876500000097000000205e3913a320cd2e3a2efa141e47419f54cb9e82320cf8dbc812fc19b9a1b2413a57f5e9fb4fa22de191454a241387f5d10cc794ee0fbf72ae2841baf3129a4eab8133025affff7f20000000000200000002f9d0be670007d38fceece999cb6144658a99c307ccc37f6d8f69129ed0f4545ff321df9790633bc33c67239c4174df8142ee616ee6a2e2788fe4820fe70e9bce010500000000");
 
 COutPoint prevout(uint256S("ce9b0ee70f82e48f78e2a2e66e61ee4281df74419c23673cc33b639097df21f3"), 1);
 
@@ -59,10 +57,6 @@ BOOST_AUTO_TEST_CASE(witness_valid)
     // Missing byte on each field to make claim ill-formatted
     // This will break deserialization and other data-matching checks
     for (unsigned int i = 0; i < witness.stack.size(); i++) {
-        //TODO(rebase) CA remove this exception
-        if (i == 1) {
-            continue;
-        }
         witness.stack[i].pop_back();
         BOOST_CHECK(!IsValidPeginWitness(witness, prevout, err, false));
         witness.stack = witness_stack;
@@ -95,7 +89,12 @@ BOOST_AUTO_TEST_CASE(witness_valid)
     // Check validation of peg-in transaction's inputs and balance
     CDataStream ssTx(pegin_transaction, SER_NETWORK, PROTOCOL_VERSION);
     CTransactionRef txRef;
-    ssTx >> txRef;
+    try {
+        ssTx >> txRef;
+    } catch (...) {
+        BOOST_CHECK(false);
+        return;
+    }
     CTransaction tx(*txRef);
 
     // Only one(valid) input witness should exist, and should match
@@ -103,16 +102,16 @@ BOOST_AUTO_TEST_CASE(witness_valid)
     BOOST_CHECK(tx.witness.vtxinwit[0].m_pegin_witness.stack == witness_stack);
     BOOST_CHECK(tx.vin[0].m_is_pegin);
     // Check that serialization doesn't cause issuance to become non-null
-    //TODO(rebase) CA
-    //BOOST_CHECK(tx.vin[0].assetIssuance.IsNull());
+    BOOST_CHECK(tx.vin[0].assetIssuance.IsNull());
     BOOST_CHECK(IsValidPeginWitness(tx.witness.vtxinwit[0].m_pegin_witness, prevout, err, false));
 
+    CAmountMap fee_map;
+
     std::set<std::pair<uint256, COutPoint> > setPeginsSpent;
     CValidationState state;
     CCoinsView coinsDummy;
     CCoinsViewCache coins(&coinsDummy);
-    CAmount txfee;
-    BOOST_CHECK(Consensus::CheckTxInputs(tx, state, coins, 0, txfee, setPeginsSpent));
+    BOOST_CHECK(Consensus::CheckTxInputs(tx, state, coins, 0, fee_map, setPeginsSpent, NULL, false, true));
     BOOST_CHECK(setPeginsSpent.size() == 1);
     setPeginsSpent.clear();
 
@@ -120,7 +119,7 @@ BOOST_AUTO_TEST_CASE(witness_valid)
     CMutableTransaction mtxn(tx);
     mtxn.witness.vtxinwit[0].m_pegin_witness.SetNull();
     CTransaction tx2(mtxn);
-    BOOST_CHECK(!Consensus::CheckTxInputs(tx2, state, coins, 0, txfee, setPeginsSpent));
+    BOOST_CHECK(!Consensus::CheckTxInputs(tx2, state, coins, 0, fee_map, setPeginsSpent, NULL, false, true));
     BOOST_CHECK(setPeginsSpent.empty());
 
     // Invalidate peg-in (and spending) authorization by pegin marker.
@@ -129,7 +128,7 @@ BOOST_AUTO_TEST_CASE(witness_valid)
     CMutableTransaction mtxn2(tx);
     mtxn2.vin[0].m_is_pegin = false;
     CTransaction tx3(mtxn2);
-    BOOST_CHECK(!Consensus::CheckTxInputs(tx3, state, coins, 0, txfee, setPeginsSpent));
+    BOOST_CHECK(!Consensus::CheckTxInputs(tx3, state, coins, 0, fee_map, setPeginsSpent, NULL, false, true));
     BOOST_CHECK(setPeginsSpent.empty());
 
 
diff --git a/src/test/script_p2sh_tests.cpp b/src/test/script_p2sh_tests.cpp
index 5b10935302a5f..8ae24645244a0 100644
--- a/src/test/script_p2sh_tests.cpp
+++ b/src/test/script_p2sh_tests.cpp
@@ -68,14 +68,14 @@ BOOST_AUTO_TEST_CASE(sign)
     // different keys, straight/P2SH, pubkey/pubkeyhash
     CScript standardScripts[4];
     standardScripts[0] << ToByteVector(key[0].GetPubKey()) << OP_CHECKSIG;
-    standardScripts[1] = GetScriptForDestination(key[1].GetPubKey().GetID());
+    standardScripts[1] = GetScriptForDestination(PKHash(key[1].GetPubKey()));
     standardScripts[2] << ToByteVector(key[1].GetPubKey()) << OP_CHECKSIG;
-    standardScripts[3] = GetScriptForDestination(key[2].GetPubKey().GetID());
+    standardScripts[3] = GetScriptForDestination(PKHash(key[2].GetPubKey()));
     CScript evalScripts[4];
     for (int i = 0; i < 4; i++)
     {
         keystore.AddCScript(standardScripts[i]);
-        evalScripts[i] = GetScriptForDestination(CScriptID(standardScripts[i]));
+        evalScripts[i] = GetScriptForDestination(ScriptHash(standardScripts[i]));
     }
 
     CMutableTransaction txFrom;  // Funding transaction:
@@ -130,7 +130,7 @@ BOOST_AUTO_TEST_CASE(norecurse)
     CScript invalidAsScript;
     invalidAsScript << OP_INVALIDOPCODE << OP_INVALIDOPCODE;
 
-    CScript p2sh = GetScriptForDestination(CScriptID(invalidAsScript));
+    CScript p2sh = GetScriptForDestination(ScriptHash(invalidAsScript));
 
     CScript scriptSig;
     scriptSig << Serialize(invalidAsScript);
@@ -141,7 +141,7 @@ BOOST_AUTO_TEST_CASE(norecurse)
 
     // Try to recur, and verification should succeed because
     // the inner HASH160 <> EQUAL should only check the hash:
-    CScript p2sh2 = GetScriptForDestination(CScriptID(p2sh));
+    CScript p2sh2 = GetScriptForDestination(ScriptHash(p2sh));
     CScript scriptSig2;
     scriptSig2 << Serialize(invalidAsScript) << Serialize(p2sh);
 
@@ -164,7 +164,7 @@ BOOST_AUTO_TEST_CASE(set)
     }
 
     CScript inner[4];
-    inner[0] = GetScriptForDestination(key[0].GetPubKey().GetID());
+    inner[0] = GetScriptForDestination(PKHash(key[0].GetPubKey()));
     inner[1] = GetScriptForMultisig(2, std::vector<CPubKey>(keys.begin(), keys.begin()+2));
     inner[2] = GetScriptForMultisig(1, std::vector<CPubKey>(keys.begin(), keys.begin()+2));
     inner[3] = GetScriptForMultisig(2, std::vector<CPubKey>(keys.begin(), keys.begin()+3));
@@ -172,7 +172,7 @@ BOOST_AUTO_TEST_CASE(set)
     CScript outer[4];
     for (int i = 0; i < 4; i++)
     {
-        outer[i] = GetScriptForDestination(CScriptID(inner[i]));
+        outer[i] = GetScriptForDestination(ScriptHash(inner[i]));
         keystore.AddCScript(inner[i]);
     }
 
@@ -244,7 +244,7 @@ BOOST_AUTO_TEST_CASE(switchover)
     CScript scriptSig;
     scriptSig << Serialize(notValid);
 
-    CScript fund = GetScriptForDestination(CScriptID(notValid));
+    CScript fund = GetScriptForDestination(ScriptHash(notValid));
 
 
     // Validation should succeed under old rules (hash is correct):
@@ -275,11 +275,11 @@ BOOST_AUTO_TEST_CASE(AreInputsStandard)
     txFrom.vout.resize(7);
 
     // First three are standard:
-    CScript pay1 = GetScriptForDestination(key[0].GetPubKey().GetID());
+    CScript pay1 = GetScriptForDestination(PKHash(key[0].GetPubKey()));
     keystore.AddCScript(pay1);
     CScript pay1of3 = GetScriptForMultisig(1, keys);
 
-    txFrom.vout[0].scriptPubKey = GetScriptForDestination(CScriptID(pay1)); // P2SH (OP_CHECKSIG)
+    txFrom.vout[0].scriptPubKey = GetScriptForDestination(ScriptHash(pay1)); // P2SH (OP_CHECKSIG)
     txFrom.vout[0].nValue = 1000;
     txFrom.vout[1].scriptPubKey = pay1; // ordinary OP_CHECKSIG
     txFrom.vout[1].nValue = 2000;
@@ -294,7 +294,7 @@ BOOST_AUTO_TEST_CASE(AreInputsStandard)
     oneAndTwo << OP_2 << ToByteVector(key[3].GetPubKey()) << ToByteVector(key[4].GetPubKey()) << ToByteVector(key[5].GetPubKey());
     oneAndTwo << OP_3 << OP_CHECKMULTISIG;
     keystore.AddCScript(oneAndTwo);
-    txFrom.vout[3].scriptPubKey = GetScriptForDestination(CScriptID(oneAndTwo));
+    txFrom.vout[3].scriptPubKey = GetScriptForDestination(ScriptHash(oneAndTwo));
     txFrom.vout[3].nValue = 4000;
 
     // vout[4] is max sigops:
@@ -303,24 +303,24 @@ BOOST_AUTO_TEST_CASE(AreInputsStandard)
         fifteenSigops << ToByteVector(key[i%3].GetPubKey());
     fifteenSigops << OP_15 << OP_CHECKMULTISIG;
     keystore.AddCScript(fifteenSigops);
-    txFrom.vout[4].scriptPubKey = GetScriptForDestination(CScriptID(fifteenSigops));
+    txFrom.vout[4].scriptPubKey = GetScriptForDestination(ScriptHash(fifteenSigops));
     txFrom.vout[4].nValue = 5000;
 
     // vout[5/6] are non-standard because they exceed MAX_P2SH_SIGOPS
     CScript sixteenSigops; sixteenSigops << OP_16 << OP_CHECKMULTISIG;
     keystore.AddCScript(sixteenSigops);
-    txFrom.vout[5].scriptPubKey = GetScriptForDestination(CScriptID(sixteenSigops));
+    txFrom.vout[5].scriptPubKey = GetScriptForDestination(ScriptHash(sixteenSigops));
     txFrom.vout[5].nValue = 5000;
     CScript twentySigops; twentySigops << OP_CHECKMULTISIG;
     keystore.AddCScript(twentySigops);
-    txFrom.vout[6].scriptPubKey = GetScriptForDestination(CScriptID(twentySigops));
+    txFrom.vout[6].scriptPubKey = GetScriptForDestination(ScriptHash(twentySigops));
     txFrom.vout[6].nValue = 6000;
 
     AddCoins(coins, txFrom, 0);
 
     CMutableTransaction txTo;
     txTo.vout.resize(1);
-    txTo.vout[0].scriptPubKey = GetScriptForDestination(key[1].GetPubKey().GetID());
+    txTo.vout[0].scriptPubKey = GetScriptForDestination(PKHash(key[1].GetPubKey()));
 
     txTo.vin.resize(5);
     for (int i = 0; i < 5; i++)
@@ -343,7 +343,7 @@ BOOST_AUTO_TEST_CASE(AreInputsStandard)
 
     CMutableTransaction txToNonStd1;
     txToNonStd1.vout.resize(1);
-    txToNonStd1.vout[0].scriptPubKey = GetScriptForDestination(key[1].GetPubKey().GetID());
+    txToNonStd1.vout[0].scriptPubKey = GetScriptForDestination(PKHash(key[1].GetPubKey()));
     txToNonStd1.vout[0].nValue = 1000;
     txToNonStd1.vin.resize(1);
     txToNonStd1.vin[0].prevout.n = 5;
@@ -355,7 +355,7 @@ BOOST_AUTO_TEST_CASE(AreInputsStandard)
 
     CMutableTransaction txToNonStd2;
     txToNonStd2.vout.resize(1);
-    txToNonStd2.vout[0].scriptPubKey = GetScriptForDestination(key[1].GetPubKey().GetID());
+    txToNonStd2.vout[0].scriptPubKey = GetScriptForDestination(PKHash(key[1].GetPubKey()));
     txToNonStd2.vout[0].nValue = 1000;
     txToNonStd2.vin.resize(1);
     txToNonStd2.vin[0].prevout.n = 6;
diff --git a/src/test/script_standard_tests.cpp b/src/test/script_standard_tests.cpp
index b3e4b12918437..936284b4cd0e5 100644
--- a/src/test/script_standard_tests.cpp
+++ b/src/test/script_standard_tests.cpp
@@ -179,23 +179,23 @@ BOOST_AUTO_TEST_CASE(script_standard_ExtractDestination)
     s.clear();
     s << ToByteVector(pubkey) << OP_CHECKSIG;
     BOOST_CHECK(ExtractDestination(s, address));
-    BOOST_CHECK(boost::get<CKeyID>(&address) &&
-                *boost::get<CKeyID>(&address) == pubkey.GetID());
+    BOOST_CHECK(boost::get<PKHash>(&address) &&
+                *boost::get<PKHash>(&address) == PKHash(pubkey));
 
     // 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());
+    BOOST_CHECK(boost::get<PKHash>(&address) &&
+                *boost::get<PKHash>(&address) == PKHash(pubkey));
 
     // 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));
+    BOOST_CHECK(boost::get<ScriptHash>(&address) &&
+                *boost::get<ScriptHash>(&address) == ScriptHash(redeemScript));
 
     // TX_MULTISIG
     s.clear();
@@ -255,8 +255,8 @@ BOOST_AUTO_TEST_CASE(script_standard_ExtractDestinations)
     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());
+    BOOST_CHECK(boost::get<PKHash>(&addresses[0]) &&
+                *boost::get<PKHash>(&addresses[0]) == PKHash(pubkeys[0]));
 
     // TX_PUBKEYHASH
     s.clear();
@@ -265,8 +265,8 @@ BOOST_AUTO_TEST_CASE(script_standard_ExtractDestinations)
     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());
+    BOOST_CHECK(boost::get<PKHash>(&addresses[0]) &&
+                *boost::get<PKHash>(&addresses[0]) == PKHash(pubkeys[0]));
 
     // TX_SCRIPTHASH
     CScript redeemScript(s); // initialize with leftover P2PKH script
@@ -276,8 +276,8 @@ BOOST_AUTO_TEST_CASE(script_standard_ExtractDestinations)
     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));
+    BOOST_CHECK(boost::get<ScriptHash>(&addresses[0]) &&
+                *boost::get<ScriptHash>(&addresses[0]) == ScriptHash(redeemScript));
 
     // TX_MULTISIG
     s.clear();
@@ -289,10 +289,10 @@ BOOST_AUTO_TEST_CASE(script_standard_ExtractDestinations)
     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());
+    BOOST_CHECK(boost::get<PKHash>(&addresses[0]) &&
+                *boost::get<PKHash>(&addresses[0]) == PKHash(pubkeys[0]));
+    BOOST_CHECK(boost::get<PKHash>(&addresses[1]) &&
+                *boost::get<PKHash>(&addresses[1]) == PKHash(pubkeys[1]));
 
     // TX_NULL_DATA
     s.clear();
@@ -311,17 +311,17 @@ BOOST_AUTO_TEST_CASE(script_standard_GetScriptFor_)
 
     CScript expected, result;
 
-    // CKeyID
+    // PKHash
     expected.clear();
     expected << OP_DUP << OP_HASH160 << ToByteVector(pubkeys[0].GetID()) << OP_EQUALVERIFY << OP_CHECKSIG;
-    result = GetScriptForDestination(pubkeys[0].GetID());
+    result = GetScriptForDestination(PKHash(pubkeys[0]));
     BOOST_CHECK(result == expected);
 
     // CScriptID
     CScript redeemScript(result);
     expected.clear();
     expected << OP_HASH160 << ToByteVector(CScriptID(redeemScript)) << OP_EQUAL;
-    result = GetScriptForDestination(CScriptID(redeemScript));
+    result = GetScriptForDestination(ScriptHash(redeemScript));
     BOOST_CHECK(result == expected);
 
     // CNoDestination
@@ -421,7 +421,7 @@ BOOST_AUTO_TEST_CASE(script_standard_IsMine)
     // P2PKH compressed
     {
         CBasicKeyStore keystore;
-        scriptPubKey = GetScriptForDestination(pubkeys[0].GetID());
+        scriptPubKey = GetScriptForDestination(PKHash(pubkeys[0]));
 
         // Keystore does not have key
         result = IsMine(keystore, scriptPubKey);
@@ -436,7 +436,7 @@ BOOST_AUTO_TEST_CASE(script_standard_IsMine)
     // P2PKH uncompressed
     {
         CBasicKeyStore keystore;
-        scriptPubKey = GetScriptForDestination(uncompressedPubkey.GetID());
+        scriptPubKey = GetScriptForDestination(PKHash(uncompressedPubkey));
 
         // Keystore does not have key
         result = IsMine(keystore, scriptPubKey);
@@ -452,8 +452,8 @@ BOOST_AUTO_TEST_CASE(script_standard_IsMine)
     {
         CBasicKeyStore keystore;
 
-        CScript redeemScript = GetScriptForDestination(pubkeys[0].GetID());
-        scriptPubKey = GetScriptForDestination(CScriptID(redeemScript));
+        CScript redeemScript = GetScriptForDestination(PKHash(pubkeys[0]));
+        scriptPubKey = GetScriptForDestination(ScriptHash(redeemScript));
 
         // Keystore does not have redeemScript or key
         result = IsMine(keystore, scriptPubKey);
@@ -474,9 +474,9 @@ BOOST_AUTO_TEST_CASE(script_standard_IsMine)
     {
         CBasicKeyStore keystore;
 
-        CScript redeemscript_inner = GetScriptForDestination(pubkeys[0].GetID());
-        CScript redeemscript = GetScriptForDestination(CScriptID(redeemscript_inner));
-        scriptPubKey = GetScriptForDestination(CScriptID(redeemscript));
+        CScript redeemscript_inner = GetScriptForDestination(PKHash(pubkeys[0]));
+        CScript redeemscript = GetScriptForDestination(ScriptHash(redeemscript_inner));
+        scriptPubKey = GetScriptForDestination(ScriptHash(redeemscript));
 
         keystore.AddCScript(redeemscript);
         keystore.AddCScript(redeemscript_inner);
@@ -490,8 +490,8 @@ BOOST_AUTO_TEST_CASE(script_standard_IsMine)
     {
         CBasicKeyStore keystore;
 
-        CScript redeemscript = GetScriptForDestination(pubkeys[0].GetID());
-        CScript witnessscript = GetScriptForDestination(CScriptID(redeemscript));
+        CScript redeemscript = GetScriptForDestination(ScriptHash(PKHash(pubkeys[0])));
+        CScript witnessscript = GetScriptForDestination(ScriptHash(redeemscript));
         scriptPubKey = GetScriptForDestination(WitnessV0ScriptHash(witnessscript));
 
         keystore.AddCScript(witnessscript);
@@ -506,7 +506,7 @@ BOOST_AUTO_TEST_CASE(script_standard_IsMine)
     {
         CBasicKeyStore keystore;
 
-        CScript witnessscript = GetScriptForDestination(WitnessV0KeyHash(pubkeys[0].GetID()));
+        CScript witnessscript = GetScriptForDestination(WitnessV0KeyHash(PKHash(pubkeys[0])));
         scriptPubKey = GetScriptForDestination(WitnessV0ScriptHash(witnessscript));
 
         keystore.AddCScript(witnessscript);
@@ -520,7 +520,7 @@ BOOST_AUTO_TEST_CASE(script_standard_IsMine)
     {
         CBasicKeyStore keystore;
 
-        CScript witnessscript_inner = GetScriptForDestination(pubkeys[0].GetID());
+        CScript witnessscript_inner = GetScriptForDestination(PKHash(pubkeys[0]));
         CScript witnessscript = GetScriptForDestination(WitnessV0ScriptHash(witnessscript_inner));
         scriptPubKey = GetScriptForDestination(WitnessV0ScriptHash(witnessscript));
 
@@ -537,7 +537,7 @@ BOOST_AUTO_TEST_CASE(script_standard_IsMine)
         CBasicKeyStore keystore;
         keystore.AddKey(keys[0]);
 
-        scriptPubKey = GetScriptForDestination(WitnessV0KeyHash(pubkeys[0].GetID()));
+        scriptPubKey = GetScriptForDestination(WitnessV0KeyHash(PKHash(pubkeys[0])));
 
         // Keystore implicitly has key and P2SH redeemScript
         keystore.AddCScript(scriptPubKey);
@@ -550,7 +550,7 @@ BOOST_AUTO_TEST_CASE(script_standard_IsMine)
         CBasicKeyStore keystore;
         keystore.AddKey(uncompressedKey);
 
-        scriptPubKey = GetScriptForDestination(WitnessV0KeyHash(uncompressedPubkey.GetID()));
+        scriptPubKey = GetScriptForDestination(WitnessV0KeyHash(PKHash(uncompressedPubkey)));
 
         // Keystore has key, but no P2SH redeemScript
         result = IsMine(keystore, scriptPubKey);
@@ -598,7 +598,7 @@ BOOST_AUTO_TEST_CASE(script_standard_IsMine)
         keystore.AddKey(keys[1]);
 
         CScript redeemScript = GetScriptForMultisig(2, {uncompressedPubkey, pubkeys[1]});
-        scriptPubKey = GetScriptForDestination(CScriptID(redeemScript));
+        scriptPubKey = GetScriptForDestination(ScriptHash(CScriptID(redeemScript)));
 
         // Keystore has no redeemScript
         result = IsMine(keystore, scriptPubKey);
@@ -664,7 +664,7 @@ BOOST_AUTO_TEST_CASE(script_standard_IsMine)
 
         CScript witnessScript = GetScriptForMultisig(2, {pubkeys[0], pubkeys[1]});
         CScript redeemScript = GetScriptForDestination(WitnessV0ScriptHash(witnessScript));
-        scriptPubKey = GetScriptForDestination(CScriptID(redeemScript));
+        scriptPubKey = GetScriptForDestination(ScriptHash(redeemScript));
 
         // Keystore has no witnessScript, P2SH redeemScript, or keys
         result = IsMine(keystore, scriptPubKey);
diff --git a/src/test/script_tests.cpp b/src/test/script_tests.cpp
index 92b1b2bbc7324..bb524779684f7 100644
--- a/src/test/script_tests.cpp
+++ b/src/test/script_tests.cpp
@@ -183,12 +183,16 @@ void DoTest(const CScript& scriptPubKey, const CScript& scriptSig, const CScript
 #if defined(HAVE_CONSENSUS_LIB)
     CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
     stream << tx2;
+    CDataStream streamVal(SER_NETWORK, PROTOCOL_VERSION);
+    streamVal << txCredit.vout[0].nValue;
+    CDataStream streamVal0(SER_NETWORK, PROTOCOL_VERSION);
+    streamVal0 << CConfidentialValue(0);
     int libconsensus_flags = flags & bitcoinconsensus_SCRIPT_FLAGS_VERIFY_ALL;
     if (libconsensus_flags == flags) {
         if (flags & bitcoinconsensus_SCRIPT_FLAGS_VERIFY_WITNESS) {
-            BOOST_CHECK_MESSAGE(bitcoinconsensus_verify_script_with_amount(scriptPubKey.data(), scriptPubKey.size(), txCredit.vout[0].nValue, (const unsigned char*)&stream[0], stream.size(), 0, libconsensus_flags, nullptr) == expect, message);
+            BOOST_CHECK_MESSAGE(bitcoinconsensus_verify_script_with_amount(scriptPubKey.data(), scriptPubKey.size(), (const unsigned char*)&streamVal[0], streamVal.size(), (const unsigned char*)&stream[0], stream.size(), 0, libconsensus_flags, nullptr) == expect, message);
         } else {
-            BOOST_CHECK_MESSAGE(bitcoinconsensus_verify_script_with_amount(scriptPubKey.data(), scriptPubKey.size(), 0, (const unsigned char*)&stream[0], stream.size(), 0, libconsensus_flags, nullptr) == expect, message);
+            BOOST_CHECK_MESSAGE(bitcoinconsensus_verify_script_with_amount(scriptPubKey.data(), scriptPubKey.size(), (const unsigned char*)&streamVal0[0], streamVal0.size(), (const unsigned char*)&stream[0], stream.size(), 0, libconsensus_flags, nullptr) == expect, message);
             BOOST_CHECK_MESSAGE(bitcoinconsensus_verify_script(scriptPubKey.data(), scriptPubKey.size(), (const unsigned char*)&stream[0], stream.size(), 0, libconsensus_flags, nullptr) == expect,message);
         }
     }
@@ -1189,7 +1193,7 @@ BOOST_AUTO_TEST_CASE(script_combineSigs)
         keystore.AddKey(key);
     }
 
-    CMutableTransaction txFrom = BuildCreditingTransaction(GetScriptForDestination(keys[0].GetPubKey().GetID()));
+    CMutableTransaction txFrom = BuildCreditingTransaction(GetScriptForDestination(PKHash(keys[0].GetPubKey())));
     CMutableTransaction txTo = BuildSpendingTransaction(CScript(), CScriptWitness(), txFrom);
     CScript& scriptPubKey = txFrom.vout[0].scriptPubKey;
     SignatureData scriptSig;
@@ -1215,7 +1219,7 @@ BOOST_AUTO_TEST_CASE(script_combineSigs)
     // P2SH, single-signature case:
     CScript pkSingle; pkSingle << ToByteVector(keys[0].GetPubKey()) << OP_CHECKSIG;
     keystore.AddCScript(pkSingle);
-    scriptPubKey = GetScriptForDestination(CScriptID(pkSingle));
+    scriptPubKey = GetScriptForDestination(ScriptHash(pkSingle));
     SignSignature(keystore, txFrom, txTo, 0, SIGHASH_ALL);
     scriptSig = DataFromTransaction(txTo, 0, txFrom.vout[0]);
     combined = CombineSignatures(txFrom.vout[0], txTo, scriptSig, empty);
diff --git a/src/test/sigopcount_tests.cpp b/src/test/sigopcount_tests.cpp
index d4eec99721f03..d223b4dcce67f 100644
--- a/src/test/sigopcount_tests.cpp
+++ b/src/test/sigopcount_tests.cpp
@@ -39,7 +39,7 @@ BOOST_AUTO_TEST_CASE(GetSigOpCount)
     BOOST_CHECK_EQUAL(s1.GetSigOpCount(true), 3U);
     BOOST_CHECK_EQUAL(s1.GetSigOpCount(false), 21U);
 
-    CScript p2sh = GetScriptForDestination(CScriptID(s1));
+    CScript p2sh = GetScriptForDestination(ScriptHash(s1));
     CScript scriptSig;
     scriptSig << OP_0 << Serialize(s1);
     BOOST_CHECK_EQUAL(p2sh.GetSigOpCount(scriptSig), 3U);
@@ -55,7 +55,7 @@ BOOST_AUTO_TEST_CASE(GetSigOpCount)
     BOOST_CHECK_EQUAL(s2.GetSigOpCount(true), 3U);
     BOOST_CHECK_EQUAL(s2.GetSigOpCount(false), 20U);
 
-    p2sh = GetScriptForDestination(CScriptID(s2));
+    p2sh = GetScriptForDestination(ScriptHash(s2));
     BOOST_CHECK_EQUAL(p2sh.GetSigOpCount(true), 0U);
     BOOST_CHECK_EQUAL(p2sh.GetSigOpCount(false), 0U);
     CScript scriptSig2;
@@ -152,7 +152,7 @@ BOOST_AUTO_TEST_CASE(GetTxSigOpCost)
     // Multisig nested in P2SH
     {
         CScript redeemScript = CScript() << 1 << ToByteVector(pubkey) << ToByteVector(pubkey) << 2 << OP_CHECKMULTISIGVERIFY;
-        CScript scriptPubKey = GetScriptForDestination(CScriptID(redeemScript));
+        CScript scriptPubKey = GetScriptForDestination(ScriptHash(redeemScript));
         CScript scriptSig = CScript() << OP_0 << OP_0 << ToByteVector(redeemScript);
 
         BuildTxs(spendingTx, coins, creationTx, scriptPubKey, scriptSig, CScriptWitness());
@@ -193,7 +193,7 @@ BOOST_AUTO_TEST_CASE(GetTxSigOpCost)
     {
         CScript p2pk = CScript() << ToByteVector(pubkey) << OP_CHECKSIG;
         CScript scriptSig = GetScriptForWitness(p2pk);
-        CScript scriptPubKey = GetScriptForDestination(CScriptID(scriptSig));
+        CScript scriptPubKey = GetScriptForDestination(ScriptHash(scriptSig));
         scriptSig = CScript() << ToByteVector(scriptSig);
         CScriptWitness scriptWitness;
         scriptWitness.stack.push_back(std::vector<unsigned char>(0));
@@ -224,7 +224,7 @@ BOOST_AUTO_TEST_CASE(GetTxSigOpCost)
     {
         CScript witnessScript = CScript() << 1 << ToByteVector(pubkey) << ToByteVector(pubkey) << 2 << OP_CHECKMULTISIGVERIFY;
         CScript redeemScript = GetScriptForWitness(witnessScript);
-        CScript scriptPubKey = GetScriptForDestination(CScriptID(redeemScript));
+        CScript scriptPubKey = GetScriptForDestination(ScriptHash(redeemScript));
         CScript scriptSig = CScript() << ToByteVector(redeemScript);
         CScriptWitness scriptWitness;
         scriptWitness.stack.push_back(std::vector<unsigned char>(0));
diff --git a/src/test/test_bitcoin.cpp b/src/test/test_bitcoin.cpp
index 753ed6f2a88d7..101f086eaa78f 100644
--- a/src/test/test_bitcoin.cpp
+++ b/src/test/test_bitcoin.cpp
@@ -4,6 +4,7 @@
 
 #include <test/test_bitcoin.h>
 
+#include <asset.h>
 #include <chainparams.h>
 #include <consensus/consensus.h>
 #include <consensus/params.h>
@@ -12,10 +13,11 @@
 #include <miner.h>
 #include <net_processing.h>
 #include <pow.h>
-#include <rpc/register.h>
+#include <policy/policy.h>
+#include <streams.h>
 #include <rpc/server.h>
+#include <rpc/register.h>
 #include <script/sigcache.h>
-#include <streams.h>
 #include <ui_interface.h>
 #include <validation.h>
 
@@ -58,6 +60,8 @@ BasicTestingSetup::BasicTestingSetup(const std::string& chainName, const std::st
     SetupNetworking();
     InitSignatureCache();
     InitScriptExecutionCache();
+    InitRangeproofCache();
+    InitSurjectionproofCache();
     fCheckBlockIndex = true;
     // Hack to allow testing of fedpeg args
     if (!fedpegscript.empty()) {
@@ -68,6 +72,11 @@ BasicTestingSetup::BasicTestingSetup(const std::string& chainName, const std::st
     // TODO: fix the code to support SegWit blocks.
     gArgs.ForceSetArg("-vbparams", strprintf("segwit:0:%d", (int64_t)Consensus::BIP9Deployment::NO_TIMEOUT));
     SelectParams(chainName);
+
+    // ELEMENTS:
+    // Set policy asset for correct fee output generation
+    policyAsset = CAsset();
+
     noui_connect();
 }
 
diff --git a/src/test/transaction_tests.cpp b/src/test/transaction_tests.cpp
index 9f4e723c013eb..d65873d6b9ed6 100644
--- a/src/test/transaction_tests.cpp
+++ b/src/test/transaction_tests.cpp
@@ -310,9 +310,9 @@ SetupDummyInputs(CBasicKeyStore& keystoreRet, CCoinsViewCache& coinsRet)
 
     dummyTransactions[1].vout.resize(2);
     dummyTransactions[1].vout[0].nValue = 21*CENT;
-    dummyTransactions[1].vout[0].scriptPubKey = GetScriptForDestination(key[2].GetPubKey().GetID());
+    dummyTransactions[1].vout[0].scriptPubKey = GetScriptForDestination(PKHash(key[2].GetPubKey()));
     dummyTransactions[1].vout[1].nValue = 22*CENT;
-    dummyTransactions[1].vout[1].scriptPubKey = GetScriptForDestination(key[3].GetPubKey().GetID());
+    dummyTransactions[1].vout[1].scriptPubKey = GetScriptForDestination(PKHash(key[3].GetPubKey()));
     AddCoins(coinsRet, dummyTransactions[1], 0);
 
     return dummyTransactions;
@@ -493,10 +493,8 @@ BOOST_AUTO_TEST_CASE(test_big_witness_transaction) {
     }
 
     for(uint32_t i = 0; i < mtx.vin.size(); i++) {
-        std::vector<CScriptCheck> vChecks;
-        CScriptCheck check(coins[tx.vin[i].prevout.n].out, tx, i, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS, false, &txdata);
-        vChecks.push_back(CScriptCheck());
-        check.swap(vChecks.back());
+        std::vector<CScriptCheck*> vChecks;
+        vChecks.push_back(new CScriptCheck(coins[tx.vin[i].prevout.n].out, tx, i, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS, false, &txdata));
         control.Add(vChecks);
     }
 
@@ -574,8 +572,8 @@ BOOST_AUTO_TEST_CASE(test_witness)
     CheckWithFlag(output1, input2, STANDARD_SCRIPT_VERIFY_FLAGS, false);
 
     // P2SH pay-to-compressed-pubkey.
-    CreateCreditAndSpend(keystore, GetScriptForDestination(CScriptID(scriptPubkey1)), output1, input1);
-    CreateCreditAndSpend(keystore, GetScriptForDestination(CScriptID(scriptPubkey2)), output2, input2);
+    CreateCreditAndSpend(keystore, GetScriptForDestination(ScriptHash(scriptPubkey1)), output1, input1);
+    CreateCreditAndSpend(keystore, GetScriptForDestination(ScriptHash(scriptPubkey2)), output2, input2);
     ReplaceRedeemScript(input2.vin[0].scriptSig, scriptPubkey1);
     CheckWithFlag(output1, input1, 0, true);
     CheckWithFlag(output1, input1, SCRIPT_VERIFY_P2SH, true);
@@ -599,8 +597,8 @@ BOOST_AUTO_TEST_CASE(test_witness)
     CheckWithFlag(output1, input2, STANDARD_SCRIPT_VERIFY_FLAGS, false);
 
     // P2SH witness pay-to-compressed-pubkey (v0).
-    CreateCreditAndSpend(keystore, GetScriptForDestination(CScriptID(GetScriptForWitness(scriptPubkey1))), output1, input1);
-    CreateCreditAndSpend(keystore, GetScriptForDestination(CScriptID(GetScriptForWitness(scriptPubkey2))), output2, input2);
+    CreateCreditAndSpend(keystore, GetScriptForDestination(ScriptHash(GetScriptForWitness(scriptPubkey1))), output1, input1);
+    CreateCreditAndSpend(keystore, GetScriptForDestination(ScriptHash(GetScriptForWitness(scriptPubkey2))), output2, input2);
     ReplaceRedeemScript(input2.vin[0].scriptSig, GetScriptForWitness(scriptPubkey1));
     CheckWithFlag(output1, input1, 0, true);
     CheckWithFlag(output1, input1, SCRIPT_VERIFY_P2SH, true);
@@ -624,8 +622,8 @@ BOOST_AUTO_TEST_CASE(test_witness)
     CheckWithFlag(output1, input2, STANDARD_SCRIPT_VERIFY_FLAGS, false);
 
     // P2SH pay-to-uncompressed-pubkey.
-    CreateCreditAndSpend(keystore, GetScriptForDestination(CScriptID(scriptPubkey1L)), output1, input1);
-    CreateCreditAndSpend(keystore, GetScriptForDestination(CScriptID(scriptPubkey2L)), output2, input2);
+    CreateCreditAndSpend(keystore, GetScriptForDestination(ScriptHash(scriptPubkey1L)), output1, input1);
+    CreateCreditAndSpend(keystore, GetScriptForDestination(ScriptHash(scriptPubkey2L)), output2, input2);
     ReplaceRedeemScript(input2.vin[0].scriptSig, scriptPubkey1L);
     CheckWithFlag(output1, input1, 0, true);
     CheckWithFlag(output1, input1, SCRIPT_VERIFY_P2SH, true);
@@ -641,8 +639,8 @@ BOOST_AUTO_TEST_CASE(test_witness)
     CreateCreditAndSpend(keystore, GetScriptForWitness(scriptPubkey2L), output2, input2, false);
 
     // Signing disabled for P2SH witness pay-to-uncompressed-pubkey (v1).
-    CreateCreditAndSpend(keystore, GetScriptForDestination(CScriptID(GetScriptForWitness(scriptPubkey1L))), output1, input1, false);
-    CreateCreditAndSpend(keystore, GetScriptForDestination(CScriptID(GetScriptForWitness(scriptPubkey2L))), output2, input2, false);
+    CreateCreditAndSpend(keystore, GetScriptForDestination(ScriptHash(GetScriptForWitness(scriptPubkey1L))), output1, input1, false);
+    CreateCreditAndSpend(keystore, GetScriptForDestination(ScriptHash(GetScriptForWitness(scriptPubkey2L))), output2, input2, false);
 
     // Normal 2-of-2 multisig
     CreateCreditAndSpend(keystore, scriptMulti, output1, input1, false);
@@ -655,10 +653,10 @@ BOOST_AUTO_TEST_CASE(test_witness)
     CheckWithFlag(output1, input1, STANDARD_SCRIPT_VERIFY_FLAGS, true);
 
     // P2SH 2-of-2 multisig
-    CreateCreditAndSpend(keystore, GetScriptForDestination(CScriptID(scriptMulti)), output1, input1, false);
+    CreateCreditAndSpend(keystore, GetScriptForDestination(ScriptHash(scriptMulti)), output1, input1, false);
     CheckWithFlag(output1, input1, 0, true);
     CheckWithFlag(output1, input1, SCRIPT_VERIFY_P2SH, false);
-    CreateCreditAndSpend(keystore2, GetScriptForDestination(CScriptID(scriptMulti)), output2, input2, false);
+    CreateCreditAndSpend(keystore2, GetScriptForDestination(ScriptHash(scriptMulti)), output2, input2, false);
     CheckWithFlag(output2, input2, 0, true);
     CheckWithFlag(output2, input2, SCRIPT_VERIFY_P2SH, false);
     BOOST_CHECK(*output1 == *output2);
@@ -679,10 +677,10 @@ BOOST_AUTO_TEST_CASE(test_witness)
     CheckWithFlag(output1, input1, STANDARD_SCRIPT_VERIFY_FLAGS, true);
 
     // P2SH witness 2-of-2 multisig
-    CreateCreditAndSpend(keystore, GetScriptForDestination(CScriptID(GetScriptForWitness(scriptMulti))), output1, input1, false);
+    CreateCreditAndSpend(keystore, GetScriptForDestination(ScriptHash(GetScriptForWitness(scriptMulti))), output1, input1, false);
     CheckWithFlag(output1, input1, SCRIPT_VERIFY_P2SH, true);
     CheckWithFlag(output1, input1, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS, false);
-    CreateCreditAndSpend(keystore2, GetScriptForDestination(CScriptID(GetScriptForWitness(scriptMulti))), output2, input2, false);
+    CreateCreditAndSpend(keystore2, GetScriptForDestination(ScriptHash(GetScriptForWitness(scriptMulti))), output2, input2, false);
     CheckWithFlag(output2, input2, SCRIPT_VERIFY_P2SH, true);
     CheckWithFlag(output2, input2, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS, false);
     BOOST_CHECK(*output1 == *output2);
@@ -708,7 +706,7 @@ BOOST_AUTO_TEST_CASE(test_IsStandard)
     t.vout[0].nValue = 90*CENT;
     CKey key;
     key.MakeNewKey(true);
-    t.vout[0].scriptPubKey = GetScriptForDestination(key.GetPubKey().GetID());
+    t.vout[0].scriptPubKey = GetScriptForDestination(PKHash(key.GetPubKey()));
 
     std::string reason;
     BOOST_CHECK(IsStandardTx(t, reason));
diff --git a/src/test/txindex_tests.cpp b/src/test/txindex_tests.cpp
index 2a160b9988c75..0ad831599f00e 100644
--- a/src/test/txindex_tests.cpp
+++ b/src/test/txindex_tests.cpp
@@ -49,7 +49,7 @@ BOOST_FIXTURE_TEST_CASE(txindex_initial_sync, TestChain100Setup)
 
     // Check that new transactions in new blocks make it into the index.
     for (int i = 0; i < 10; i++) {
-        CScript coinbase_script_pub_key = GetScriptForDestination(coinbaseKey.GetPubKey().GetID());
+        CScript coinbase_script_pub_key = GetScriptForDestination(PKHash(coinbaseKey.GetPubKey()));
         std::vector<CMutableTransaction> no_txns;
         const CBlock& block = CreateAndProcessBlock(no_txns, coinbase_script_pub_key);
         const CTransaction& txn = *block.vtx[0];
diff --git a/src/test/txvalidationcache_tests.cpp b/src/test/txvalidationcache_tests.cpp
index b043e9f03c2e5..db95902ec6ce2 100644
--- a/src/test/txvalidationcache_tests.cpp
+++ b/src/test/txvalidationcache_tests.cpp
@@ -2,6 +2,7 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include <chainparams.h>
 #include <consensus/validation.h>
 #include <key.h>
 #include <validation.h>
@@ -19,7 +20,7 @@
 
 #include <boost/test/unit_test.hpp>
 
-bool CheckInputs(const CTransaction& tx, CValidationState &state, const CCoinsViewCache &inputs, bool fScriptChecks, unsigned int flags, bool cacheSigStore, bool cacheFullScriptStore, PrecomputedTransactionData& txdata, std::vector<CScriptCheck> *pvChecks);
+bool CheckInputs(const CTransaction& tx, CValidationState &state, const CCoinsViewCache &inputs, bool fScriptChecks, unsigned int flags, bool cacheSigStore, bool cacheFullScriptStore, PrecomputedTransactionData& txdata, std::vector<CCheck*> *pvChecks);
 
 BOOST_AUTO_TEST_SUITE(tx_validationcache_tests)
 
@@ -128,13 +129,13 @@ static void ValidateCheckInputsForAllFlags(const CTransaction &tx, uint32_t fail
         // Test the caching
         if (ret && add_to_cache) {
             // Check that we get a cache hit if the tx was valid
-            std::vector<CScriptCheck> scriptchecks;
+            std::vector<CCheck*> scriptchecks;
             BOOST_CHECK(CheckInputs(tx, state, pcoinsTip.get(), true, test_flags, true, add_to_cache, txdata, &scriptchecks));
             BOOST_CHECK(scriptchecks.empty());
         } else {
             // Check that we get script executions to check, if the transaction
             // was invalid, or we didn't add to cache.
-            std::vector<CScriptCheck> scriptchecks;
+            std::vector<CCheck*> scriptchecks;
             BOOST_CHECK(CheckInputs(tx, state, pcoinsTip.get(), true, test_flags, true, add_to_cache, txdata, &scriptchecks));
             BOOST_CHECK_EQUAL(scriptchecks.size(), tx.vin.size());
         }
@@ -151,8 +152,8 @@ BOOST_FIXTURE_TEST_CASE(checkinputs_test, TestChain100Setup)
     }
 
     CScript p2pk_scriptPubKey = CScript() << ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;
-    CScript p2sh_scriptPubKey = GetScriptForDestination(CScriptID(p2pk_scriptPubKey));
-    CScript p2pkh_scriptPubKey = GetScriptForDestination(coinbaseKey.GetPubKey().GetID());
+    CScript p2sh_scriptPubKey = GetScriptForDestination(ScriptHash(p2pk_scriptPubKey));
+    CScript p2pkh_scriptPubKey = GetScriptForDestination(PKHash(coinbaseKey.GetPubKey()));
     CScript p2wpkh_scriptPubKey = GetScriptForWitness(p2pkh_scriptPubKey);
 
     CBasicKeyStore keystore;
@@ -203,7 +204,7 @@ BOOST_FIXTURE_TEST_CASE(checkinputs_test, TestChain100Setup)
         // If we call again asking for scriptchecks (as happens in
         // ConnectBlock), we should add a script check object for this -- we're
         // not caching invalidity (if that changes, delete this test case).
-        std::vector<CScriptCheck> scriptchecks;
+        std::vector<CCheck*> scriptchecks;
         BOOST_CHECK(CheckInputs(spend_tx, state, pcoinsTip.get(), true, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_DERSIG, true, true, ptd_spend_tx, &scriptchecks));
         BOOST_CHECK_EQUAL(scriptchecks.size(), 1U);
 
@@ -361,7 +362,7 @@ BOOST_FIXTURE_TEST_CASE(checkinputs_test, TestChain100Setup)
         // This transaction is now invalid under segwit, because of the second input.
         BOOST_CHECK(!CheckInputs(tx, state, pcoinsTip.get(), true, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS, true, true, txdata, nullptr));
 
-        std::vector<CScriptCheck> scriptchecks;
+        std::vector<CCheck*> scriptchecks;
         // Make sure this transaction was not cached (ie because the first
         // input was valid)
         BOOST_CHECK(CheckInputs(tx, state, pcoinsTip.get(), true, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_WITNESS, true, true, txdata, &scriptchecks));
diff --git a/src/txmempool.cpp b/src/txmempool.cpp
index 3df8ad7257100..2c04c803c91cd 100644
--- a/src/txmempool.cpp
+++ b/src/txmempool.cpp
@@ -404,6 +404,7 @@ void CTxMemPool::addUnchecked(const CTxMemPoolEntry &entry, setEntries &setAnces
     vTxHashes.emplace_back(tx.GetWitnessHash(), newit);
     newit->vTxHashesIdx = vTxHashes.size() - 1;
 
+    // ELEMENTS:
     typedef std::pair<uint256, COutPoint> PeginPair;
     for(const PeginPair& it : entry.setPeginsSpent) {
         std::pair<std::map<std::pair<uint256, COutPoint>, uint256>::iterator, bool> ret = mapPeginsSpentToTxid.insert(std::make_pair(it, tx.GetHash()));
@@ -651,9 +652,9 @@ static void CheckInputsAndUpdateCoins(const CTxMemPoolEntry& entry, CCoinsViewCa
 {
     CTransaction tx = entry.GetTx();
     CValidationState state;
-    CAmount txfee = 0;
+    CAmountMap fee_map;
     std::set<std::pair<uint256, COutPoint> > setPeginsSpent;
-    bool fCheckResult = tx.IsCoinBase() || Consensus::CheckTxInputs(tx, state, mempoolDuplicate, spendheight, txfee, setPeginsSpent);
+    bool fCheckResult = tx.IsCoinBase() || Consensus::CheckTxInputs(tx, state, mempoolDuplicate, spendheight, fee_map, setPeginsSpent, NULL, false, true);
     assert(fCheckResult);
     UpdateCoins(tx, mempoolDuplicate, 1000000);
 
diff --git a/src/validation.cpp b/src/validation.cpp
index c256ada6f1212..415235bdf2417 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -314,7 +314,7 @@ static void FindFilesToPrune(std::set<int>& setFilesToPrune, uint64_t nPruneAfte
 bool CheckInputs(const CTransaction& tx, CValidationState &state, const CCoinsViewCache &inputs,
         bool fScriptChecks, unsigned int flags, bool cacheSigStore, bool cacheFullScriptStore,
         PrecomputedTransactionData& txdata,
-        std::vector<CScriptCheck> *pvChecks = nullptr);
+        std::vector<CCheck*> *pvChecks = nullptr);
 static FILE* OpenUndoFile(const CDiskBlockPos &pos, bool fReadOnly = false);
 
 bool CheckFinalTx(const CTransaction &tx, int flags)
@@ -709,8 +709,8 @@ static bool AcceptToMemoryPoolWorker(const CChainParams& chainparams, CTxMemPool
         if (!CheckSequenceLocks(tx, STANDARD_LOCKTIME_VERIFY_FLAGS, &lp))
             return state.DoS(0, false, REJECT_NONSTANDARD, "non-BIP68-final");
 
-        CAmount nFees = 0;
-        if (!Consensus::CheckTxInputs(tx, state, view, GetSpendHeight(view), nFees, setPeginsSpent)) {
+        CAmountMap fee_map;
+        if (!Consensus::CheckTxInputs(tx, state, view, GetSpendHeight(view), fee_map, setPeginsSpent, NULL, true, true)) {
             return error("%s: Consensus::CheckTxInputs: %s, %s", __func__, tx.GetHash().ToString(), FormatStateMessage(state));
         }
 
@@ -724,6 +724,9 @@ static bool AcceptToMemoryPoolWorker(const CChainParams& chainparams, CTxMemPool
 
         int64_t nSigOpsCost = GetTransactionSigOpCost(tx, view, STANDARD_SCRIPT_VERIFY_FLAGS);
 
+        // We only consider policyAsset
+        CAmount nFees = fee_map[policyAsset];
+
         // nModifiedFees includes any fee deltas from PrioritiseTransaction
         CAmount nModifiedFees = nFees;
         pool.ApplyDelta(hash, nModifiedFees);
@@ -1412,7 +1415,7 @@ void InitScriptExecutionCache() {
  *
  * Non-static (and re-declared) in src/test/txvalidationcache_tests.cpp
  */
-bool CheckInputs(const CTransaction& tx, CValidationState &state, const CCoinsViewCache &inputs, bool fScriptChecks, unsigned int flags, bool cacheSigStore, bool cacheFullScriptStore, PrecomputedTransactionData& txdata, std::vector<CScriptCheck> *pvChecks) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
+bool CheckInputs(const CTransaction& tx, CValidationState &state, const CCoinsViewCache &inputs, bool fScriptChecks, unsigned int flags, bool cacheSigStore, bool cacheFullScriptStore, PrecomputedTransactionData& txdata, std::vector<CCheck*> *pvChecks) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
 {
     if (!tx.IsCoinBase())
     {
@@ -1465,11 +1468,9 @@ bool CheckInputs(const CTransaction& tx, CValidationState &state, const CCoinsVi
                 // spent being checked as a part of CScriptCheck.
 
                 // Verify signature
-                CScriptCheck check(coin.out, tx, i, flags, cacheSigStore, &txdata);
-                if (pvChecks) {
-                    pvChecks->push_back(CScriptCheck());
-                    check.swap(pvChecks->back());
-                } else if (!check()) {
+                CCheck* check = new CScriptCheck(coin.out, tx, i, flags, cacheSigStore, &txdata);
+                ScriptError serror = QueueCheck(pvChecks, check);
+                if (serror != SCRIPT_ERR_OK) {
                     if (flags & STANDARD_NOT_MANDATORY_VERIFY_FLAGS) {
                         // Check whether the failure was caused by a
                         // non-mandatory script verification check, such as
@@ -1480,7 +1481,7 @@ bool CheckInputs(const CTransaction& tx, CValidationState &state, const CCoinsVi
                         CScriptCheck check2(coin.out, tx, i,
                                 flags & ~STANDARD_NOT_MANDATORY_VERIFY_FLAGS, cacheSigStore, &txdata);
                         if (check2()) {
-                            return state.Invalid(false, REJECT_NONSTANDARD, strprintf("non-mandatory-script-verify-flag (%s)", ScriptErrorString(check.GetScriptError())));
+                            return state.Invalid(false, REJECT_NONSTANDARD, strprintf("non-mandatory-script-verify-flag (%s)", ScriptErrorString(serror)));
                         }
                     }
                     // Failures of other flags indicate a transaction that is
@@ -1490,7 +1491,7 @@ bool CheckInputs(const CTransaction& tx, CValidationState &state, const CCoinsVi
                     // as to the correct behavior - we may want to continue
                     // peering with non-upgraded nodes even after soft-fork
                     // super-majority signaling has occurred.
-                    return state.DoS(100,false, REJECT_INVALID, strprintf("mandatory-script-verify-flag-failed (%s)", ScriptErrorString(check.GetScriptError())));
+                    return state.DoS(100,false, REJECT_INVALID, strprintf("mandatory-script-verify-flag-failed (%s)", ScriptErrorString(serror)));
                 }
             }
 
@@ -1608,7 +1609,13 @@ int ApplyTxInUndo(Coin&& undo, CCoinsViewCache& view, const COutPoint& out, cons
                 undo.nHeight = alternate.nHeight;
                 undo.fCoinBase = alternate.fCoinBase;
             } else {
-                return DISCONNECT_FAILED; // adding output for transaction without known metadata
+                // ELEMENTS:
+                // If we're connecting genesis outputs, it's probably actually just
+                // a genesis output, let it through. N.B. The case where it's a corrupted
+                // txundo from per-tx db will not be caught!
+                if (!Params().GetConsensus().connect_genesis_outputs) {
+                    return DISCONNECT_FAILED; // adding output for transaction without known metadata
+                }
             }
         }
         // The potential_overwrite parameter to AddCoin is only allowed to be false if we know for
@@ -1634,6 +1641,15 @@ int ApplyTxInUndo(Coin&& undo, CCoinsViewCache& view, const COutPoint& out, cons
     return fClean ? DISCONNECT_OK : DISCONNECT_UNCLEAN;
 }
 
+// We don't want to compare things that are not stored in utxo db, specifically
+// the nonce commitment which has no consensus meaning for spending conditions
+static bool TxOutDBEntryIsSame(const CTxOut& block_txout, const CTxOut& txdb_txout)
+{
+    return txdb_txout.nValue == block_txout.nValue &&
+        txdb_txout.nAsset == block_txout.nAsset &&
+        txdb_txout.scriptPubKey == block_txout.scriptPubKey;
+}
+
 /** Undo the effects of this block (with given index) on the UTXO set represented by coins.
  *  When FAILED is returned, view is left in an indeterminate state. */
 DisconnectResult CChainState::DisconnectBlock(const CBlock& block, const CBlockIndex* pindex, CCoinsViewCache& view)
@@ -1664,7 +1680,7 @@ DisconnectResult CChainState::DisconnectBlock(const CBlock& block, const CBlockI
                 COutPoint out(hash, o);
                 Coin coin;
                 bool is_spent = view.SpendCoin(out, &coin);
-                if (!is_spent || tx.vout[o] != coin.out || pindex->nHeight != coin.nHeight || is_coinbase != coin.fCoinBase) {
+                if (!is_spent || !TxOutDBEntryIsSame(tx.vout[o], coin.out) || pindex->nHeight != coin.nHeight || is_coinbase != coin.fCoinBase) {
                     fClean = false; // transaction output mismatch
                 }
             }
@@ -1743,7 +1759,7 @@ static bool WriteUndoDataForBlock(const CBlockUndo& blockundo, CValidationState&
     return true;
 }
 
-static CCheckQueue<CScriptCheck> scriptcheckqueue(128);
+static CCheckQueue<CCheck> scriptcheckqueue(128);
 
 void ThreadScriptCheck() {
     RenameThread("bitcoin-scriptch");
@@ -1920,7 +1936,8 @@ bool CChainState::ConnectBlock(const CBlock& block, CValidationState& state, CBl
     const CScript& mandatory_coinbase_destination = chainparams.GetConsensus().mandatory_coinbase_destination;
     if (mandatory_coinbase_destination != CScript()) {
         for (auto& txout : block.vtx[0]->vout) {
-            if (txout.scriptPubKey != mandatory_coinbase_destination && txout.nValue != 0) {
+            bool mustPay = !txout.nValue.IsExplicit() || txout.nValue.GetAmount() != 0;
+            if (mustPay && txout.scriptPubKey != mandatory_coinbase_destination) {
                 return state.DoS(100, error("ConnectBlock(): Coinbase outputs didn't match required scriptPubKey"),
                                  REJECT_INVALID, "bad-coinbase-txos");
             }
@@ -2061,10 +2078,10 @@ bool CChainState::ConnectBlock(const CBlock& block, CValidationState& state, CBl
 
     CBlockUndo blockundo;
 
-    CCheckQueueControl<CScriptCheck> control(fScriptChecks && nScriptCheckThreads ? &scriptcheckqueue : nullptr);
+    CCheckQueueControl<CCheck> control(fScriptChecks && nScriptCheckThreads ? &scriptcheckqueue : nullptr);
 
     std::vector<int> prevheights;
-    CAmount nFees = 0;
+    CAmountMap fee_map;
     int nInputs = 0;
     int64_t nSigOpsCost = 0;
     blockundo.vtxundo.reserve(block.vtx.size() - 1);
@@ -2083,16 +2100,17 @@ bool CChainState::ConnectBlock(const CBlock& block, CValidationState& state, CBl
 
         if (!tx.IsCoinBase())
         {
-            CAmount txfee = 0;
-            if (!Consensus::CheckTxInputs(tx, state, view, pindex->nHeight, txfee,
-                        setPeginsSpent == NULL ? setPeginsSpentDummy : *setPeginsSpent)) {
+            std::vector<CCheck*> vChecks;
+            bool fCacheResults = fJustCheck; /* Don't cache results if we're actually connecting blocks (still consult the cache, though) */
+            if (!Consensus::CheckTxInputs(tx, state, view, pindex->nHeight, fee_map,
+                        setPeginsSpent == NULL ? setPeginsSpentDummy : *setPeginsSpent,
+                        nScriptCheckThreads ? &vChecks : NULL, fCacheResults, fScriptChecks)) {
                 return error("%s: Consensus::CheckTxInputs: %s, %s", __func__, tx.GetHash().ToString(), FormatStateMessage(state));
             }
-            nFees += txfee;
-            if (!MoneyRange(nFees)) {
-                return state.DoS(100, error("%s: accumulated fee in the block out of range.", __func__),
-                                 REJECT_INVALID, "bad-txns-accumulated-fee-outofrange");
-            }
+            control.Add(vChecks);
+
+            if (!MoneyRange(fee_map))
+                return state.DoS(100, error("ConnectBlock(): total block reward overflowed"), REJECT_INVALID, "bad-blockreward-outofrange");
 
             // Check that transaction is BIP68 final
             // BIP68 lock checks (as opposed to nLockTime checks) must
@@ -2124,7 +2142,7 @@ bool CChainState::ConnectBlock(const CBlock& block, CValidationState& state, CBl
         txdata.emplace_back(tx);
         if (!tx.IsCoinBase())
         {
-            std::vector<CScriptCheck> vChecks;
+            std::vector<CCheck*> vChecks;
             bool fCacheResults = fJustCheck; /* Don't cache results if we're actually connecting blocks (still consult the cache, though) */
             if (!CheckInputs(tx, state, view, fScriptChecks, flags, fCacheResults, fCacheResults, txdata[i], nScriptCheckThreads ? &vChecks : nullptr))
                 return error("ConnectBlock(): CheckInputs on %s failed with %s",
@@ -2137,16 +2155,19 @@ bool CChainState::ConnectBlock(const CBlock& block, CValidationState& state, CBl
             blockundo.vtxundo.push_back(CTxUndo());
         }
         UpdateCoins(tx, view, i == 0 ? undoDummy : blockundo.vtxundo.back(), pindex->nHeight);
+
     }
     int64_t nTime3 = GetTimeMicros(); nTimeConnect += nTime3 - nTime2;
     LogPrint(BCLog::BENCH, "      - Connect %u transactions: %.2fms (%.3fms/tx, %.3fms/txin) [%.2fs (%.2fms/blk)]\n", (unsigned)block.vtx.size(), MILLI * (nTime3 - nTime2), MILLI * (nTime3 - nTime2) / block.vtx.size(), nInputs <= 1 ? 0 : MILLI * (nTime3 - nTime2) / (nInputs-1), nTimeConnect * MICRO, nTimeConnect * MILLI / nBlocksTotal);
 
-    CAmount blockReward = nFees + GetBlockSubsidy(pindex->nHeight, chainparams.GetConsensus());
-    if (block.vtx[0]->GetValueOut() > blockReward)
-        return state.DoS(100,
-                         error("ConnectBlock(): coinbase pays too much (actual=%d vs limit=%d)",
-                               block.vtx[0]->GetValueOut(), blockReward),
-                               REJECT_INVALID, "bad-cb-amount");
+    CAmountMap block_reward = fee_map;
+    block_reward[consensusParams.subsidy_asset] += GetBlockSubsidy(pindex->nHeight, consensusParams);
+    if (!MoneyRange(block_reward))
+        return state.DoS(100, error("ConnectBlock(): total block reward overflowed"), REJECT_INVALID, "bad-blockreward-outofrange");
+    if (!VerifyCoinbaseAmount(*(block.vtx[0]), block_reward)) {
+        return state.DoS(100, error("ConnectBlock(): coinbase pays too much (limit=%d)",
+                block_reward[consensusParams.subsidy_asset]), REJECT_INVALID, "bad-cb-amount");
+    }
 
     if (!control.Wait())
         return state.DoS(100, error("%s: CheckQueue failed", __func__), REJECT_INVALID, "block-validation-failed");
@@ -3332,10 +3353,21 @@ std::vector<unsigned char> GenerateCoinbaseCommitment(CBlock& block, const CBloc
     std::vector<unsigned char> ret(32, 0x00);
     if (consensusParams.vDeployments[Consensus::DEPLOYMENT_SEGWIT].nTimeout != 0) {
         if (commitpos == -1) {
+            // ELEMENTS: Shim in blank coinbase output for witness output hash
+            // Previous iterations of CA could have allowed witness data
+            // in coinbase transactions, and this witness data must be committed
+            // to here.
+            //
+            // Is No-op in Bitcoin
+            CMutableTransaction tx0(*block.vtx[0]);
+            tx0.vout.push_back(CTxOut());
+            block.vtx[0] = MakeTransactionRef(std::move(tx0));
+            // END
             uint256 witnessroot = BlockWitnessMerkleRoot(block, nullptr);
             CHash256().Write(witnessroot.begin(), 32).Write(ret.data(), 32).Finalize(witnessroot.begin());
             CTxOut out;
             out.nValue = 0;
+            out.nAsset = policyAsset;
             out.scriptPubKey.resize(38);
             out.scriptPubKey[0] = OP_RETURN;
             out.scriptPubKey[1] = 0x24;
@@ -3346,7 +3378,9 @@ std::vector<unsigned char> GenerateCoinbaseCommitment(CBlock& block, const CBloc
             memcpy(&out.scriptPubKey[6], witnessroot.begin(), 32);
             commitment = std::vector<unsigned char>(out.scriptPubKey.begin(), out.scriptPubKey.end());
             CMutableTransaction tx(*block.vtx[0]);
-            tx.vout.push_back(out);
+            // Elements: replace shimmed output with real coinbase rather than push
+            tx.vout.back() = out;
+            // END
             block.vtx[0] = MakeTransactionRef(std::move(tx));
         }
     }
@@ -3536,8 +3570,9 @@ static bool ContextualCheckBlock(const CBlock& block, CValidationState& state, c
                 return state.DoS(100, false, REJECT_INVALID, "bad-witness-nonce-size", true, strprintf("%s : invalid witness reserved value size", __func__));
             }
             CHash256().Write(hashWitness.begin(), 32).Write(&block.vtx[0]->witness.vtxinwit[0].scriptWitness.stack[0][0], 32).Finalize(hashWitness.begin());
+            uint256 committedWitness(std::vector<unsigned char>(&block.vtx[0]->vout[commitpos].scriptPubKey[6], &block.vtx[0]->vout[commitpos].scriptPubKey[6+32]));
             if (memcmp(hashWitness.begin(), &block.vtx[0]->vout[commitpos].scriptPubKey[6], 32)) {
-                return state.DoS(100, false, REJECT_INVALID, "bad-witness-merkle-match", true, strprintf("%s : witness merkle commitment mismatch", __func__));
+                return state.DoS(100, false, REJECT_INVALID, "bad-witness-merkle-match", true, strprintf("%s : witness merkle commitment mismatch: calculated: %s found commitment: %s", __func__, hashWitness.GetHex(), committedWitness.GetHex()));
             }
             fHaveWitness = true;
         }
diff --git a/src/validation.h b/src/validation.h
index cba97aaa7d03a..6e3b9e3ec4c45 100644
--- a/src/validation.h
+++ b/src/validation.h
@@ -12,6 +12,7 @@
 
 #include <amount.h>
 #include <coins.h>
+#include <confidential_validation.h>
 #include <fs.h>
 #include <protocol.h> // For CMessageHeader::MessageStartChars
 #include <policy/feerate.h>
@@ -365,7 +366,7 @@ bool CheckSequenceLocks(const CTransaction &tx, int flags, LockPoints* lp = null
  * Closure representing one script verification
  * Note that this stores references to the spending transaction
  */
-class CScriptCheck
+class CScriptCheck : public CCheck
 {
 private:
     CTxOut m_tx_out;
@@ -373,27 +374,14 @@ class CScriptCheck
     unsigned int nIn;
     unsigned int nFlags;
     bool cacheStore;
-    ScriptError error;
     PrecomputedTransactionData *txdata;
 
 public:
-    CScriptCheck(): ptxTo(nullptr), nIn(0), nFlags(0), cacheStore(false), error(SCRIPT_ERR_UNKNOWN_ERROR) {}
+    CScriptCheck(): ptxTo(nullptr), nIn(0), nFlags(0), cacheStore(false) {}
     CScriptCheck(const CTxOut& outIn, const CTransaction& txToIn, unsigned int nInIn, unsigned int nFlagsIn, bool cacheIn, PrecomputedTransactionData* txdataIn) :
-        m_tx_out(outIn), ptxTo(&txToIn), nIn(nInIn), nFlags(nFlagsIn), cacheStore(cacheIn), error(SCRIPT_ERR_UNKNOWN_ERROR), txdata(txdataIn) { }
+        m_tx_out(outIn), ptxTo(&txToIn), nIn(nInIn), nFlags(nFlagsIn), cacheStore(cacheIn), txdata(txdataIn) { }
 
     bool operator()();
-
-    void swap(CScriptCheck &check) {
-        std::swap(ptxTo, check.ptxTo);
-        std::swap(m_tx_out, check.m_tx_out);
-        std::swap(nIn, check.nIn);
-        std::swap(nFlags, check.nFlags);
-        std::swap(cacheStore, check.cacheStore);
-        std::swap(error, check.error);
-        std::swap(txdata, check.txdata);
-    }
-
-    ScriptError GetScriptError() const { return error; }
 };
 
 /** Initializes the script-execution cache */
diff --git a/src/wallet/coincontrol.cpp b/src/wallet/coincontrol.cpp
index 645981faa4639..e12678cca1326 100644
--- a/src/wallet/coincontrol.cpp
+++ b/src/wallet/coincontrol.cpp
@@ -8,7 +8,7 @@
 
 void CCoinControl::SetNull()
 {
-    destChange = CNoDestination();
+    destChange.clear();
     m_change_type.reset();
     fAllowOtherInputs = false;
     fAllowWatchOnly = false;
diff --git a/src/wallet/coincontrol.h b/src/wallet/coincontrol.h
index 48a924abfb2c5..b9aeb7b08f6a2 100644
--- a/src/wallet/coincontrol.h
+++ b/src/wallet/coincontrol.h
@@ -5,6 +5,7 @@
 #ifndef BITCOIN_WALLET_COINCONTROL_H
 #define BITCOIN_WALLET_COINCONTROL_H
 
+#include <asset.h>
 #include <policy/feerate.h>
 #include <policy/fees.h>
 #include <primitives/transaction.h>
@@ -17,7 +18,7 @@ class CCoinControl
 {
 public:
     //! Custom change destination, if not set an address is generated
-    CTxDestination destChange;
+    std::map<CAsset, CTxDestination> destChange;
     //! Override the default change type if set, ignored if destChange is set
     boost::optional<OutputType> m_change_type;
     //! If false, allows unselected inputs, but requires all selected inputs be used
diff --git a/src/wallet/coinselection.cpp b/src/wallet/coinselection.cpp
index fdeb89553b6f0..cb3f7e7d32241 100644
--- a/src/wallet/coinselection.cpp
+++ b/src/wallet/coinselection.cpp
@@ -3,12 +3,28 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <wallet/coinselection.h>
+#include <wallet/wallet.h>
 
 #include <util.h>
 #include <utilmoneystr.h>
 
 #include <boost/optional.hpp>
 
+CInputCoin::CInputCoin(const CWalletTx* wtx, unsigned int i) {
+    if (!wtx || !wtx->tx)
+        throw std::invalid_argument("tx should not be null");
+    if (i >= wtx->tx->vout.size())
+        throw std::out_of_range("The output index is out of range");
+
+    outpoint = COutPoint(wtx->tx->GetHash(), i);
+    txout = wtx->tx->vout[i];
+    effective_value = std::max<CAmount>(0, wtx->GetOutputValueOut(i));
+    value = wtx->GetOutputValueOut(i);
+    asset = wtx->GetOutputAsset(i);
+    bf_value = wtx->GetOutputAmountBlindingFactor(i);
+    bf_asset = wtx->GetOutputAssetBlindingFactor(i);
+}
+
 // Descending order comparator
 struct {
     bool operator()(const OutputGroup& a, const OutputGroup& b) const
@@ -213,6 +229,62 @@ static void ApproximateBestSubset(const std::vector<OutputGroup>& groups, const
     }
 }
 
+// ELEMENTS:
+bool KnapsackSolver(const CAmountMap& mapTargetValue, std::vector<OutputGroup>& groups, std::set<CInputCoin>& setCoinsRet, CAmountMap& mapValueRet) {
+    setCoinsRet.clear();
+    mapValueRet.clear();
+
+    std::vector<OutputGroup> inner_groups;
+    std::set<CInputCoin> inner_coinsret;
+    // Perform the standard Knapsack solver for every asset individually.
+    for(std::map<CAsset, CAmount>::const_iterator it = mapTargetValue.begin(); it != mapTargetValue.end(); ++it) {
+        inner_groups.clear();
+        inner_coinsret.clear();
+
+        if (it->second == 0) {
+            continue;
+        }
+
+        // We filter the groups on two conditions:
+        // - only groups that have (exclusively) coins of the asset we're solving for
+        // - no groups that are already used in setCoinsRet
+        for (const OutputGroup& g : groups) {
+            bool add = true;
+            for (const CInputCoin& c : g.m_outputs) {
+                if (setCoinsRet.find(c) != setCoinsRet.end()) {
+                    add = false;
+                    break;
+                }
+
+                if (c.asset != it->first) {
+                    add = false;
+                    break;
+                }
+            }
+
+            if (add) {
+                inner_groups.push_back(g);
+            }
+        }
+
+        if (inner_groups.size() == 0) {
+            // No output groups for this asset.
+            return false;
+        }
+
+        CAmount outValue;
+        if (!KnapsackSolver(it->second, inner_groups, inner_coinsret, outValue)) {
+            return false;
+        }
+        mapValueRet[it->first] = outValue;
+        for (const CInputCoin& ic : inner_coinsret) {
+            setCoinsRet.insert(ic);
+        }
+    }
+
+    return true;
+}
+
 bool KnapsackSolver(const CAmount& nTargetValue, std::vector<OutputGroup>& groups, std::set<CInputCoin>& setCoinsRet, CAmount& nValueRet)
 {
     setCoinsRet.clear();
diff --git a/src/wallet/coinselection.h b/src/wallet/coinselection.h
index 6d755d0969583..2d4cf3a9ca2b5 100644
--- a/src/wallet/coinselection.h
+++ b/src/wallet/coinselection.h
@@ -14,21 +14,14 @@ static const CAmount MIN_CHANGE = CENT;
 //! final minimum change amount after paying for fees
 static const CAmount MIN_FINAL_CHANGE = MIN_CHANGE/2;
 
+class CWalletTx;
+class uint256;
+
 class CInputCoin {
 public:
-    CInputCoin(const CTransactionRef& tx, unsigned int i)
-    {
-        if (!tx)
-            throw std::invalid_argument("tx should not be null");
-        if (i >= tx->vout.size())
-            throw std::out_of_range("The output index is out of range");
-
-        outpoint = COutPoint(tx->GetHash(), i);
-        txout = tx->vout[i];
-        effective_value = txout.nValue;
-    }
+    CInputCoin(const CWalletTx* wtx, unsigned int i);
 
-    CInputCoin(const CTransactionRef& tx, unsigned int i, int input_bytes) : CInputCoin(tx, i)
+    CInputCoin(const CWalletTx* wtx, unsigned int i, int input_bytes) : CInputCoin(wtx, i)
     {
         m_input_bytes = input_bytes;
     }
@@ -36,6 +29,11 @@ class CInputCoin {
     COutPoint outpoint;
     CTxOut txout;
     CAmount effective_value;
+    // ELEMENTS:
+    CAmount value;
+    CAsset asset;
+    uint256 bf_value;
+    uint256 bf_asset;
 
     /** Pre-computed estimated size of this output as a fully-signed input in a transaction. Can be -1 if it could not be calculated */
     int m_input_bytes{-1};
@@ -98,4 +96,8 @@ bool SelectCoinsBnB(std::vector<OutputGroup>& utxo_pool, const CAmount& target_v
 // Original coin selection algorithm as a fallback
 bool KnapsackSolver(const CAmount& nTargetValue, std::vector<OutputGroup>& groups, std::set<CInputCoin>& setCoinsRet, CAmount& nValueRet);
 
+// ELEMENTS:
+// Knapsack that delegates for every asset individually.
+bool KnapsackSolver(const CAmountMap& mapTargetValue, std::vector<OutputGroup>& groups, std::set<CInputCoin>& setCoinsRet, CAmountMap& mapValueRet);
+
 #endif // BITCOIN_WALLET_COINSELECTION_H
diff --git a/src/wallet/feebumper.cpp b/src/wallet/feebumper.cpp
index d0237869483f2..9e1bf312c96c3 100644
--- a/src/wallet/feebumper.cpp
+++ b/src/wallet/feebumper.cpp
@@ -94,6 +94,10 @@ Result CreateTransaction(const CWallet* wallet, const uint256& txid, const CCoin
     // if there was no change output or multiple change outputs, fail
     int nOutput = -1;
     for (size_t i = 0; i < wtx.tx->vout.size(); ++i) {
+        if (wtx.GetOutputAsset(i) != ::policyAsset) {
+            continue;
+        }
+
         if (wallet->IsChange(wtx.tx->vout[i])) {
             if (nOutput != -1) {
                 errors.push_back("Transaction has multiple change outputs");
@@ -107,8 +111,22 @@ Result CreateTransaction(const CWallet* wallet, const uint256& txid, const CCoin
         return Result::WALLET_ERROR;
     }
 
+    // Find the fee output.
+    int nFeeOutput = -1;
+    for (int i = (int)wtx.tx->vout.size()-1; i >= 0; --i) {
+        if (wtx.GetOutputAsset(i) == ::policyAsset && wtx.tx->vout[i].IsFee()) {
+            nFeeOutput = i;
+            break;
+        }
+    }
+
     // Calculate the expected size of the new transaction.
     int64_t txSize = GetVirtualTransactionSize(*(wtx.tx));
+    if (g_con_elementsmode && nFeeOutput == -1) {
+        CMutableTransaction with_fee_output = CMutableTransaction{*wtx.tx};
+        with_fee_output.vout.push_back(CTxOut(::policyAsset, 0, CScript()));
+        txSize = GetVirtualTransactionSize(with_fee_output);
+    }
     const int64_t maxNewTxSize = CalculateMaximumSignedTxSize(*wtx.tx, wallet);
     if (maxNewTxSize < 0) {
         errors.push_back("Transaction contains inputs that cannot be signed");
@@ -116,7 +134,10 @@ Result CreateTransaction(const CWallet* wallet, const uint256& txid, const CCoin
     }
 
     // calculate the old fee and fee-rate
-    old_fee = wtx.GetDebit(ISMINE_SPENDABLE) - wtx.tx->GetValueOut();
+    old_fee = wtx.GetDebit(ISMINE_SPENDABLE)[::policyAsset] - wtx.tx->GetValueOutMap()[::policyAsset];
+    if (g_con_elementsmode) {
+        old_fee = GetFeeMap(*wtx.tx)[::policyAsset];
+    }
     CFeeRate nOldFeeRate(old_fee, txSize);
     CFeeRate nNewFeeRate;
     // The wallet uses a conservative WALLET_INCREMENTAL_RELAY_FEE value to
@@ -187,20 +208,33 @@ Result CreateTransaction(const CWallet* wallet, const uint256& txid, const CCoin
     assert(nDelta > 0);
     mtx = CMutableTransaction{*wtx.tx};
     CTxOut* poutput = &(mtx.vout[nOutput]);
-    if (poutput->nValue < nDelta) {
+    // TODO CA: Decrypt output amount using wallet
+    if (!poutput->nValue.IsExplicit() || poutput->nValue.GetAmount() < nDelta) {
         errors.push_back("Change output is too small to bump the fee");
         return Result::WALLET_ERROR;
     }
 
     // If the output would become dust, discard it (converting the dust to fee)
-    poutput->nValue -= nDelta;
-    if (poutput->nValue <= GetDustThreshold(*poutput, GetDiscardRate(*wallet, ::feeEstimator))) {
+    poutput->nValue = poutput->nValue.GetAmount() - nDelta;
+    if (poutput->nValue.GetAmount() <= GetDustThreshold(*poutput, GetDiscardRate(*wallet, ::feeEstimator))) {
         wallet->WalletLogPrintf("Bumping fee and discarding dust output\n");
-        new_fee += poutput->nValue;
+        new_fee += poutput->nValue.GetAmount();
         mtx.vout.erase(mtx.vout.begin() + nOutput);
         if (mtx.witness.vtxoutwit.size() > (size_t) nOutput) {
             mtx.witness.vtxoutwit.erase(mtx.witness.vtxoutwit.begin() + nOutput);
         }
+        if (nFeeOutput > nOutput) {
+            --nFeeOutput;
+        }
+    }
+
+    // Update fee output or add one.
+    if (g_con_elementsmode) {
+        if (nFeeOutput >= 0) {
+            mtx.vout[nFeeOutput].nValue.SetToAmount(new_fee);
+        } else {
+            mtx.vout.push_back(CTxOut(::policyAsset, new_fee, CScript()));
+        }
     }
 
     // Mark new tx not replaceable, if requested.
@@ -242,10 +276,15 @@ Result CommitTransaction(CWallet* wallet, const uint256& txid, CMutableTransacti
     CTransactionRef tx = MakeTransactionRef(std::move(mtx));
     mapValue_t mapValue = oldWtx.mapValue;
     mapValue["replaces_txid"] = oldWtx.GetHash().ToString();
+    // wipe blinding details to not store old information
+    mapValue["blindingdata"] = "";
+    // TODO CA: store new blinding data to remember otherwise unblindable outputs
 
-    CReserveKey reservekey(wallet);
+    std::vector<std::unique_ptr<CReserveKey>> reservekeys;
+    reservekeys.push_back(std::unique_ptr<CReserveKey>(new CReserveKey(wallet)));
+    //reservekeys.push_back(std::unique_ptr<CReserveKey>(wallet));
     CValidationState state;
-    if (!wallet->CommitTransaction(tx, std::move(mapValue), oldWtx.vOrderForm, reservekey, g_connman.get(), state)) {
+    if (!wallet->CommitTransaction(tx, std::move(mapValue), oldWtx.vOrderForm, reservekeys, g_connman.get(), state)) {
         // NOTE: CommitTransaction never returns false, so this should never happen.
         errors.push_back(strprintf("The transaction was rejected: %s", FormatStateMessage(state)));
         return Result::WALLET_ERROR;
diff --git a/src/wallet/rpcdump.cpp b/src/wallet/rpcdump.cpp
index f19a1bb56958c..54639d7ef074b 100644
--- a/src/wallet/rpcdump.cpp
+++ b/src/wallet/rpcdump.cpp
@@ -26,6 +26,7 @@
 #include <univalue.h>
 
 #include <script/descriptor.h> // getwalletpakinfo
+#include <rpc/util.h> // IsBlindDestination
 
 
 int64_t static DecodeDumpTime(const std::string &str) {
@@ -235,7 +236,7 @@ static void ImportScript(CWallet* const pwallet, const CScript& script, const st
         if (!pwallet->HaveCScript(id) && !pwallet->AddCScript(script)) {
             throw JSONRPCError(RPC_WALLET_ERROR, "Error adding p2sh redeemScript to wallet");
         }
-        ImportAddress(pwallet, id, strLabel);
+        ImportAddress(pwallet, ScriptHash(id), strLabel);
     } else {
         CTxDestination destination;
         if (ExtractDestination(script, destination)) {
@@ -573,7 +574,7 @@ UniValue importwallet(const JSONRPCRequest& request)
                 assert(key.VerifyPubKey(pubkey));
                 CKeyID keyid = pubkey.GetID();
                 if (pwallet->HaveKey(keyid)) {
-                    pwallet->WalletLogPrintf("Skipping import of %s (key already present)\n", EncodeDestination(keyid));
+                    pwallet->WalletLogPrintf("Skipping import of %s (key already present)\n", EncodeDestination(PKHash(keyid)));
                     continue;
                 }
                 int64_t nTime = DecodeDumpTime(vstr[1]);
@@ -591,14 +592,14 @@ UniValue importwallet(const JSONRPCRequest& request)
                         fLabel = true;
                     }
                 }
-                pwallet->WalletLogPrintf("Importing %s...\n", EncodeDestination(keyid));
+                pwallet->WalletLogPrintf("Importing %s...\n", EncodeDestination(PKHash(keyid)));
                 if (!pwallet->AddKeyPubKey(key, pubkey)) {
                     fGood = false;
                     continue;
                 }
                 pwallet->mapKeyMetadata[keyid].nCreateTime = nTime;
                 if (fLabel)
-                    pwallet->SetAddressBook(keyid, strLabel, "receive");
+                    pwallet->SetAddressBook(PKHash(keyid), strLabel, "receive");
                 nTimeBegin = std::min(nTimeBegin, nTime);
             } else if(IsHex(vstr[0])) {
                std::vector<unsigned char> vData(ParseHex(vstr[0]));
@@ -735,8 +736,8 @@ UniValue dumpwallet(const JSONRPCRequest& request)
     // 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));
+        if (const PKHash* keyID = boost::get<PKHash>(&entry.first)) { // set and test
+            vKeyBirth.push_back(std::make_pair(entry.second, CKeyID(*keyID)));
         }
     }
     mapKeyBirth.clear();
@@ -761,6 +762,10 @@ UniValue dumpwallet(const JSONRPCRequest& request)
             file << "# extended private masterkey: " << EncodeExtKey(masterKey) << "\n\n";
         }
     }
+    // ELEMENTS: Dump the master blinding key in hex as well
+    if (!pwallet->blinding_derivation_key.IsNull()) {
+        file << ("# Master private blinding key: " + pwallet->blinding_derivation_key.GetHex() + "\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);
@@ -787,7 +792,7 @@ UniValue dumpwallet(const JSONRPCRequest& request)
     for (const CScriptID &scriptid : scripts) {
         CScript script;
         std::string create_time = "0";
-        std::string address = EncodeDestination(scriptid);
+        std::string address = EncodeDestination(ScriptHash(scriptid));
         // get birth times for scripts with metadata
         auto it = pwallet->m_script_metadata.find(scriptid);
         if (it != pwallet->m_script_metadata.end()) {
@@ -825,6 +830,7 @@ static UniValue ProcessImport(CWallet * const pwallet, const UniValue& data, con
         // 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 std::string& str_blinding_key = data.exists("blinding_privkey") ? data["blinding_privkey"].get_str() : "";
         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;
@@ -878,6 +884,18 @@ static UniValue ProcessImport(CWallet * const pwallet, const UniValue& data, con
 
         // Process. //
 
+        // Get blinding privkey
+        if (!str_blinding_key.empty() &&
+                (!IsHex(str_blinding_key) || str_blinding_key.size() != 64)) {
+            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid blinding privkey");
+        }
+
+        uint256 blinding_privkey;
+        if (!str_blinding_key.empty()) {
+            std::vector<unsigned char> blind_bytes = ParseHex(str_blinding_key);
+            memcpy(blinding_privkey.begin(), blind_bytes.data(), 32);
+        }
+
         // P2SH
         if (isP2SH) {
             // Import redeem script.
@@ -900,7 +918,7 @@ static UniValue ProcessImport(CWallet * const pwallet, const UniValue& data, con
                 throw JSONRPCError(RPC_WALLET_ERROR, "Error adding p2sh redeemScript to wallet");
             }
 
-            CScript redeemDestination = GetScriptForDestination(redeem_id);
+            CScript redeemDestination = GetScriptForDestination(ScriptHash(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");
@@ -933,7 +951,7 @@ static UniValue ProcessImport(CWallet * const pwallet, const UniValue& data, con
 
                     CKeyID vchAddress = pubkey.GetID();
                     pwallet->MarkDirty();
-                    pwallet->SetAddressBook(vchAddress, label, "receive");
+                    pwallet->SetAddressBook(PKHash(vchAddress), label, "receive");
 
                     if (pwallet->HaveKey(vchAddress)) {
                         throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Already have this key");
@@ -966,7 +984,7 @@ static UniValue ProcessImport(CWallet * const pwallet, const UniValue& data, con
                     throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Pubkey is not a valid public key");
                 }
 
-                CTxDestination pubkey_dest = pubKey.GetID();
+                CTxDestination pubkey_dest = PKHash(pubKey);
 
                 // Consistency check.
                 if (!(pubkey_dest == dest)) {
@@ -1020,7 +1038,7 @@ static UniValue ProcessImport(CWallet * const pwallet, const UniValue& data, con
                 CPubKey pubKey = key.GetPubKey();
                 assert(key.VerifyPubKey(pubKey));
 
-                CTxDestination pubkey_dest = pubKey.GetID();
+                CTxDestination pubkey_dest = PKHash(pubKey);
 
                 // Consistency check.
                 if (!(pubkey_dest == dest)) {
@@ -1029,7 +1047,7 @@ static UniValue ProcessImport(CWallet * const pwallet, const UniValue& data, con
 
                 CKeyID vchAddress = pubKey.GetID();
                 pwallet->MarkDirty();
-                pwallet->SetAddressBook(vchAddress, label, "receive");
+                pwallet->SetAddressBook(PKHash(vchAddress), label, "receive");
 
                 if (pwallet->HaveKey(vchAddress)) {
                     throw JSONRPCError(RPC_WALLET_ERROR, "The wallet already contains the private key for this address or script");
@@ -1067,6 +1085,11 @@ static UniValue ProcessImport(CWallet * const pwallet, const UniValue& data, con
             }
         }
 
+        // Lastly, if dest import is valid, import blinding key
+        if (!str_blinding_key.empty() && !pwallet->AddSpecificBlindingKey(CScriptID(GetScriptForDestination(dest)), blinding_privkey)) {
+            throw JSONRPCError(RPC_WALLET_ERROR, "Error adding blinding key to wallet");
+        }
+
         UniValue result = UniValue(UniValue::VOBJ);
         result.pushKV("success", UniValue(success));
         return result;
@@ -1123,6 +1146,7 @@ UniValue importmulti(const JSONRPCRequest& mainRequest)
             "                                                              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"
+            "      \"blinding_privkey\": \"<privkey>\"                       , (string, optional) String giving blinding key in hex that is used to unblind outputs going to `scriptPubKey`\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"
@@ -1293,7 +1317,7 @@ UniValue getwalletpakinfo(const JSONRPCRequest& request)
 
     ret.pushKV("bitcoin_descriptor", desc_str);
     ret.pushKV("liquid_pak", HexStr(pwallet->online_key));
-    ret.pushKV("liquid_pak_address", EncodeDestination((pwallet->online_key.GetID())));
+    ret.pushKV("liquid_pak_address", EncodeDestination(PKHash(pwallet->online_key)));
 
     UniValue address_list(UniValue::VARR);
     for (unsigned int i = 0; i < 3; i++) {
@@ -1309,3 +1333,251 @@ UniValue getwalletpakinfo(const JSONRPCRequest& request)
     ret.pushKV("address_lookahead", address_list);
     return ret;
 }
+
+UniValue importblindingkey(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 || request.params.size() > 3)
+        throw std::runtime_error(
+            "importblindingkey \"address\" \"blindinghex\"\n"
+            "\nImports a private blinding key in hex for a CT address."
+            "\nArguments:\n"
+            "1. \"address\"          (string, required) The CT address\n"
+            "2. \"hexkey\"           (string, required) The blinding key in hex\n"
+            "3. \"key_is_master\"    (bool, optional, default=false) If the `hexkey` is a master blinding key. Note: wallets can only have one master blinding key at a time. Funds could be permanently lost if user doesn't know what they are doing. Recommended use is only for wallet recovery using this in conjunction with `sethdseed`.\n"
+            "\nExample:\n"
+            + HelpExampleCli("importblindingkey", "\"my blinded CT address\" <blindinghex>")
+        );
+
+    LOCK2(cs_main, pwallet->cs_wallet);
+
+    CTxDestination dest = DecodeDestination(request.params[0].get_str());
+    if (!IsValidDestination(dest)) {
+        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Bitcoin address.");
+    }
+    if (!IsBlindDestination(dest)) {
+        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Address is not confidential.");
+    }
+
+    if (!IsHex(request.params[1].get_str())) {
+        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid hexadecimal for key");
+    }
+    std::vector<unsigned char> keydata = ParseHex(request.params[1].get_str());
+    if (keydata.size() != 32) {
+        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid hexadecimal key length");
+    }
+
+    bool key_is_master = false;
+    if (!request.params[2].isNull()) {
+        key_is_master = request.params[2].get_bool();
+    }
+
+    CKey key;
+    key.Set(keydata.begin(), keydata.end(), true);
+    if (!key.IsValid() || key.GetPubKey() != GetDestinationBlindingKey(dest)) {
+        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Address and key do not match");
+    }
+
+    uint256 keyval;
+    memcpy(keyval.begin(), &keydata[0], 32);
+    if (key_is_master) {
+        if (pwallet->SetMasterBlindingKey(keyval)) {
+            throw JSONRPCError(RPC_WALLET_ERROR, "Failed to import master blinding key");
+        }
+    } else {
+        if (!pwallet->AddSpecificBlindingKey(CScriptID(GetScriptForDestination(dest)), keyval)) {
+            throw JSONRPCError(RPC_WALLET_ERROR, "Failed to import blinding key");
+        }
+    }
+    pwallet->MarkDirty();
+
+    return NullUniValue;
+}
+
+UniValue importissuanceblindingkey(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() != 3)
+        throw std::runtime_error(
+            "importissuanceblindingkey \"txid\" vin \"blindingkey\"\n"
+            "\nImports a private blinding key in hex for an asset issuance."
+            "\nArguments:\n"
+
+            "1. \"txid\"          (string, required) The transaction id of the issuance\n"
+            "2. \"vin\"           (numeric, required) The input number of the issuance in the transaction.\n"
+            "3. \"blindingkey\"           (string, required) The blinding key in hex\n"
+            "\nExample:\n"
+            + HelpExampleCli("importblindingkey", "\"my blinded CT address\" <blindinghex>")
+        );
+
+    LOCK2(cs_main, pwallet->cs_wallet);
+
+    if (!request.params[0].isStr() || !IsHex(request.params[0].get_str()) || request.params[0].get_str().size() != 64) {
+        throw JSONRPCError(RPC_TYPE_ERROR, "First argument must be a txid string");
+    }
+    std::string txidstr = request.params[0].get_str();
+    uint256 txid;
+    txid.SetHex(txidstr);
+
+    uint32_t vindex;
+    if (!request.params[1].isNum()) {
+        throw JSONRPCError(RPC_TYPE_ERROR, "vin must be an integer");
+    }
+    vindex = request.params[1].get_int();
+
+    if (!request.params[2].isStr() || !IsHex(request.params[2].get_str()) || request.params[2].get_str().size() != 64) {
+        throw JSONRPCError(RPC_TYPE_ERROR, "blinding key must be a hex string of length 64");
+    }
+
+    std::vector<unsigned char> keydata = ParseHex(request.params[2].get_str());
+    if (keydata.size() != 32) {
+        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid hexadecimal key length");
+    }
+    CKey key;
+    key.Set(keydata.begin(), keydata.end(), true);
+
+    // Process as issuance key dump
+    for (std::map<uint256, CWalletTx>::const_iterator it = pwallet->mapWallet.begin(); it != pwallet->mapWallet.end(); ++it) {
+        const CWalletTx* pcoin = &(*it).second;
+        if (pcoin->GetHash() != txid) {
+            continue;
+        }
+        if (pcoin->tx->vin.size() <= vindex) {
+            throw JSONRPCError(RPC_WALLET_ERROR, "Transaction is in wallet but vin does not exist");
+        }
+        if (pcoin->tx->vin[vindex].assetIssuance.IsNull()) {
+            throw JSONRPCError(RPC_WALLET_ERROR, "Transaction input has no issuance");
+        }
+
+        // Import the key in that slot
+        uint256 keyval;
+        memcpy(keyval.begin(), &keydata[0], 32);
+        CScript blindingScript(CScript() << OP_RETURN << std::vector<unsigned char>(pcoin->tx->vin[vindex].prevout.hash.begin(), pcoin->tx->vin[vindex].prevout.hash.end()) << pcoin->tx->vin[vindex].prevout.n);
+        if (!pwallet->AddSpecificBlindingKey(CScriptID(blindingScript), keyval)) {
+            throw JSONRPCError(RPC_WALLET_ERROR, "Failed to import blinding key");
+        }
+        pwallet->MarkDirty();
+        return NullUniValue;
+    }
+
+    throw JSONRPCError(RPC_WALLET_ERROR, "Transaction is unknown to wallet.");
+}
+
+UniValue dumpblindingkey(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(
+            "dumpblindingkey \"address\"\n"
+            "\nDumps the private blinding key for a CT address in hex."
+            "\nArguments:\n"
+            "1. \"address\"          (string, required) The CT address\n"
+            "\nResult:\n"
+            "\"blindingkey\"      (string) The blinding key\n"
+            "\nExample:\n"
+            + HelpExampleCli("dumpblindingkey", "\"my address\"")
+        );
+
+    LOCK2(cs_main, pwallet->cs_wallet);
+
+
+    CTxDestination dest = DecodeDestination(request.params[0].get_str());
+    if (!IsValidDestination(dest)) {
+        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Bitcoin address");
+    }
+    if (!IsBlindDestination(dest)) {
+        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Not a CT address");
+    }
+    CScript script = GetScriptForDestination(dest);
+    CKey key;
+    key = pwallet->GetBlindingKey(&script);
+    if (key.IsValid()) {
+        CPubKey pubkey(key.GetPubKey());
+        if (pubkey == GetDestinationBlindingKey(dest)) {
+            return HexStr(key.begin(), key.end());
+        }
+    }
+
+    throw JSONRPCError(RPC_WALLET_ERROR, "Blinding key for address is unknown");
+}
+
+UniValue dumpissuanceblindingkey(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(
+            "dumpissuanceblindingkey \"txid\" vin\n"
+            "\nDumps the private blinding key for an asset issuance in wallet."
+            "\nArguments:\n"
+            "1. \"txid\"          (string, required) The transaction id of the issuance\n"
+            "2. \"vin\"           (numeric, required) The input number of the issuance in the transaction.\n"
+            "\nResult:\n"
+            "\"blindingkey\"      (string) The blinding key\n"
+            "\nExample:\n"
+            + HelpExampleCli("dumpissuanceblindingkey", "\"<txid>\", 0")
+        );
+
+    LOCK2(cs_main, pwallet->cs_wallet);
+
+    if (!request.params[0].isStr() || !IsHex(request.params[0].get_str()) || request.params[0].get_str().size() != 64) {
+        throw JSONRPCError(RPC_TYPE_ERROR, "First argument must be a txid string");
+    }
+    std::string txidstr = request.params[0].get_str();
+    uint256 txid;
+    txid.SetHex(txidstr);
+
+    uint32_t vindex;
+    if (!request.params[1].isNum()) {
+        throw JSONRPCError(RPC_TYPE_ERROR, "vin must be an integer");
+    }
+    vindex = request.params[1].get_int();
+
+    // Process as issuance key dump
+    for (std::map<uint256, CWalletTx>::const_iterator it = pwallet->mapWallet.begin(); it != pwallet->mapWallet.end(); ++it) {
+        const CWalletTx* pcoin = &(*it).second;
+        if (pcoin->tx->GetHash() != txid) {
+            continue;
+        }
+        if (pcoin->tx->vin.size() <= vindex) {
+            throw JSONRPCError(RPC_WALLET_ERROR, "Transaction is in wallet but vin does not exist");
+        }
+        if (pcoin->tx->vin[vindex].assetIssuance.IsNull()) {
+            throw JSONRPCError(RPC_WALLET_ERROR, "Transaction input has no issuance");
+        }
+        // We can actually deblind the input
+        if (pcoin->GetIssuanceAmount(vindex, false) != -1 ) {
+            CScript blindingScript(CScript() << OP_RETURN << std::vector<unsigned char>(pcoin->tx->vin[vindex].prevout.hash.begin(), pcoin->tx->vin[vindex].prevout.hash.end()) << pcoin->tx->vin[vindex].prevout.n);
+            CKey key;
+            key = pwallet->GetBlindingKey(&blindingScript);
+            return HexStr(key.begin(), key.end());
+        } else {
+            // We don't know how to deblind this using our wallet
+            throw JSONRPCError(RPC_WALLET_ERROR, "Unable to unblind issuance with wallet blinding key.");
+        }
+    }
+    throw JSONRPCError(RPC_WALLET_ERROR, "Transaction is unknown to wallet.");
+}
diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
index ea8673264e781..e0ef1965ffb72 100644
--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@@ -4,6 +4,8 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <amount.h>
+#include <asset.h>
+#include <assetsdir.h>
 #include <block_proof.h>
 #include <chain.h>
 #include <consensus/validation.h>
@@ -50,6 +52,8 @@
 #include <script/generic.hpp> // signblock
 #include <script/descriptor.h> // initpegoutwallet
 #include <span.h> // sendtomainchain_pak
+#include <blind.h>
+#include <issuance.h>
 
 static const std::string WALLET_ENDPOINT_BASE = "/wallet/";
 
@@ -137,8 +141,12 @@ static void WalletTxToJSON(const CWalletTx& wtx, UniValue& entry) EXCLUSIVE_LOCK
     }
     entry.pushKV("bip125-replaceable", rbfStatus);
 
-    for (const std::pair<const std::string, std::string>& item : wtx.mapValue)
-        entry.pushKV(item.first, item.second);
+    for (const std::pair<const std::string, std::string>& item : wtx.mapValue) {
+        // Skip blinding data which isn't parseable
+        if (item.first != "blindingdata") {
+            entry.pushKV(item.first, item.second);
+        }
+    }
 }
 
 static std::string LabelFromValue(const UniValue& value)
@@ -164,6 +172,8 @@ static UniValue getnewaddress(const JSONRPCRequest& request)
             "\nReturns a new Bitcoin address for receiving payments.\n"
             "If 'label' is specified, it is added to the address book \n"
             "so payments received with the address will be associated with 'label'.\n"
+            "Blinded addresses are returned by default, and can be set with\n"
+            "startup argument `-blindedaddresses`.\n"
             "\nArguments:\n"
             "1. \"label\"          (string, optional) The label name for the address to be linked to. If not provided, the default label \"\" is used. It can also be set to the empty string \"\" to represent the default label. The label does not need to exist, it will be created if there is no label by the given name.\n"
             "2. \"address_type\"   (string, optional) The address type to use. Options are \"legacy\", \"p2sh-segwit\", and \"bech32\". Default is set by -addresstype.\n"
@@ -203,6 +213,10 @@ static UniValue getnewaddress(const JSONRPCRequest& request)
     }
     pwallet->LearnRelatedScripts(newKey, output_type);
     CTxDestination dest = GetDestinationForKey(newKey, output_type);
+    if (gArgs.GetBoolArg("-blindedaddresses", g_con_elementsmode)) {
+        CPubKey blinding_pubkey = pwallet->GetBlindingPubKey(GetScriptForDestination(dest));
+        dest = GetDestinationForKey(newKey, output_type, blinding_pubkey);
+    }
 
     pwallet->SetAddressBook(dest, label, "receive");
 
@@ -223,6 +237,8 @@ static UniValue getrawchangeaddress(const JSONRPCRequest& request)
             "getrawchangeaddress ( \"address_type\" )\n"
             "\nReturns a new Bitcoin address, for receiving change.\n"
             "This is for use with raw transactions, NOT normal use.\n"
+            "Blinded addresses are returned by default, and can be set with\n"
+            "startup argument `-blindedaddresses`.\n"
             "\nArguments:\n"
             "1. \"address_type\"           (string, optional) The address type to use. Options are \"legacy\", \"p2sh-segwit\", and \"bech32\". Default is set by -changetype.\n"
             "\nResult:\n"
@@ -258,6 +274,10 @@ static UniValue getrawchangeaddress(const JSONRPCRequest& request)
 
     pwallet->LearnRelatedScripts(vchPubKey, output_type);
     CTxDestination dest = GetDestinationForKey(vchPubKey, output_type);
+    if (gArgs.GetBoolArg("-blindedaddresses", g_con_elementsmode)) {
+        CPubKey blinding_pubkey = pwallet->GetBlindingPubKey(GetScriptForDestination(dest));
+        dest = GetDestinationForKey(vchPubKey, output_type, blinding_pubkey);
+    }
 
     return EncodeDestination(dest);
 }
@@ -303,15 +323,15 @@ static UniValue setlabel(const JSONRPCRequest& request)
 }
 
 
-static CTransactionRef SendMoney(CWallet * const pwallet, const CTxDestination &address, CAmount nValue, bool fSubtractFeeFromAmount, const CCoinControl& coin_control, mapValue_t mapValue)
+static CTransactionRef SendMoney(CWallet * const pwallet, const CTxDestination &address, CAmount nValue, const CAsset& asset, bool fSubtractFeeFromAmount, const CCoinControl& coin_control, mapValue_t mapValue, bool ignore_blind_fail)
 {
-    CAmount curBalance = pwallet->GetBalance();
+    CAmountMap curBalance = pwallet->GetBalance();
 
     // Check amount
     if (nValue <= 0)
         throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid amount");
 
-    if (nValue > curBalance)
+    if (nValue > curBalance[asset])
         throw JSONRPCError(RPC_WALLET_INSUFFICIENT_FUNDS, "Insufficient funds");
 
     if (pwallet->GetBroadcastTransactions() && !g_connman) {
@@ -321,22 +341,32 @@ static CTransactionRef SendMoney(CWallet * const pwallet, const CTxDestination &
     // Parse Bitcoin address
     CScript scriptPubKey = GetScriptForDestination(address);
 
+    // Create the lower bound number of reserve keys.
+    std::vector<COutPoint> vPresetInputs;
+    coin_control.ListSelected(vPresetInputs);
+    int numReservedKeysNeeded = 2 + vPresetInputs.size(); // 1 fee + 1 destination
+    std::vector<std::unique_ptr<CReserveKey>> reserveKeys;
+    for (int i = 0; i < numReservedKeysNeeded; ++i) {
+        reserveKeys.push_back(std::unique_ptr<CReserveKey>(new CReserveKey(pwallet)));
+    }
+
     // Create and send the transaction
-    CReserveKey reservekey(pwallet);
     CAmount nFeeRequired;
     std::string strError;
     std::vector<CRecipient> vecSend;
     int nChangePosRet = -1;
-    CRecipient recipient = {scriptPubKey, nValue, fSubtractFeeFromAmount};
+    CRecipient recipient = {scriptPubKey, nValue, asset, GetDestinationBlindingKey(address), fSubtractFeeFromAmount};
     vecSend.push_back(recipient);
     CTransactionRef tx;
-    if (!pwallet->CreateTransaction(vecSend, tx, reservekey, nFeeRequired, nChangePosRet, strError, coin_control)) {
-        if (!fSubtractFeeFromAmount && nValue + nFeeRequired > curBalance)
+    BlindDetails* blind_details = g_con_elementsmode ? new BlindDetails() : NULL;
+    if (blind_details) blind_details->ignore_blind_failure = ignore_blind_fail;
+    if (!pwallet->CreateTransaction(vecSend, tx, reserveKeys, nFeeRequired, nChangePosRet, strError, coin_control, true, blind_details)) {
+        if (!fSubtractFeeFromAmount && nValue + nFeeRequired > curBalance[policyAsset])
             strError = strprintf("Error: This transaction requires a transaction fee of at least %s", FormatMoney(nFeeRequired));
         throw JSONRPCError(RPC_WALLET_ERROR, strError);
     }
     CValidationState state;
-    if (!pwallet->CommitTransaction(tx, std::move(mapValue), {} /* orderForm */, reservekey, g_connman.get(), state)) {
+    if (!pwallet->CommitTransaction(tx, std::move(mapValue), {} /* orderForm */, reserveKeys, g_connman.get(), state, blind_details)) {
         strError = strprintf("Error: The transaction was rejected! Reason given: %s", FormatStateMessage(state));
         throw JSONRPCError(RPC_WALLET_ERROR, strError);
     }
@@ -352,9 +382,9 @@ static UniValue sendtoaddress(const JSONRPCRequest& request)
         return NullUniValue;
     }
 
-    if (request.fHelp || request.params.size() < 2 || request.params.size() > 8)
+    if (request.fHelp || request.params.size() < 2 || request.params.size() > 10)
         throw std::runtime_error(
-            "sendtoaddress \"address\" amount ( \"comment\" \"comment_to\" subtractfeefromamount replaceable conf_target \"estimate_mode\")\n"
+            "sendtoaddress \"address\" amount ( \"comment\" \"comment_to\" subtractfeefromamount replaceable conf_target \"estimate_mode\" \"assetlabel\" ignoreblindfail )\n"
             "\nSend an amount to a given address.\n"
             + HelpRequiringPassphrase(pwallet) +
             "\nArguments:\n"
@@ -373,6 +403,8 @@ static UniValue sendtoaddress(const JSONRPCRequest& request)
             "       \"UNSET\"\n"
             "       \"ECONOMICAL\"\n"
             "       \"CONSERVATIVE\"\n"
+            "9. \"assetlabel\"               (string, optional) Hex asset id or asset label for balance.\n"
+            "10. \"ignoreblindfail\"   (bool, default=true) Return a transaction even when a blinding attempt fails due to number of blinded inputs/outputs.\n"
             "\nResult:\n"
             "\"txid\"                  (string) The transaction id.\n"
             "\nExamples:\n"
@@ -425,10 +457,23 @@ static UniValue sendtoaddress(const JSONRPCRequest& request)
         }
     }
 
+    std::string strasset = Params().GetConsensus().pegged_asset.GetHex();
+    if (request.params.size() > 8 && request.params[8].isStr() && !request.params[8].get_str().empty()) {
+        strasset = request.params[8].get_str();
+    }
+    CAsset asset = GetAssetFromString(strasset);
+    if (asset.IsNull() && g_con_elementsmode) {
+        throw JSONRPCError(RPC_WALLET_ERROR, strprintf("Unknown label and invalid asset hex: %s", asset.GetHex()));
+    }
+
+    bool ignore_blind_fail = true;
+    if (request.params.size() > 9) {
+        ignore_blind_fail = request.params[9].get_bool();
+    }
 
     EnsureWalletIsUnlocked(pwallet);
 
-    CTransactionRef tx = SendMoney(pwallet, dest, nAmount, fSubtractFeeFromAmount, coin_control, std::move(mapValue));
+    CTransactionRef tx = SendMoney(pwallet, dest, nAmount, asset, fSubtractFeeFromAmount, coin_control, std::move(mapValue), ignore_blind_fail);
     return tx->GetHash().GetHex();
 }
 
@@ -533,13 +578,14 @@ static UniValue signmessage(const JSONRPCRequest& request)
         throw JSONRPCError(RPC_TYPE_ERROR, "Invalid address");
     }
 
-    const CKeyID *keyID = boost::get<CKeyID>(&dest);
-    if (!keyID) {
+    const PKHash *pkhash = boost::get<PKHash>(&dest);
+    if (!pkhash) {
         throw JSONRPCError(RPC_TYPE_ERROR, "Address does not refer to key");
     }
 
     CKey key;
-    if (!pwallet->GetKey(*keyID, key)) {
+    CKeyID keyID(*pkhash);
+    if (!pwallet->GetKey(keyID, key)) {
         throw JSONRPCError(RPC_WALLET_ERROR, "Private key not available");
     }
 
@@ -570,6 +616,7 @@ static UniValue getreceivedbyaddress(const JSONRPCRequest& request)
             "\nArguments:\n"
             "1. \"address\"         (string, required) The bitcoin address for transactions.\n"
             "2. minconf             (numeric, optional, default=1) Only include transactions confirmed at least this many times.\n"
+            "3. \"assetlabel\"      (string, optional) Hex asset id or asset label for balance.\n"
             "\nResult:\n"
             "amount   (numeric) The total amount in " + CURRENCY_UNIT + " received at this address.\n"
             "\nExamples:\n"
@@ -605,19 +652,34 @@ static UniValue getreceivedbyaddress(const JSONRPCRequest& request)
         nMinDepth = request.params[1].get_int();
 
     // Tally
-    CAmount nAmount = 0;
-    for (const std::pair<const uint256, CWalletTx>& pairWtx : pwallet->mapWallet) {
-        const CWalletTx& wtx = pairWtx.second;
+    CAmountMap amounts;
+    for (auto& pairWtx : pwallet->mapWallet) {
+        CWalletTx& wtx = pairWtx.second;
         if (wtx.IsCoinBase() || !CheckFinalTx(*wtx.tx))
             continue;
 
-        for (const CTxOut& txout : wtx.tx->vout)
-            if (txout.scriptPubKey == scriptPubKey)
-                if (wtx.GetDepthInMainChain() >= nMinDepth)
-                    nAmount += txout.nValue;
+        for (unsigned int i = 0; i < wtx.tx->vout.size(); i++) {
+            const CTxOut& txout = wtx.tx->vout[i];
+            if (txout.scriptPubKey == scriptPubKey) {
+                if (wtx.GetDepthInMainChain() >= nMinDepth) {
+                    CAmountMap wtxValue;
+                    CAmount amt = wtx.GetOutputValueOut(i);
+                    if (amt < 0) {
+                        continue;
+                    }
+                    wtxValue[wtx.GetOutputAsset(i)] = amt;
+                    amounts += wtxValue;
+                }
+            }
+        }
     }
 
-    return  ValueFromAmount(nAmount);
+    std::string asset = "";
+    if (request.params.size() > 2 && request.params[2].isStr()) {
+        asset = request.params[2].get_str();
+    }
+
+    return AmountMapToUniv(amounts, asset);
 }
 
 
@@ -637,6 +699,7 @@ static UniValue getreceivedbylabel(const JSONRPCRequest& request)
             "\nArguments:\n"
             "1. \"label\"        (string, required) The selected label, may be the default label using \"\".\n"
             "2. minconf          (numeric, optional, default=1) Only include transactions confirmed at least this many times.\n"
+            "3. \"assetlabel\"      (string, optional) Hex asset id or asset label for balance.\n"
             "\nResult:\n"
             "amount              (numeric) The total amount in " + CURRENCY_UNIT + " received for this label.\n"
             "\nExamples:\n"
@@ -666,23 +729,35 @@ static UniValue getreceivedbylabel(const JSONRPCRequest& request)
     std::set<CTxDestination> setAddress = pwallet->GetLabelAddresses(label);
 
     // Tally
-    CAmount nAmount = 0;
-    for (const std::pair<const uint256, CWalletTx>& pairWtx : pwallet->mapWallet) {
-        const CWalletTx& wtx = pairWtx.second;
+    CAmountMap amounts;
+    for (auto& pairWtx : pwallet->mapWallet) {
+        CWalletTx& wtx = pairWtx.second;
         if (wtx.IsCoinBase() || !CheckFinalTx(*wtx.tx))
             continue;
 
-        for (const CTxOut& txout : wtx.tx->vout)
-        {
+        for (unsigned int i = 0; i < wtx.tx->vout.size(); i++) {
+            const CTxOut& txout = wtx.tx->vout[i];
             CTxDestination address;
             if (ExtractDestination(txout.scriptPubKey, address) && IsMine(*pwallet, address) && setAddress.count(address)) {
-                if (wtx.GetDepthInMainChain() >= nMinDepth)
-                    nAmount += txout.nValue;
+                if (wtx.GetDepthInMainChain() >= nMinDepth) {
+                    CAmountMap wtxValue;
+                    CAmount amt = wtx.GetOutputValueOut(i);
+                    if (amt < 0) {
+                        continue;
+                    }
+                    wtxValue[wtx.GetOutputAsset(i)] = amt;
+                    amounts += wtxValue;
+                }
             }
         }
     }
 
-    return ValueFromAmount(nAmount);
+    std::string asset = "";
+    if (request.params.size() > 2 && request.params[2].isStr()) {
+        asset = request.params[2].get_str();
+    }
+
+    return AmountMapToUniv(amounts, asset);
 }
 
 
@@ -695,7 +770,7 @@ static UniValue getbalance(const JSONRPCRequest& request)
         return NullUniValue;
     }
 
-    if (request.fHelp || (request.params.size() > 3 ))
+    if (request.fHelp || (request.params.size() > 4 ))
         throw std::runtime_error(
             "getbalance ( \"(dummy)\" minconf include_watchonly )\n"
             "\nReturns the total available balance.\n"
@@ -705,6 +780,7 @@ static UniValue getbalance(const JSONRPCRequest& request)
             "1. (dummy)           (string, optional) Remains for backward compatibility. Must be excluded or set to \"*\".\n"
             "2. minconf           (numeric, optional, default=0) Only include transactions confirmed at least this many times.\n"
             "3. include_watchonly (bool, optional, default=false) Also include balance in watch-only addresses (see 'importaddress')\n"
+            "4. \"assetlabel\"   (string, optional) Hex asset id or asset label for balance.\n"
             "\nResult:\n"
             "amount              (numeric) The total amount in " + CURRENCY_UNIT + " received for this wallet.\n"
             "\nExamples:\n"
@@ -737,7 +813,12 @@ static UniValue getbalance(const JSONRPCRequest& request)
         filter = filter | ISMINE_WATCH_ONLY;
     }
 
-    return ValueFromAmount(pwallet->GetBalance(filter, min_depth));
+    std::string asset = "";
+    if (!request.params[3].isNull() && request.params[3].isStr()) {
+        asset = request.params[3].get_str();
+    }
+
+    return AmountMapToUniv(pwallet->GetBalance(filter, min_depth), asset);
 }
 
 static UniValue getunconfirmedbalance(const JSONRPCRequest &request)
@@ -760,7 +841,7 @@ static UniValue getunconfirmedbalance(const JSONRPCRequest &request)
 
     LOCK2(cs_main, pwallet->cs_wallet);
 
-    return ValueFromAmount(pwallet->GetUnconfirmedBalance());
+    return AmountMapToUniv(pwallet->GetUnconfirmedBalance(), "");
 }
 
 
@@ -773,10 +854,10 @@ static UniValue sendmany(const JSONRPCRequest& request)
         return NullUniValue;
     }
 
-    if (request.fHelp || request.params.size() < 2 || request.params.size() > 8)
+    if (request.fHelp || request.params.size() < 2 || request.params.size() > 10)
         throw std::runtime_error(
-            "sendmany \"\" {\"address\":amount,...} ( minconf \"comment\" [\"address\",...] replaceable conf_target \"estimate_mode\")\n"
-            "\nSend multiple times. Amounts are double-precision floating point numbers.\n"
+            "sendmany \"\" \"\" {\"address\":amount,...} ( minconf \"comment\" [\"address\",...] replaceable conf_target \"estimate_mode\", [\"output_assets\"])\n"
+            "\nSend multiple times. Amounts are double-precision floating point numbers."
             + HelpRequiringPassphrase(pwallet) + "\n"
             "\nArguments:\n"
             "1. \"dummy\"               (string, required) Must be set to \"\" for backwards compatibility.\n"
@@ -801,6 +882,12 @@ static UniValue sendmany(const JSONRPCRequest& request)
             "       \"UNSET\"\n"
             "       \"ECONOMICAL\"\n"
             "       \"CONSERVATIVE\"\n"
+            "9. \"output_assets\"     (string, optional, default=bitcoin) a json object of addresses to assets\n"
+            "   {\n"
+            "       \"address\": \"hex\" \n"
+            "       ...\n"
+            "   }\n"
+            "10. \"ignoreblindfail\"\"   (bool, default=true) Return a transaction even when a blinding attempt fails due to number of blinded inputs/outputs.\n"
              "\nResult:\n"
             "\"txid\"                   (string) The transaction id for the send. Only 1 transaction is created regardless of \n"
             "                                    the number of addresses.\n"
@@ -813,7 +900,7 @@ static UniValue sendmany(const JSONRPCRequest& request)
             + HelpExampleCli("sendmany", "\"\" \"{\\\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\\\":0.01,\\\"1353tsE8YMTA4EuV7dgUXGjNFf9KpVvKHz\\\":0.02}\" 1 \"\" \"[\\\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\\\",\\\"1353tsE8YMTA4EuV7dgUXGjNFf9KpVvKHz\\\"]\"") +
             "\nAs a json rpc call\n"
             + HelpExampleRpc("sendmany", "\"\", {\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\":0.01,\"1353tsE8YMTA4EuV7dgUXGjNFf9KpVvKHz\":0.02}, 6, \"testing\"")
-        );
+            );
 
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
@@ -856,12 +943,34 @@ static UniValue sendmany(const JSONRPCRequest& request)
         }
     }
 
+    UniValue assets;
+    if (!request.params[8].isNull()) {
+        if (!g_con_elementsmode) {
+            throw JSONRPCError(RPC_TYPE_ERROR, "Asset argument cannot be given for Bitcoin serialization.");
+        }
+        assets = request.params[8].get_obj();
+    }
+
+    bool ignore_blind_fail = true;
+    if (request.params.size() > 9) {
+        ignore_blind_fail = request.params[9].get_bool();
+    }
+
     std::set<CTxDestination> destinations;
     std::vector<CRecipient> vecSend;
 
-    CAmount totalAmount = 0;
+    CAmountMap totalAmount;
     std::vector<std::string> keys = sendTo.getKeys();
     for (const std::string& name_ : keys) {
+        std::string strasset = Params().GetConsensus().pegged_asset.GetHex();
+        if (!assets.isNull() && assets[name_].isStr()) {
+            strasset = assets[name_].get_str();
+        }
+        CAsset asset = GetAssetFromString(strasset);
+        if (asset.IsNull() && g_con_elementsmode) {
+            throw JSONRPCError(RPC_WALLET_ERROR, strprintf("Unknown label and invalid asset hex: %s", asset.GetHex()));
+        }
+
         CTxDestination dest = DecodeDestination(name_);
         if (!IsValidDestination(dest)) {
             throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, std::string("Invalid Bitcoin address: ") + name_);
@@ -876,7 +985,7 @@ static UniValue sendmany(const JSONRPCRequest& request)
         CAmount nAmount = AmountFromValue(sendTo[name_]);
         if (nAmount <= 0)
             throw JSONRPCError(RPC_TYPE_ERROR, "Invalid amount for send");
-        totalAmount += nAmount;
+        totalAmount[asset] += nAmount;
 
         bool fSubtractFeeFromAmount = false;
         for (unsigned int idx = 0; idx < subtractFeeFromAmount.size(); idx++) {
@@ -885,7 +994,7 @@ static UniValue sendmany(const JSONRPCRequest& request)
                 fSubtractFeeFromAmount = true;
         }
 
-        CRecipient recipient = {scriptPubKey, nAmount, fSubtractFeeFromAmount};
+        CRecipient recipient = {scriptPubKey, nAmount, asset, GetDestinationBlindingKey(dest), fSubtractFeeFromAmount};
         vecSend.push_back(recipient);
     }
 
@@ -900,16 +1009,39 @@ static UniValue sendmany(const JSONRPCRequest& request)
     std::shuffle(vecSend.begin(), vecSend.end(), FastRandomContext());
 
     // Send
-    CReserveKey keyChange(pwallet);
+    std::vector<std::unique_ptr<CReserveKey>> change_keys;
+
+    std::set<CAsset> setAssets;
+    setAssets.insert(policyAsset);
+    for (auto recipient : vecSend) {
+        setAssets.insert(recipient.asset);
+    }
+    std::vector<COutPoint> vPresetInputs;
+    coin_control.ListSelected(vPresetInputs);
+    for (const COutPoint& presetInput : vPresetInputs) {
+        std::map<uint256, CWalletTx>::const_iterator it = pwallet->mapWallet.find(presetInput.hash);
+        if (it != pwallet->mapWallet.end()) {
+            setAssets.insert(it->second.GetOutputAsset(presetInput.n));
+        }
+    }
+    for (unsigned int i = 0; i < setAssets.size(); i++) {
+        change_keys.push_back(std::unique_ptr<CReserveKey>(new CReserveKey(pwallet)));
+    }
+
     CAmount nFeeRequired = 0;
     int nChangePosRet = -1;
     std::string strFailReason;
     CTransactionRef tx;
-    bool fCreated = pwallet->CreateTransaction(vecSend, tx, keyChange, nFeeRequired, nChangePosRet, strFailReason, coin_control);
-    if (!fCreated)
+    BlindDetails* blind_details = g_con_elementsmode ? new BlindDetails() : NULL;
+    if (g_con_elementsmode) {
+        blind_details->ignore_blind_failure = ignore_blind_fail;
+    }
+    bool fCreated = pwallet->CreateTransaction(vecSend, tx, change_keys, nFeeRequired, nChangePosRet, strFailReason, coin_control, true, blind_details);
+    if (!fCreated) {
         throw JSONRPCError(RPC_WALLET_INSUFFICIENT_FUNDS, strFailReason);
+    }
     CValidationState state;
-    if (!pwallet->CommitTransaction(tx, std::move(mapValue), {} /* orderForm */, keyChange, g_connman.get(), state)) {
+    if (!pwallet->CommitTransaction(tx, std::move(mapValue), {} /* orderForm */, change_keys, g_connman.get(), state, blind_details)) {
         strFailReason = strprintf("Transaction commit failed:: %s", FormatStateMessage(state));
         throw JSONRPCError(RPC_WALLET_ERROR, strFailReason);
     }
@@ -1004,7 +1136,7 @@ class Witnessifier : public boost::static_visitor<bool>
 
     explicit Witnessifier(CWallet *_pwallet) : pwallet(_pwallet), already_witness(false) {}
 
-    bool operator()(const CKeyID &keyID) {
+    bool operator()(const PKHash &keyID) {
         if (pwallet) {
             CScript basescript = GetScriptForDestination(keyID);
             CScript witscript = GetScriptForWitness(basescript);
@@ -1016,9 +1148,9 @@ class Witnessifier : public boost::static_visitor<bool>
         return false;
     }
 
-    bool operator()(const CScriptID &scriptID) {
+    bool operator()(const ScriptHash &scripthash) {
         CScript subscript;
-        if (pwallet && pwallet->GetCScript(scriptID, subscript)) {
+        if (pwallet && pwallet->GetCScript(CScriptID(scripthash), subscript)) {
             int witnessversion;
             std::vector<unsigned char> witprog;
             if (subscript.IsWitnessProgram(witnessversion, witprog)) {
@@ -1105,7 +1237,7 @@ static UniValue addwitnessaddress(const JSONRPCRequest& request)
     CScript witprogram = GetScriptForDestination(w.result);
 
     if (p2sh) {
-        w.result = CScriptID(witprogram);
+        w.result = ScriptHash(witprogram);
     }
 
     if (w.already_witness) {
@@ -1122,13 +1254,13 @@ static UniValue addwitnessaddress(const JSONRPCRequest& request)
 
 struct tallyitem
 {
-    CAmount nAmount;
+    CAmountMap mapAmount;
     int nConf;
     std::vector<uint256> txids;
     bool fIsWatchonly;
     tallyitem()
     {
-        nAmount = 0;
+        mapAmount = CAmountMap();
         nConf = std::numeric_limits<int>::max();
         fIsWatchonly = false;
     }
@@ -1153,7 +1285,7 @@ static UniValue ListReceived(CWallet * const pwallet, const UniValue& params, bo
 
     bool has_filtered_address = false;
     CTxDestination filtered_address = CNoDestination();
-    if (!by_label && params.size() > 3) {
+    if (!by_label && params.size() > 3 && params[3].get_str() != "") {
         if (!IsValidDestinationString(params[3].get_str())) {
             throw JSONRPCError(RPC_WALLET_ERROR, "address_filter parameter was invalid");
         }
@@ -1161,6 +1293,15 @@ static UniValue ListReceived(CWallet * const pwallet, const UniValue& params, bo
         has_filtered_address = true;
     }
 
+    std::string strasset = "";
+    if (params.size() > 4 && params[4].isStr()) {
+        strasset = params[4].get_str();
+    }
+    CAsset asset;
+    if (!strasset.empty()) {
+        asset = GetAssetFromString(strasset);
+    }
+
     // Tally
     std::map<CTxDestination, tallyitem> mapTally;
     for (const std::pair<const uint256, CWalletTx>& pairWtx : pwallet->mapWallet) {
@@ -1173,8 +1314,10 @@ static UniValue ListReceived(CWallet * const pwallet, const UniValue& params, bo
         if (nDepth < nMinDepth)
             continue;
 
-        for (const CTxOut& txout : wtx.tx->vout)
+        for (size_t index = 0; index < wtx.tx->vout.size(); ++index)
         {
+            const CTxOut& txout = wtx.tx->vout[index];
+
             CTxDestination address;
             if (!ExtractDestination(txout.scriptPubKey, address))
                 continue;
@@ -1187,8 +1330,17 @@ static UniValue ListReceived(CWallet * const pwallet, const UniValue& params, bo
             if(!(mine & filter))
                 continue;
 
+            CAmount amt = wtx.GetOutputValueOut(index);
+            if (amt < 0) {
+                continue;
+            }
+
+            if (strasset != "" && wtx.GetOutputAsset(index) != asset) {
+                continue;
+            }
+
             tallyitem& item = mapTally[address];
-            item.nAmount += txout.nValue;
+            item.mapAmount[wtx.GetOutputAsset(index)] += amt;
             item.nConf = std::min(item.nConf, nDepth);
             item.txids.push_back(wtx.GetHash());
             if (mine & ISMINE_WATCH_ONLY)
@@ -1220,12 +1372,12 @@ static UniValue ListReceived(CWallet * const pwallet, const UniValue& params, bo
         if (it == mapTally.end() && !fIncludeEmpty)
             continue;
 
-        CAmount nAmount = 0;
+        CAmountMap mapAmount;
         int nConf = std::numeric_limits<int>::max();
         bool fIsWatchonly = false;
         if (it != mapTally.end())
         {
-            nAmount = (*it).second.nAmount;
+            mapAmount = (*it).second.mapAmount;
             nConf = (*it).second.nConf;
             fIsWatchonly = (*it).second.fIsWatchonly;
         }
@@ -1233,7 +1385,7 @@ static UniValue ListReceived(CWallet * const pwallet, const UniValue& params, bo
         if (by_label)
         {
             tallyitem& _item = label_tally[label];
-            _item.nAmount += nAmount;
+            _item.mapAmount += mapAmount;
             _item.nConf = std::min(_item.nConf, nConf);
             _item.fIsWatchonly = fIsWatchonly;
         }
@@ -1243,7 +1395,7 @@ static UniValue ListReceived(CWallet * const pwallet, const UniValue& params, bo
             if(fIsWatchonly)
                 obj.pushKV("involvesWatchonly", true);
             obj.pushKV("address",       EncodeDestination(address));
-            obj.pushKV("amount",        ValueFromAmount(nAmount));
+            obj.pushKV("amount",        AmountMapToUniv(mapAmount, ""));
             obj.pushKV("confirmations", (nConf == std::numeric_limits<int>::max() ? 0 : nConf));
             obj.pushKV("label", label);
             UniValue transactions(UniValue::VARR);
@@ -1263,12 +1415,12 @@ static UniValue ListReceived(CWallet * const pwallet, const UniValue& params, bo
     {
         for (const auto& entry : label_tally)
         {
-            CAmount nAmount = entry.second.nAmount;
+            CAmountMap mapAmount = entry.second.mapAmount;
             int nConf = entry.second.nConf;
             UniValue obj(UniValue::VOBJ);
             if (entry.second.fIsWatchonly)
                 obj.pushKV("involvesWatchonly", true);
-            obj.pushKV("amount",        ValueFromAmount(nAmount));
+            obj.pushKV("amount",        AmountMapToUniv(mapAmount, ""));
             obj.pushKV("confirmations", (nConf == std::numeric_limits<int>::max() ? 0 : nConf));
             obj.pushKV("label",         entry.first);
             ret.push_back(obj);
@@ -1287,7 +1439,7 @@ static UniValue listreceivedbyaddress(const JSONRPCRequest& request)
         return NullUniValue;
     }
 
-    if (request.fHelp || request.params.size() > 4)
+    if (request.fHelp || request.params.size() > 5)
         throw std::runtime_error(
             "listreceivedbyaddress ( minconf include_empty include_watchonly address_filter )\n"
             "\nList balances by receiving address.\n"
@@ -1296,6 +1448,7 @@ static UniValue listreceivedbyaddress(const JSONRPCRequest& request)
             "2. include_empty     (bool, optional, default=false) Whether to include addresses that haven't received any payments.\n"
             "3. include_watchonly (bool, optional, default=false) Whether to include watch-only addresses (see 'importaddress').\n"
             "4. address_filter    (string, optional) If present, only return information on this address.\n"
+            "5. assetlabel        (string, optional) The hex asset id or asset label to filter for.\n"
             "\nResult:\n"
             "[\n"
             "  {\n"
@@ -1411,6 +1564,11 @@ static void ListTransactions(CWallet* const pwallet, const CWalletTx& wtx, int n
             MaybePushAddress(entry, s.destination);
             entry.pushKV("category", "send");
             entry.pushKV("amount", ValueFromAmount(-s.amount));
+            if (g_con_elementsmode) {
+                entry.pushKV("amountblinder", s.amount_blinding_factor.GetHex());
+                entry.pushKV("asset", s.asset.GetHex());
+                entry.pushKV("assetblinder", s.asset_blinding_factor.GetHex());
+            }
             if (pwallet->mapAddressBook.count(s.destination)) {
                 entry.pushKV("label", pwallet->mapAddressBook[s.destination].name);
             }
@@ -1451,6 +1609,11 @@ static void ListTransactions(CWallet* const pwallet, const CWalletTx& wtx, int n
                 entry.pushKV("category", "receive");
             }
             entry.pushKV("amount", ValueFromAmount(r.amount));
+            if (g_con_elementsmode) {
+                entry.pushKV("amountblinder", r.amount_blinding_factor.GetHex());
+                entry.pushKV("asset", r.asset.GetHex());
+                entry.pushKV("assetblinder", r.asset_blinding_factor.GetHex());
+            }
             if (pwallet->mapAddressBook.count(r.destination)) {
                 entry.pushKV("label", label);
             }
@@ -1796,14 +1959,23 @@ static UniValue gettransaction(const JSONRPCRequest& request)
     }
     const CWalletTx& wtx = it->second;
 
-    CAmount nCredit = wtx.GetCredit(filter);
-    CAmount nDebit = wtx.GetDebit(filter);
-    CAmount nNet = nCredit - nDebit;
-    CAmount nFee = (wtx.IsFromMe(filter) ? wtx.tx->GetValueOut() - nDebit : 0);
+    CAmountMap nCredit = wtx.GetCredit(filter);
+    CAmountMap nDebit = wtx.GetDebit(filter);
+    CAmountMap nNet = nCredit - nDebit;
+    assert(HasValidFee(*wtx.tx));
+    CAmountMap nFee = wtx.IsFromMe(filter) ? CAmountMap() - GetFeeMap(*wtx.tx) : CAmountMap();
+    if (!g_con_elementsmode) {
+        CAmount total_out = 0;
+        for (const auto& output : wtx.tx->vout) {
+            total_out += output.nValue.GetAmount();
+        }
+        nFee = CAmountMap();
+        nFee[::policyAsset] = wtx.IsFromMe(filter) ? total_out - nDebit[::policyAsset] : 0;
+    }
 
-    entry.pushKV("amount", ValueFromAmount(nNet - nFee));
+    entry.pushKV("amount", AmountMapToUniv(nNet - nFee, ""));
     if (wtx.IsFromMe(filter))
-        entry.pushKV("fee", ValueFromAmount(nFee));
+        entry.pushKV("fee", AmountMapToUniv(nFee, ""));
 
     WalletTxToJSON(wtx, entry);
 
@@ -2441,9 +2613,9 @@ static UniValue getwalletinfo(const JSONRPCRequest& request)
     size_t kpExternalSize = pwallet->KeypoolCountExternalKeys();
     obj.pushKV("walletname", pwallet->GetName());
     obj.pushKV("walletversion", pwallet->GetVersion());
-    obj.pushKV("balance",       ValueFromAmount(pwallet->GetBalance()));
-    obj.pushKV("unconfirmed_balance", ValueFromAmount(pwallet->GetUnconfirmedBalance()));
-    obj.pushKV("immature_balance",    ValueFromAmount(pwallet->GetImmatureBalance()));
+    obj.pushKV("balance",       AmountMapToUniv(pwallet->GetBalance(), ""));
+    obj.pushKV("unconfirmed_balance", AmountMapToUniv(pwallet->GetUnconfirmedBalance(), ""));
+    obj.pushKV("immature_balance",    AmountMapToUniv(pwallet->GetImmatureBalance(), ""));
     obj.pushKV("txcount",       (int)pwallet->mapWallet.size());
     obj.pushKV("keypoololdest", pwallet->GetOldestKeyPoolTime());
     obj.pushKV("keypoolsize", (int64_t)kpExternalSize);
@@ -2718,6 +2890,7 @@ static UniValue listunspent(const JSONRPCRequest& request)
             "      \"maximumAmount\"    (numeric or string, default=unlimited) Maximum value of each UTXO in " + CURRENCY_UNIT + "\n"
             "      \"maximumCount\"     (numeric or string, default=unlimited) Maximum number of UTXOs\n"
             "      \"minimumSumAmount\" (numeric or string, default=unlimited) Minimum sum value of all UTXOs in " + CURRENCY_UNIT + "\n"
+            "      \"asset\"            (string, default="") Asset to filter outputs for.\n"
             "    }\n"
             "\nResult\n"
             "[                   (array of json object)\n"
@@ -2785,6 +2958,7 @@ static UniValue listunspent(const JSONRPCRequest& request)
     CAmount nMaximumAmount = MAX_MONEY;
     CAmount nMinimumSumAmount = MAX_MONEY;
     uint64_t nMaximumCount = 0;
+    std::string asset_str;
 
     if (!request.params[4].isNull()) {
         const UniValue& options = request.params[4].get_obj();
@@ -2800,6 +2974,14 @@ static UniValue listunspent(const JSONRPCRequest& request)
 
         if (options.exists("maximumCount"))
             nMaximumCount = options["maximumCount"].get_int64();
+
+        if (options.exists("asset"))
+            asset_str = options["asset"].get_str();
+    }
+
+    CAsset asset_filter;
+    if (!asset_str.empty()) {
+        asset_filter = GetAssetFromString(asset_str);
     }
 
     // Make sure the results are valid at least up to the most recent block
@@ -2810,19 +2992,33 @@ static UniValue listunspent(const JSONRPCRequest& request)
     std::vector<COutput> vecOutputs;
     {
         LOCK2(cs_main, pwallet->cs_wallet);
-        pwallet->AvailableCoins(vecOutputs, !include_unsafe, nullptr, nMinimumAmount, nMaximumAmount, nMinimumSumAmount, nMaximumCount, nMinDepth, nMaxDepth);
+        pwallet->AvailableCoins(vecOutputs, !include_unsafe, nullptr, nMinimumAmount, nMaximumAmount, nMinimumSumAmount, nMaximumCount, nMinDepth, nMaxDepth, asset_filter.IsNull() ? nullptr : &asset_filter);
     }
 
     LOCK(pwallet->cs_wallet);
 
     for (const COutput& out : vecOutputs) {
         CTxDestination address;
+        const CTxOut& tx_out = out.tx->tx->vout[out.i];
         const CScript& scriptPubKey = out.tx->tx->vout[out.i].scriptPubKey;
         bool fValidAddress = ExtractDestination(scriptPubKey, address);
 
         if (destinations.size() && (!fValidAddress || !destinations.count(address)))
             continue;
 
+        // Elements
+        CAmount amount = out.tx->GetOutputValueOut(out.i);
+        CAsset assetid = out.tx->GetOutputAsset(out.i);
+        // Only list known outputs that match optional filter
+        if (g_con_elementsmode && (amount < 0 || assetid.IsNull())) {
+            wallet->WalletLogPrintf("Unable to unblind output: %s:%d\n", out.tx->tx->GetHash().GetHex(), out.i);
+            continue;
+        }
+        if (!asset_str.empty() && asset_filter != assetid) {
+            continue;
+        }
+        //////////
+
         UniValue entry(UniValue::VOBJ);
         entry.pushKV("txid", out.tx->GetHash().GetHex());
         entry.pushKV("vout", out.i);
@@ -2836,7 +3032,7 @@ static UniValue listunspent(const JSONRPCRequest& request)
             }
 
             if (scriptPubKey.IsPayToScriptHash()) {
-                const CScriptID& hash = boost::get<CScriptID>(address);
+                const CScriptID hash(GetScriptForDestination(address));
                 CScript redeemScript;
                 if (pwallet->GetCScript(hash, redeemScript)) {
                     entry.pushKV("redeemScript", HexStr(redeemScript.begin(), redeemScript.end()));
@@ -2845,7 +3041,18 @@ static UniValue listunspent(const JSONRPCRequest& request)
         }
 
         entry.pushKV("scriptPubKey", HexStr(scriptPubKey.begin(), scriptPubKey.end()));
-        entry.pushKV("amount", ValueFromAmount(out.tx->tx->vout[out.i].nValue));
+        entry.pushKV("amount", ValueFromAmount(amount));
+        if (g_con_elementsmode) {
+            if (tx_out.nAsset.IsCommitment()) {
+                entry.pushKV("assetcommitment", HexStr(tx_out.nAsset.vchCommitment));
+            }
+            entry.pushKV("asset", assetid.GetHex());
+            if (tx_out.nValue.IsCommitment()) {
+                entry.pushKV("amountcommitment", HexStr(tx_out.nValue.vchCommitment));
+            }
+            entry.pushKV("amountblinder", out.tx->GetOutputAmountBlindingFactor(out.i).ToString());
+            entry.pushKV("assetblinder", out.tx->GetOutputAssetBlindingFactor(out.i).ToString());
+        }
         entry.pushKV("confirmations", out.nDepth);
         entry.pushKV("spendable", out.fSpendable);
         entry.pushKV("solvable", out.fSolvable);
@@ -2875,9 +3082,10 @@ void FundTransaction(CWallet* const pwallet, CMutableTransaction& tx, CAmount& f
       }
       else {
         RPCTypeCheckArgument(options, UniValue::VOBJ);
+
         RPCTypeCheckObj(options,
             {
-                {"changeAddress", UniValueType(UniValue::VSTR)},
+                {"changeAddress", UniValueType()}, // will be checked below
                 {"changePosition", UniValueType(UniValue::VNUM)},
                 {"change_type", UniValueType(UniValue::VSTR)},
                 {"includeWatching", UniValueType(UniValue::VBOOL)},
@@ -2891,13 +3099,38 @@ void FundTransaction(CWallet* const pwallet, CMutableTransaction& tx, CAmount& f
             true, true);
 
         if (options.exists("changeAddress")) {
-            CTxDestination dest = DecodeDestination(options["changeAddress"].get_str());
+            std::map<CAsset, CTxDestination> destinations;
 
-            if (!IsValidDestination(dest)) {
-                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "changeAddress must be a valid bitcoin address");
+            if (options["changeAddress"].isStr()) {
+                // Single destination for default asset (policyAsset).
+                CTxDestination dest = DecodeDestination(options["changeAddress"].get_str());
+                if (!IsValidDestination(dest)) {
+                    throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "changeAddress must be a valid bitcoin address");
+                }
+                destinations[::policyAsset] = dest;
+            } else if (options["changeAddress"].isObject()) {
+                // Map of assets to destinations.
+                std::map<std::string, UniValue> kvMap;
+                options["changeAddress"].getObjMap(kvMap);
+
+                for (const std::pair<std::string, UniValue>& kv : kvMap) {
+                    CAsset asset = GetAssetFromString(kv.first);
+                    if (asset.IsNull()) {
+                        throw JSONRPCError(RPC_INVALID_PARAMETER, "changeAddress key must be a valid asset label or hex");
+                    }
+
+                    CTxDestination dest = DecodeDestination(kv.second.get_str());
+                    if (!IsValidDestination(dest)) {
+                        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "changeAddress must be a valid bitcoin address");
+                    }
+
+                    destinations[asset] = dest;
+                }
+            } else {
+                throw JSONRPCError(RPC_INVALID_PARAMETER, "changeAddress must be either a map or a string");
             }
 
-            coinControl.destChange = dest;
+            coinControl.destChange = destinations;
         }
 
         if (options.exists("changePosition"))
@@ -2998,7 +3231,7 @@ static UniValue fundrawtransaction(const JSONRPCRequest& request)
                             "1. \"hexstring\"           (string, required) The hex string of the raw transaction\n"
                             "2. options                 (object, optional)\n"
                             "   {\n"
-                            "     \"changeAddress\"          (string, optional, default pool address) The bitcoin address to receive the change\n"
+                            "     \"changeAddress\"          (string/object, optional, default pool address) The bitcoin address to receive the change or a map from asset to address\n"
                             "     \"changePosition\"         (numeric, optional, default random) The index of the change output\n"
                             "     \"change_type\"            (string, optional) The output type to use. Only valid if changeAddress is not specified. Options are \"legacy\", \"p2sh-segwit\", and \"bech32\". Default is set by -changetype.\n"
                             "     \"includeWatching\"        (boolean, optional, default false) Also select inputs which are watch only\n"
@@ -3087,7 +3320,8 @@ UniValue signrawtransactionwithwallet(const JSONRPCRequest& request)
             "         \"vout\":n,                  (numeric, required) The output number\n"
             "         \"scriptPubKey\": \"hex\",     (string, required) script key\n"
             "         \"redeemScript\": \"hex\",     (string, required for P2SH or P2WSH) redeem script\n"
-            "         \"amount\": value            (numeric, required) The amount spent\n"
+            "         \"amount\": value            (numeric, required if non-confidential segwit output) The amount spent\n"
+            "         \"amountcommitment\": \"hex\", (string, required if confidential segiwt output) The amount commitment spent\n"
             "       }\n"
             "       ,...\n"
             "    ]\n"
@@ -3525,7 +3759,7 @@ class DescribeWalletAddressVisitor : public boost::static_visitor<UniValue>
             UniValue pubkeys(UniValue::VARR);
             for (size_t i = 1; i < solutions_data.size() - 1; ++i) {
                 CPubKey key(solutions_data[i].begin(), solutions_data[i].end());
-                if (include_addresses) a.push_back(EncodeDestination(key.GetID()));
+                if (include_addresses) a.push_back(EncodeDestination(PKHash(key)));
                 pubkeys.push_back(HexStr(key.begin(), key.end()));
             }
             obj.pushKV("pubkeys", std::move(pubkeys));
@@ -3542,8 +3776,9 @@ class DescribeWalletAddressVisitor : public boost::static_visitor<UniValue>
 
     UniValue operator()(const CNoDestination& dest) const { return UniValue(UniValue::VOBJ); }
 
-    UniValue operator()(const CKeyID& keyID) const
+    UniValue operator()(const PKHash& pkhash) const
     {
+        CKeyID keyID(pkhash);
         UniValue obj(UniValue::VOBJ);
         CPubKey vchPubKey;
         if (pwallet && pwallet->GetPubKey(keyID, vchPubKey)) {
@@ -3553,8 +3788,9 @@ class DescribeWalletAddressVisitor : public boost::static_visitor<UniValue>
         return obj;
     }
 
-    UniValue operator()(const CScriptID& scriptID) const
+    UniValue operator()(const ScriptHash& scripthash) const
     {
+        CScriptID scriptID(scripthash);
         UniValue obj(UniValue::VOBJ);
         CScript subscript;
         if (pwallet && pwallet->GetCScript(scriptID, subscript)) {
@@ -3599,6 +3835,83 @@ static UniValue DescribeWalletAddress(CWallet* pwallet, const CTxDestination& de
     return ret;
 }
 
+class DescribeWalletBlindAddressVisitor : public boost::static_visitor<UniValue>
+{
+public:
+    CWallet * const pwallet;
+    isminetype mine;
+
+    explicit DescribeWalletBlindAddressVisitor(CWallet* _pwallet, isminetype mine_in) : pwallet(_pwallet), mine(mine_in) {}
+
+    UniValue operator()(const CNoDestination& dest) const { return UniValue(UniValue::VOBJ); }
+
+    UniValue operator()(const PKHash& pkhash) const
+    {
+        UniValue obj(UniValue::VOBJ);
+        if (!IsBlindDestination(pkhash) && mine != ISMINE_NO) {
+            CPubKey blind_pub = pwallet->GetBlindingPubKey(GetScriptForDestination(pkhash));
+            PKHash dest(pkhash);
+            dest.blinding_pubkey = blind_pub;
+            obj.pushKV("confidential", EncodeDestination(dest));
+        } else {
+            obj.pushKV("confidential", EncodeDestination(pkhash));
+        }
+        return obj;
+    }
+
+    UniValue operator()(const ScriptHash& scripthash) const
+    {
+        UniValue obj(UniValue::VOBJ);
+        if (!IsBlindDestination(scripthash) && mine != ISMINE_NO) {
+            CPubKey blind_pub = pwallet->GetBlindingPubKey(GetScriptForDestination(scripthash));
+            ScriptHash dest(scripthash);
+            dest.blinding_pubkey = blind_pub;
+            obj.pushKV("confidential", EncodeDestination(dest));
+        } else {
+            obj.pushKV("confidential", EncodeDestination(scripthash));
+        }
+        return obj;
+    }
+
+    UniValue operator()(const WitnessV0KeyHash& id) const
+    {
+        UniValue obj(UniValue::VOBJ);
+        if (!IsBlindDestination(id) && mine != ISMINE_NO) {
+            CPubKey blind_pub = pwallet->GetBlindingPubKey(GetScriptForDestination(id));
+            WitnessV0KeyHash dest(id);
+            dest.blinding_pubkey = blind_pub;
+            obj.pushKV("confidential", EncodeDestination(dest));
+        } else {
+            obj.pushKV("confidential", EncodeDestination(id));
+        }
+        return obj;
+    }
+
+    UniValue operator()(const WitnessV0ScriptHash& id) const
+    {
+        UniValue obj(UniValue::VOBJ);
+        if (!IsBlindDestination(id) && mine != ISMINE_NO) {
+            CPubKey blind_pub = pwallet->GetBlindingPubKey(GetScriptForDestination(id));
+            WitnessV0ScriptHash dest(id);
+            dest.blinding_pubkey = blind_pub;
+            obj.pushKV("confidential", EncodeDestination(dest));
+        } else {
+            obj.pushKV("confidential", EncodeDestination(id));
+        }
+        return obj;
+    }
+
+    UniValue operator()(const WitnessUnknown& id) const { return UniValue(UniValue::VOBJ); }
+    UniValue operator()(const NullData& id) const { return NullUniValue; }
+};
+
+static UniValue DescribeWalletBlindAddress(CWallet* pwallet, const CTxDestination& dest, isminetype mine)
+{
+    UniValue ret(UniValue::VOBJ);
+    ret.pushKVs(boost::apply_visitor(DescribeWalletBlindAddressVisitor(pwallet, mine), dest));
+    return ret;
+}
+
 /** Convert CAddressBookData to JSON record.  */
 static UniValue AddressBookDataToJSON(const CAddressBookData& data, const bool verbose)
 {
@@ -3647,6 +3960,9 @@ UniValue getaddressinfo(const JSONRPCRequest& request)
             "  \"pubkey\" : \"publickeyhex\",    (string, optional) The hex value of the raw public key, for single-key addresses (possibly embedded in P2SH or P2WSH)\n"
             "  \"embedded\" : {...},           (object, optional) Information about the address embedded in P2SH or P2WSH, if relevant and known. It includes all getaddressinfo output fields for the embedded address, excluding metadata (\"timestamp\", \"hdkeypath\", \"hdseedid\") and relation to the wallet (\"ismine\", \"iswatchonly\").\n"
             "  \"iscompressed\" : true|false,  (boolean) If the address is compressed\n"
+            "  \"confidential_key\" : \"hex\", (string) The hex value of the raw blinding public key for that address, if any. \"\" if none.\n"
+            "  \"unconfidential\" : \"address\", (string) The address without confidentiality key.\n"
+            "  \"confidential\" : \"address\", (string) The address with wallet-stored confidentiality key if known. Only displayed for non-confidential address inputs.\n"
             "  \"label\" :  \"label\"         (string) The label associated with the address, \"\" is the default label\n"
             "  \"timestamp\" : timestamp,      (number, optional) The creation time of the key if available in seconds since epoch (Jan 1 1970 GMT)\n"
             "  \"hdkeypath\" : \"keypath\"       (string, optional) The HD keypath if the key is HD and available\n"
@@ -3683,10 +3999,20 @@ UniValue getaddressinfo(const JSONRPCRequest& request)
     ret.pushKV("scriptPubKey", HexStr(scriptPubKey.begin(), scriptPubKey.end()));
 
     isminetype mine = IsMine(*pwallet, dest);
+    // Elements: Addresses we can not unblind outputs for aren't spendable
+    if (IsBlindDestination(dest) &&
+            GetDestinationBlindingKey(dest) != pwallet->GetBlindingPubKey(GetScriptForDestination(dest))) {
+        mine = ISMINE_NO;
+    }
     ret.pushKV("ismine", bool(mine & ISMINE_SPENDABLE));
     ret.pushKV("iswatchonly", bool(mine & ISMINE_WATCH_ONLY));
     UniValue detail = DescribeWalletAddress(pwallet, dest);
     ret.pushKVs(detail);
+    // Elements blinding info
+    UniValue blind_detail = DescribeWalletBlindAddress(pwallet, dest, mine);
+    ret.pushKVs(blind_detail);
+    blind_detail = DescribeBlindAddress(dest);
+    ret.pushKVs(blind_detail);
     if (pwallet->mapAddressBook.count(dest)) {
         ret.pushKV("label", pwallet->mapAddressBook[dest].name);
     }
@@ -3946,7 +4272,7 @@ bool FillPSBT(const CWallet* pwallet, PartiallySignedTransaction& psbtx, const C
         SignatureData sigdata;
         psbt_out.FillSignatureData(sigdata);
 
-        MutableTransactionSignatureCreator creator(psbtx.tx.get_ptr(), 0, out.nValue, 1);
+        MutableTransactionSignatureCreator creator(psbtx.tx.get_ptr(), 0, out.nValue.GetAmount(), 1);
         ProduceSignature(HidingSigningProvider(pwallet, true, !bip32derivs), creator, out.scriptPubKey, sigdata);
         psbt_out.FromSignatureData(sigdata);
     }
@@ -4104,7 +4430,7 @@ UniValue walletcreatefundedpsbt(const JSONRPCRequest& request)
 
     CAmount fee;
     int change_position;
-    CMutableTransaction rawTx = ConstructTransaction(request.params[0], request.params[1], request.params[2], request.params[3]["replaceable"]);
+    CMutableTransaction rawTx = ConstructTransaction(request.params[0], request.params[1], request.params[2], request.params[3]["replaceable"], NullUniValue /* CA: assets_in */);
     FundTransaction(pwallet, rawTx, fee, change_position, request.params[3]);
 
     // Make a blank psbt
@@ -4179,8 +4505,6 @@ UniValue getpeginaddress(const JSONRPCRequest& request)
 
     //Creates new address for receiving unlocked utxos
     JSONRPCRequest req;
-    //TODO(rebase) replace with CT/CA
-    //CTxDestination dest(DecodeDestination(getnewaddress(req).get_str()).GetUnblinded());
     CTxDestination address = DecodeDestination(getnewaddress(req).get_str());
 
     Witnessifier w(pwallet);
@@ -4199,7 +4523,7 @@ UniValue getpeginaddress(const JSONRPCRequest& request)
     pwallet->AddCScript(destScript);
 
     //Call contracthashtool, get deposit address on mainchain.
-    CTxDestination destAddr(CScriptID(GetScriptForWitness(calculate_contract(Params().GetConsensus().fedpegScript, witProg))));
+    CTxDestination destAddr(ScriptHash(GetScriptForWitness(calculate_contract(Params().GetConsensus().fedpegScript, witProg))));
 
     UniValue fundinginfo(UniValue::VOBJ);
 
@@ -4293,8 +4617,6 @@ UniValue initpegoutwallet(const JSONRPCRequest& request)
         }
     }
 
-    CKeyID online_key_id = online_pubkey.GetID();
-
     // Parse offline counter
     int counter = 0;
     if (request.params.size() > 1) {
@@ -4389,7 +4711,7 @@ UniValue initpegoutwallet(const JSONRPCRequest& request)
     UniValue pak(UniValue::VOBJ);
     pak.pushKV("pakentry", "pak=" + HexStr(negatedpubkeybytes) + ":" + HexStr(online_pubkey));
     pak.pushKV("liquid_pak", HexStr(online_pubkey));
-    pak.pushKV("liquid_pak_address", EncodeDestination(online_key_id));
+    pak.pushKV("liquid_pak_address", EncodeDestination(PKHash(online_pubkey)));
     pak.pushKV("address_lookahead", address_list);
     return pak;
 }
@@ -4450,11 +4772,7 @@ UniValue sendtomainchain_base(const JSONRPCRequest& request)
 
     mapValue_t mapValue;
     CCoinControl no_coin_control; // This is a deprecated API
-    CTransactionRef tx = SendMoney(pwallet, address, nAmount, subtract_fee, no_coin_control, std::move(mapValue));
-
-    //TODO(rebase) CT/CA
-    //  v this line was in elements-0.14 instead of the line above here
-    ////SendMoney(scriptPubKey, nAmount, Params().GetConsensus().pegged_asset, subtract_fee, CPubKey(), wtxNew, true);
+    CTransactionRef tx = SendMoney(pwallet, address, nAmount, Params().GetConsensus().pegged_asset, subtract_fee, no_coin_control, std::move(mapValue), true /* ignore_blind_fail */);
 
     return (*tx).GetHash().GetHex();
 
@@ -4603,9 +4921,10 @@ UniValue sendtomainchain_pak(const JSONRPCRequest& request)
     int whitelistindex=-1;
     std::vector<secp256k1_pubkey> pak_online = paklist.OnlineKeys();
     for (unsigned int i=0; i<pak_online.size(); i++) {
-        if (memcmp((void *)&pak_online[i], (void *)&onlinepubkey_secp, sizeof(secp256k1_pubkey)) == 0)
+        if (memcmp((void *)&pak_online[i], (void *)&onlinepubkey_secp, sizeof(secp256k1_pubkey)) == 0) {
             whitelistindex = i;
             break;
+        }
     }
     if (whitelistindex == -1)
         throw JSONRPCError(RPC_WALLET_ERROR, "Given online key is not in Pegout Authorization Key List");
@@ -4695,7 +5014,7 @@ UniValue sendtomainchain_pak(const JSONRPCRequest& request)
 
     mapValue_t mapValue;
     CCoinControl no_coin_control; // This is a deprecated API
-    CTransactionRef tx = SendMoney(pwallet, address, nAmount, subtract_fee, no_coin_control, std::move(mapValue));
+    CTransactionRef tx = SendMoney(pwallet, address, nAmount, Params().GetConsensus().pegged_asset, subtract_fee, no_coin_control, std::move(mapValue), true /* ignore_blind_fail */);
 
     pwallet->SetOfflineCounter(counter+1);
 
@@ -4728,7 +5047,7 @@ unsigned int GetPeginTxnOutputIndex(const T_tx& txn, const CScript& witnessProgr
 {
     unsigned int nOut = 0;
     //Call contracthashtool
-    CScript mainchain_script = GetScriptForDestination(CScriptID(GetScriptForWitness(calculate_contract(Params().GetConsensus().fedpegScript, witnessProgram))));
+    CScript mainchain_script = GetScriptForDestination(ScriptHash(GetScriptForWitness(calculate_contract(Params().GetConsensus().fedpegScript, witnessProgram))));
     for (; nOut < txn.vout.size(); nOut++)
         if (txn.vout[nOut].scriptPubKey == mainchain_script)
             break;
@@ -4843,8 +5162,7 @@ static UniValue createrawpegin(const JSONRPCRequest& request, T_tx_ref& txBTCRef
 
     CAmount value = 0;
     if (!GetAmountFromParentChainPegin(value, txBTC, nOut)) {
-        //TODO(rebase) CT/CA
-        //throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Amounts to pegin must be explicit and asset must be %s", Params().GetConsensus().parent_pegged_asset.GetHex()));
+        throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Amounts to pegin must be explicit and asset must be %s", Params().GetConsensus().parent_pegged_asset.GetHex()));
     }
 
     CDataStream stream(0, 0);
@@ -4871,28 +5189,23 @@ static UniValue createrawpegin(const JSONRPCRequest& request, T_tx_ref& txBTCRef
     CPubKey newKey;
     if (!pwallet->GetKeyFromPool(newKey))
         throw JSONRPCError(RPC_WALLET_KEYPOOL_RAN_OUT, "Error: Keypool ran out, please call keypoolrefill first");
-    CKeyID keyID = newKey.GetID();
+    PKHash pkhash(newKey);
 
-    pwallet->SetAddressBook(keyID, "", "receive");
+    pwallet->SetAddressBook(pkhash, "", "receive");
 
     // One peg-in input, one wallet output and one fee output
     CMutableTransaction mtx;
     mtx.vin.push_back(CTxIn(COutPoint(txHashes[0], nOut), CScript(), ~(uint32_t)0));
     // mark as peg-in input
     mtx.vin[0].m_is_pegin = true;
-    //TODO(rebase) CA
-    //mtx.vout.push_back(CTxOut(Params().GetConsensus().pegged_asset, value, GetScriptForDestination(CTxDestination(keyID))));
-    //mtx.vout.push_back(CTxOut(Params().GetConsensus().pegged_asset, 0, CScript()));
-    mtx.vout.push_back(CTxOut(value, GetScriptForDestination(CTxDestination(keyID))));
+    mtx.vout.push_back(CTxOut(Params().GetConsensus().pegged_asset, value, GetScriptForDestination(pkhash)));
+    mtx.vout.push_back(CTxOut(Params().GetConsensus().pegged_asset, 0, CScript()));
 
     // Construct pegin proof
     CScriptWitness pegin_witness;
     std::vector<std::vector<unsigned char> >& stack = pegin_witness.stack;
     stack.push_back(value_bytes);
-    //TODO(rebase) CA
-    std::vector<unsigned char> empty(32);
-    stack.push_back(empty);
-    //stack.push_back(std::vector<unsigned char>(Params().GetConsensus().pegged_asset.begin(), Params().GetConsensus().pegged_asset.end()));
+    stack.push_back(std::vector<unsigned char>(Params().GetConsensus().pegged_asset.begin(), Params().GetConsensus().pegged_asset.end()));
     stack.push_back(std::vector<unsigned char>(genesisBlockHash.begin(), genesisBlockHash.end()));
     stack.push_back(std::vector<unsigned char>(witnessProgScript.begin(), witnessProgScript.end()));
     stack.push_back(txData);
@@ -4916,10 +5229,8 @@ static UniValue createrawpegin(const JSONRPCRequest& request, T_tx_ref& txBTCRef
     CCoinControl coin_control;
     CAmount nFeeNeeded = GetMinimumFee(*pwallet, nBytes, coin_control, mempool, ::feeEstimator, nullptr);
 
-    //TODO(rebase) CT
-    //mtx.vout[0].nValue = mtx.vout[0].nValue.GetAmount() - nFeeNeeded;
-    //mtx.vout[1].nValue = mtx.vout[1].nValue.GetAmount() + nFeeNeeded;
-    mtx.vout[0].nValue = mtx.vout[0].nValue - nFeeNeeded;
+    mtx.vout[0].nValue = mtx.vout[0].nValue.GetAmount() - nFeeNeeded;
+    mtx.vout[1].nValue = mtx.vout[1].nValue.GetAmount() + nFeeNeeded;
 
     UniValue ret(UniValue::VOBJ);
 
@@ -5011,8 +5322,9 @@ UniValue claimpegin(const JSONRPCRequest& request)
     // Send it
     CValidationState state;
     mapValue_t mapValue;
-    CReserveKey reservekey(pwallet);
-    if (!pwallet->CommitTransaction(MakeTransactionRef(mtx), mapValue, {} /* orderForm */, reservekey, g_connman.get(), state)) {
+    std::vector<std::unique_ptr<CReserveKey>> reservekeys;
+    reservekeys.push_back(std::unique_ptr<CReserveKey>(new CReserveKey(pwallet)));
+    if (!pwallet->CommitTransaction(MakeTransactionRef(mtx), mapValue, {} /* orderForm */, reservekeys, g_connman.get(), state)) {
         std::string strError = strprintf("Error: The transaction was rejected! Reason given: %s", FormatStateMessage(state));
         throw JSONRPCError(RPC_WALLET_ERROR, strError);
     }
@@ -5020,11 +5332,710 @@ UniValue claimpegin(const JSONRPCRequest& request)
     return mtx.GetHash().GetHex();
 }
 
+// Rewind the outputs to unblinded, and push placeholders for blinding info. Not exported.
+void FillBlinds(CWallet* pwallet, CMutableTransaction& tx, std::vector<uint256>& output_value_blinds, std::vector<uint256>& output_asset_blinds, std::vector<CPubKey>& output_pubkeys, std::vector<CKey>& asset_keys, std::vector<CKey>& token_keys) {
+
+    // Resize witness before doing anything
+    tx.witness.vtxinwit.resize(tx.vin.size());
+    tx.witness.vtxoutwit.resize(tx.vout.size());
+
+    for (size_t nOut = 0; nOut < tx.vout.size(); ++nOut) {
+        CTxOut& out = tx.vout[nOut];
+        if (out.nValue.IsExplicit()) {
+            CPubKey pubkey(out.nNonce.vchCommitment);
+            if (!pubkey.IsFullyValid()) {
+                output_pubkeys.push_back(CPubKey());
+            } else {
+                output_pubkeys.push_back(pubkey);
+            }
+            output_value_blinds.push_back(uint256());
+            output_asset_blinds.push_back(uint256());
+        } else if (out.nValue.IsCommitment()) {
+            CTxOutWitness* ptxoutwit = &tx.witness.vtxoutwit[nOut];
+            uint256 blinding_factor;
+            uint256 asset_blinding_factor;
+            CAsset asset;
+            CAmount amount;
+            // This can only be used to recover things like change addresses and self-sends.
+            if (UnblindConfidentialPair(pwallet->GetBlindingKey(&out.scriptPubKey), out.nValue, out.nAsset, out.nNonce, out.scriptPubKey, ptxoutwit->vchRangeproof, amount, blinding_factor, asset, asset_blinding_factor) != 0) {
+                // Wipe out confidential info from output and output witness
+                CScript scriptPubKey = tx.vout[nOut].scriptPubKey;
+                CTxOut newOut(asset, amount, scriptPubKey);
+                tx.vout[nOut] = newOut;
+                ptxoutwit->SetNull();
+
+                // Mark for re-blinding with same key that deblinded it
+                CPubKey pubkey(pwallet->GetBlindingKey(&out.scriptPubKey).GetPubKey());
+                output_pubkeys.push_back(pubkey);
+                output_value_blinds.push_back(uint256());
+                output_asset_blinds.push_back(uint256());
+            } else {
+                output_pubkeys.push_back(CPubKey());
+                output_value_blinds.push_back(uint256());
+                output_asset_blinds.push_back(uint256());
+            }
+        } else {
+            // Null or invalid, do nothing for that output
+            output_pubkeys.push_back(CPubKey());
+            output_value_blinds.push_back(uint256());
+            output_asset_blinds.push_back(uint256());
+        }
+    }
+
+    // Fill out issuance blinding keys to be used directly as nonce for rangeproof
+    for (size_t nIn = 0; nIn < tx.vin.size(); ++nIn) {
+        CAssetIssuance& issuance = tx.vin[nIn].assetIssuance;
+        if (issuance.IsNull()) {
+            asset_keys.push_back(CKey());
+            token_keys.push_back(CKey());
+            continue;
+        }
+
+        // Calculate underlying asset for use as blinding key script
+        CAsset asset;
+        // New issuance, compute the asset ids
+        if (issuance.assetBlindingNonce.IsNull()) {
+            uint256 entropy;
+            GenerateAssetEntropy(entropy, tx.vin[nIn].prevout, issuance.assetEntropy);
+            CalculateAsset(asset, entropy);
+        }
+        // Re-issuance
+        else {
+            // TODO Give option to skip blinding when the reissuance token was derived without blinding ability. For now we assume blinded
+            // hashAssetIdentifier doubles as the entropy on reissuance
+            CalculateAsset(asset, issuance.assetEntropy);
+        }
+
+        // Special format for issuance blinding keys, unique for each transaction
+        CScript blindingScript = CScript() << OP_RETURN << std::vector<unsigned char>(tx.vin[nIn].prevout.hash.begin(), tx.vin[nIn].prevout.hash.end()) << tx.vin[nIn].prevout.n;
+
+        for (size_t nPseudo = 0; nPseudo < 2; nPseudo++) {
+            bool issuance_asset = (nPseudo == 0);
+            std::vector<CKey>& issuance_blinding_keys = issuance_asset ? asset_keys : token_keys;
+            CConfidentialValue& conf_value = issuance_asset ? issuance.nAmount : issuance.nInflationKeys;
+            if (conf_value.IsCommitment()) {
+                // Rangeproof must exist
+                if (tx.witness.vtxinwit.size() <= nIn) {
+                    throw JSONRPCError(RPC_INVALID_PARAMETER, "Transaction issuance is already blinded but has no attached rangeproof.");
+                }
+                CTxInWitness& txinwit = tx.witness.vtxinwit[nIn];
+                std::vector<unsigned char>& vchRangeproof = issuance_asset ? txinwit.vchIssuanceAmountRangeproof : txinwit.vchInflationKeysRangeproof;
+                uint256 blinding_factor;
+                uint256 asset_blinding_factor;
+                CAmount amount;
+                if (UnblindConfidentialPair(pwallet->GetBlindingKey(&blindingScript), conf_value, CConfidentialAsset(asset), CConfidentialNonce(), CScript(), vchRangeproof, amount, blinding_factor, asset, asset_blinding_factor) != 0) {
+                    // Wipe out confidential info from issuance
+                    vchRangeproof.clear();
+                    conf_value = CConfidentialValue(amount);
+                    // One key blinds both values, single key needed for issuance reveal
+                    issuance_blinding_keys.push_back(pwallet->GetBlindingKey(&blindingScript));
+                } else {
+                    // If  unable to unblind, leave it alone in next blinding step
+                    issuance_blinding_keys.push_back(CKey());
+                }
+            } else if (conf_value.IsExplicit()) {
+                // Use wallet to generate blindingkey used directly as nonce
+                // as user is not "sending" to anyone.
+                // Always assumed we want to blind here.
+                // TODO Signal intent for all blinding via API including replacing nonce commitment
+                issuance_blinding_keys.push_back(pwallet->GetBlindingKey(&blindingScript));
+            } else  {
+                // Null or invalid, don't try anything but append an empty key
+                issuance_blinding_keys.push_back(CKey());
+            }
+        }
+    }
+}
+
+UniValue blindrawtransaction(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() > 5))
+        throw std::runtime_error(
+            "blindrawtransaction \"hexstring\" ( ignoreblindfail [\"asset_commitment,...\"] blind_issuances \"totalblinder\" )\n"
+            "\nConvert one or more outputs of a raw transaction into confidential ones using only wallet inputs.\n"
+            "Returns the hex-encoded raw transaction.\n"
+            "The output keys used can be specified by using a confidential address in createrawtransaction.\n"
+            "This call may add an additional 0-value unspendable output in order to balance the blinders.\n"
+
+            "\nArguments:\n"
+            "1. \"hexstring\",          (string, required) A hex-encoded raw transaction.\n"
+            "2. \"ignoreblindfail\"\"   (bool, optional, default=true) Return a transaction even when a blinding attempt fails due to number of blinded inputs/outputs.\n"
+            "3. \"asset_commitments\" \n"
+            "   [                       (array, optional) An array of input asset generators. If provided, this list must be empty, or match the final input commitment list, including ordering, to make a valid surjection proof. This list does not include generators for issuances, as these assets are inherently unblinded.\n"
+            "    \"assetcommitment\"   (string, optional) A hex-encoded asset commitment, one for each input.\n"
+            "                        Null commitments must be \"\".\n"
+            "   ],\n"
+            "4. \"blind_issuances\"     (bool, optional, default=true) Blind the issuances found in the raw transaction or not. All issuances will be blinded if true. \n"
+            "5. \"totalblinder\"        (string, optional) Ignored for now.\n"
+
+            "\nResult:\n"
+            "\"transaction\"              (string) hex string of the transaction\n"
+        );
+
+    std::vector<unsigned char> txData(ParseHexV(request.params[0], "argument 1"));
+    CDataStream ssData(txData, SER_NETWORK, PROTOCOL_VERSION);
+    CMutableTransaction tx;
+    try {
+        ssData >> tx;
+    } catch (const std::exception &) {
+        throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
+    }
+
+    bool ignore_blind_fail = true;
+    if (request.params.size() > 1) {
+        ignore_blind_fail = request.params[1].get_bool();
+    }
+
+    std::vector<std::vector<unsigned char> > auxiliary_generators;
+    if (request.params.size() > 2) {
+        UniValue assetCommitments = request.params[2].get_array();
+        if (assetCommitments.size() != 0 && assetCommitments.size() != tx.vin.size()) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "Asset commitment array must have exactly as many entries as transaction inputs.");
+        }
+        for (size_t nIn = 0; nIn < assetCommitments.size(); nIn++) {
+            if (assetCommitments[nIn].isStr()) {
+                std::string assetcommitment = assetCommitments[nIn].get_str();
+                if (IsHex(assetcommitment) && assetcommitment.size() == 66) {
+                    auxiliary_generators.push_back(ParseHex(assetcommitment));
+                    continue;
+                }
+            }
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "Asset commitments must be a hex encoded string of length 66.");
+        }
+    }
+
+    bool blind_issuances = request.params[3].isNull() || request.params[3].get_bool();
+
+    LOCK(pwallet->cs_wallet);
+
+    std::vector<uint256> input_blinds;
+    std::vector<uint256> input_asset_blinds;
+    std::vector<CAsset> input_assets;
+    std::vector<CAmount> input_amounts;
+    int n_blinded_ins = 0;
+    for (size_t nIn = 0; nIn < tx.vin.size(); ++nIn) {
+        COutPoint prevout = tx.vin[nIn].prevout;
+
+        std::map<uint256, CWalletTx>::iterator it = pwallet->mapWallet.find(prevout.hash);
+        if (it == pwallet->mapWallet.end()) {
+            // For inputs we don't own input assetcommitments for the surjection must be supplied
+            if (auxiliary_generators.size() > 0) {
+                input_blinds.push_back(uint256());
+                input_asset_blinds.push_back(uint256());
+                input_assets.push_back(CAsset());
+                input_amounts.push_back(-1);
+                continue;
+            }
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter: transaction spends from non-wallet output and no assetcommitment list was given.");
+        }
+
+        if (prevout.n >= it->second.tx->vout.size()) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter: transaction spends non-existing output");
+        }
+        input_blinds.push_back(it->second.GetOutputAmountBlindingFactor(prevout.n));
+        input_asset_blinds.push_back(it->second.GetOutputAssetBlindingFactor(prevout.n));
+        input_assets.push_back(it->second.GetOutputAsset(prevout.n));
+        input_amounts.push_back(it->second.GetOutputValueOut(prevout.n));
+        if (it->second.tx->vout[prevout.n].nValue.IsCommitment()) {
+            n_blinded_ins += 1;
+        }
+    }
+
+    std::vector<uint256> output_blinds;
+    std::vector<uint256> output_asset_blinds;
+    std::vector<CPubKey> output_pubkeys;
+    std::vector<CKey> asset_keys;
+    std::vector<CKey> token_keys;
+    // This fills out issuance blinding data for you from the wallet itself
+    FillBlinds(pwallet, tx, output_blinds, output_asset_blinds, output_pubkeys, asset_keys, token_keys);
+
+    if (!blind_issuances) {
+        asset_keys.clear();
+        token_keys.clear();
+    }
+
+    // How many are we trying to blind?
+    int num_pubkeys = 0;
+    unsigned int key_index = 0;
+    for (unsigned int i = 0; i < output_pubkeys.size(); i++) {
+        const CPubKey& key = output_pubkeys[i];
+        if (key.IsValid()) {
+            num_pubkeys++;
+            key_index = i;
+        }
+    }
+    for (const CKey& key : asset_keys) {
+        if (key.IsValid()) num_pubkeys++;
+    }
+    for (const CKey& key : token_keys) {
+        if (key.IsValid()) num_pubkeys++;
+    }
+
+    if (num_pubkeys == 0 && n_blinded_ins == 0) {
+        // Vacuous, just return the transaction
+        return EncodeHexTx(tx);
+    } else if (n_blinded_ins > 0 && num_pubkeys == 0) {
+        // Blinded inputs need to balanced with something to be valid, make a dummy.
+        CTxOut newTxOut(tx.vout.back().nAsset.GetAsset(), 0, CScript() << OP_RETURN);
+        tx.vout.push_back(newTxOut);
+        num_pubkeys++;
+        output_pubkeys.push_back(pwallet->GetBlindingPubKey(newTxOut.scriptPubKey));
+    } else if (n_blinded_ins == 0 && num_pubkeys == 1) {
+        if (ignore_blind_fail) {
+            // Just get rid of the ECDH key in the nonce field and return
+            tx.vout[key_index].nNonce.SetNull();
+            return EncodeHexTx(tx);
+        } else {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "Unable to blind transaction: Add another output to blind in order to complete the blinding.");
+        }
+    }
+
+    if (BlindTransaction(input_blinds, input_asset_blinds, input_assets, input_amounts, output_blinds, output_asset_blinds, output_pubkeys, asset_keys, token_keys, tx, (auxiliary_generators.size() ? &auxiliary_generators : NULL)) != num_pubkeys) {
+        // TODO Have more rich return values, communicating to user what has been blinded
+        // User may be ok not blinding something that for instance has no corresponding type on input
+        throw JSONRPCError(RPC_INVALID_PARAMETER, "Unable to blind transaction: Are you sure each asset type to blind is represented in the inputs?");
+    }
+
+    return EncodeHexTx(tx);
+}
+
+static UniValue unblindrawtransaction(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(
+            "unblindrawtransaction \"hex\"\n"
+            "\nRecovers unblinded transaction outputs from blinded outputs and issuance inputs when possible using wallet's known blinding keys, and strips related witness data.\n"
+            "\nArguments:\n"
+            "1. \"hex\"           (string, required) The hex string of the raw transaction\n"
+            "\nResult:\n"
+                                       "{\n"
+            "  \"hex\":       \"value\", (string)  The resulting unblinded raw transaction (hex-encoded string)\n"
+                                       "}\n"
+            "\nExamples:\n"
+            + HelpExampleCli("unblindrawtransaction", "\"blindedtransactionhex\"")
+        );
+
+    RPCTypeCheck(request.params, {UniValue::VSTR});
+
+    CMutableTransaction tx;
+    if (!DecodeHexTx(tx, request.params[0].get_str()))
+        throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");
+
+    std::vector<uint256> output_value_blinds;
+    std::vector<uint256> output_asset_blinds;
+    std::vector<CPubKey> output_pubkeys;
+    std::vector<CKey> asset_keys;
+    std::vector<CKey> token_keys;
+    FillBlinds(pwallet, tx, output_value_blinds, output_asset_blinds, output_pubkeys, asset_keys, token_keys);
+
+    UniValue result(UniValue::VOBJ);
+    result.pushKV("hex", EncodeHexTx(tx));
+    return result;
+}
+
+static CTransactionRef SendGenerationTransaction(const CScript& asset_script, const CPubKey &asset_pubkey, const CScript& token_script, const CPubKey &token_pubkey, CAmount asset_amount, CAmount token_amount, IssuanceDetails* issuance_details, CWallet* pwallet)
+{
+    CAsset reissue_token = issuance_details->reissuance_token;
+    CAmount curBalance = pwallet->GetBalance()[reissue_token];
+
+    if (!reissue_token.IsNull() && curBalance <= 0) {
+        throw JSONRPCError(RPC_WALLET_INSUFFICIENT_FUNDS, "No available reissuance tokens in wallet.");
+    }
+
+    // Might need up to 3 change keys: policyAsset, asset, and reissuance token
+    std::vector<std::unique_ptr<CReserveKey>> change_keys;
+    for (unsigned int i = 0; i < 3; i++) {
+        change_keys.push_back(std::unique_ptr<CReserveKey>(new CReserveKey(pwallet)));
+    }
+
+    std::vector<CRecipient> vecSend;
+    // Signal outputs to skip "funding" with fixed asset numbers 1, 2, ...
+    // We don't know the asset during initial issuance until inputs are chosen
+    if (asset_script.size() > 0) {
+        vecSend.push_back({asset_script, asset_amount, CAsset(uint256S("1")), asset_pubkey, false});
+    }
+    if (token_script.size() > 0) {
+        CRecipient recipient = {token_script, token_amount, CAsset(uint256S("2")), token_pubkey, false};
+        // We need to select the issuance token(s) to spend
+        if (!reissue_token.IsNull()) {
+            recipient.asset = reissue_token;
+            recipient.nAmount = curBalance; // Or 1?
+            // If the issuance token *is* the fee asset, subtract fee from this output
+            if (reissue_token == ::policyAsset) {
+                recipient.fSubtractFeeFromAmount = true;
+            }
+        }
+        vecSend.push_back(recipient);
+    }
+
+    CAmount nFeeRequired;
+    int nChangePosRet = -1;
+    std::string strError;
+    CCoinControl dummy_control;
+    BlindDetails blind_details;
+    CTransactionRef tx_ref(MakeTransactionRef());
+    if (!pwallet->CreateTransaction(vecSend, tx_ref, change_keys, nFeeRequired, nChangePosRet, strError, dummy_control, true, &blind_details, issuance_details)) {
+        throw JSONRPCError(RPC_WALLET_ERROR, strError);
+    }
+
+    CValidationState state;
+    mapValue_t map_value;
+    if (!pwallet->CommitTransaction(tx_ref, std::move(map_value), {} /* orderForm */, change_keys, g_connman.get(), state, &blind_details)) {
+        throw JSONRPCError(RPC_WALLET_ERROR, "Error: The transaction was rejected! This might happen if some of the coins in your wallet were already spent, such as if you used a copy of the wallet and coins were spent in the copy but not marked as spent here.");
+    }
+
+    return tx_ref;
+}
+
+UniValue issueasset(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 || request.params.size() > 3)
+        throw std::runtime_error(
+            "issueasset assetamount tokenamount ( blind )\n"
+            "\nCreate an asset. Must have funds in wallet to do so. Returns asset hex id.\n"
+            "\nArguments:\n"
+            "1. \"assetamount\"           (numeric or string, required) Amount of asset to generate.\n"
+            "2. \"tokenamount\"           (numeric or string, required) Amount of reissuance tokens to generate. These will allow you to reissue the asset if in wallet using `reissueasset`. These tokens are not consumed during reissuance.\n"
+            "3. \"blind\"                 (bool, optional, default=true) Whether to blind the issuances.\n"
+            "\nResult:\n"
+            "{                        (json object)\n"
+            "  \"txid\":\"<txid>\",   (string) Transaction id for issuance.\n"
+            "  \"vin\":\"n\",         (numeric) The input position of the issuance in the transaction.\n"
+            "  \"entropy\":\"<entropy>\", (string) Entropy of the asset type.\n"
+            "  \"asset\":\"<asset>\", (string) Asset type for issuance.\n"
+            "  \"token\":\"<token>\", (string) Token type for issuance.\n"
+            "}\n"
+            "\nExamples:\n"
+            + HelpExampleCli("issueasset", "10 0")
+            + HelpExampleRpc("issueasset", "10, 0")
+        );
+
+    LOCK2(cs_main, pwallet->cs_wallet);
+
+    CAmount nAmount = AmountFromValue(request.params[0]);
+    CAmount nTokens = AmountFromValue(request.params[1]);
+    if (nAmount == 0 && nTokens == 0) {
+        throw JSONRPCError(RPC_TYPE_ERROR, "Issuance must have one non-zero component");
+    }
+
+    bool blind_issuances = request.params.size() < 3 || request.params[2].get_bool();
+
+    if (!pwallet->IsLocked())
+        pwallet->TopUpKeyPool();
+
+    // Generate a new key that is added to wallet
+    CPubKey newKey;
+    CTxDestination asset_dest;
+    CTxDestination token_dest;
+    CPubKey asset_dest_blindpub;
+    CPubKey token_dest_blindpub;
+
+    if (nAmount > 0) {
+        if (!pwallet->GetKeyFromPool(newKey)) {
+            throw JSONRPCError(RPC_WALLET_KEYPOOL_RAN_OUT, "Error: Keypool ran out, please call keypoolrefill first");
+        }
+        asset_dest = PKHash(newKey.GetID());
+        pwallet->SetAddressBook(asset_dest, "", "receive");
+        asset_dest_blindpub = pwallet->GetBlindingPubKey(GetScriptForDestination(asset_dest));
+    }
+    if (nTokens > 0) {
+        if (!pwallet->GetKeyFromPool(newKey)) {
+            throw JSONRPCError(RPC_WALLET_KEYPOOL_RAN_OUT, "Error: Keypool ran out, please call keypoolrefill first");
+        }
+        token_dest = PKHash(newKey.GetID());
+        pwallet->SetAddressBook(token_dest, "", "receive");
+        token_dest_blindpub = pwallet->GetBlindingPubKey(GetScriptForDestination(token_dest));
+    }
+
+    uint256 dummyentropy;
+    CAsset dummyasset;
+    IssuanceDetails issuance_details;
+    issuance_details.blind_issuance = blind_issuances;
+    CTransactionRef tx_ref = SendGenerationTransaction(GetScriptForDestination(asset_dest), asset_dest_blindpub, GetScriptForDestination(token_dest), token_dest_blindpub, nAmount, nTokens, &issuance_details, pwallet);
+
+    // Calculate asset type, assumes first vin is used for issuance
+    CAsset asset;
+    CAsset token;
+    assert(!tx_ref->vin.empty());
+    GenerateAssetEntropy(issuance_details.entropy, tx_ref->vin[0].prevout, uint256());
+    CalculateAsset(asset, issuance_details.entropy);
+    CalculateReissuanceToken(token, issuance_details.entropy, blind_issuances);
+
+    UniValue ret(UniValue::VOBJ);
+    ret.pushKV("txid", tx_ref->GetHash().GetHex());
+    ret.pushKV("vin", 0);
+    ret.pushKV("entropy", issuance_details.entropy.GetHex());
+    ret.pushKV("asset", asset.GetHex());
+    ret.pushKV("token", token.GetHex());
+    return ret;
+}
+
+UniValue reissueasset(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(
+            "reissueasset \"asset\" assetamount\n"
+            "\nCreate more of an already issued asset. Must have reissuance token in wallet to do so. Reissuing does not affect your reissuance token balance, only asset.\n"
+            "\nArguments:\n"
+            "1. \"asset\"                 (string, required) The asset you want to re-issue. The corresponding token must be in your wallet.\n"
+            "2. \"assetamount\"           (numeric or string, required) Amount of additional asset to generate.\n"
+            "\nResult:\n"
+            "{                        (json object)\n"
+            "  \"txid\":\"<txid>\",   (string) Transaction id for issuance.\n"
+            "  \"vin\":\"n\",         (numeric) The input position of the issuance in the transaction.\n"
+            "}\n"
+            "\nExamples:\n"
+            + HelpExampleCli("reissueasset", "<asset> 0")
+            + HelpExampleRpc("reissueasset", "<asset>, 0")
+        );
+
+    LOCK2(cs_main, pwallet->cs_wallet);
+
+    std::string assetstr = request.params[0].get_str();
+    CAsset asset = GetAssetFromString(assetstr);
+
+    CAmount nAmount = AmountFromValue(request.params[1]);
+    if (nAmount <= 0) {
+        throw JSONRPCError(RPC_TYPE_ERROR, "Reissuance must create a non-zero amount.");
+    }
+
+    if (!pwallet->IsLocked()) {
+        pwallet->TopUpKeyPool();
+    }
+
+    // Find the entropy and reissuance token in wallet
+    IssuanceDetails issuance_details;
+    issuance_details.reissuance_asset = asset;
+    std::map<uint256, std::pair<CAsset, CAsset> > tokenMap = pwallet->GetReissuanceTokenTypes();
+    for (const auto& it : tokenMap) {
+        if (it.second.second == asset) {
+            issuance_details.entropy = it.first;
+            issuance_details.reissuance_token = it.second.first;
+        }
+        if (it.second.first == asset) {
+            throw JSONRPCError(RPC_WALLET_ERROR, "Asset given is a reissuance token type and can not be reissued.");
+        }
+    }
+    if (issuance_details.reissuance_token.IsNull()) {
+        throw JSONRPCError(RPC_WALLET_ERROR, "Asset reissuance token definition could not be found in wallet.");
+    }
+
+    // Add destination for the to-be-created asset
+    CPubKey newAssetKey;
+    if (!pwallet->GetKeyFromPool(newAssetKey)) {
+        throw JSONRPCError(RPC_WALLET_KEYPOOL_RAN_OUT, "Error: Keypool ran out, please call keypoolrefill first");
+    }
+    CTxDestination asset_dest = PKHash(newAssetKey.GetID());
+    pwallet->SetAddressBook(asset_dest, "", "receive");
+    CPubKey asset_dest_blindpub = pwallet->GetBlindingPubKey(GetScriptForDestination(asset_dest));
+
+    // Add destination for tokens we are moving
+    CPubKey newTokenKey;
+    if (!pwallet->GetKeyFromPool(newTokenKey)) {
+        throw JSONRPCError(RPC_WALLET_KEYPOOL_RAN_OUT, "Error: Keypool ran out, please call keypoolrefill first");
+    }
+    CTxDestination token_dest = PKHash(newTokenKey.GetID());
+    pwallet->SetAddressBook(token_dest, "", "receive");
+    CPubKey token_dest_blindpub = pwallet->GetBlindingPubKey(GetScriptForDestination(token_dest));
+
+    // Attempt a send.
+    CTransactionRef tx_ref = SendGenerationTransaction(GetScriptForDestination(asset_dest), asset_dest_blindpub, GetScriptForDestination(token_dest), token_dest_blindpub, nAmount, -1, &issuance_details, pwallet);
+    assert(!tx_ref->vin.empty());
+
+    UniValue obj(UniValue::VOBJ);
+    obj.pushKV("txid", tx_ref->GetHash().GetHex());
+    for (uint64_t i = 0; i < tx_ref->vin.size(); i++) {
+        if (!tx_ref->vin[i].assetIssuance.IsNull()) {
+            obj.pushKV("vin", i);
+            break;
+        }
+    }
+
+    return obj;
+}
+
+UniValue listissuances(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(
+            "listissuances ( asset ) \n"
+            "\nList all issuances known to the wallet for the given asset, or for all issued assets if none provided.\n"
+            "\nArguments:\n"
+            "1. \"asset\"                 (string, optional) The asset whose issaunces you wish to list. Accepts either the asset hex or the locally assigned asset label.\n"
+            "\nResult:\n"
+            "[                     (json array of objects)\n"
+            "  {\n"
+            "    \"txid\":\"<txid>\",   (string) Transaction id for issuance.\n"
+            "    \"entropy\":\"<entropy>\" (string) Entropy of the asset type.\n"
+            "    \"asset\":\"<asset>\", (string) Asset type for issuance if known.\n"
+            "    \"assetlabel\":\"<assetlabel>\", (string) Asset label for issuance if set.\n"
+            "    \"token\":\"<token>\", (string) Token type for issuance.\n"
+            "    \"vin\":\"n\",         (numeric) The input position of the issuance in the transaction.\n"
+            "    \"assetamount\":\"X.XX\",     (numeric) The amount of asset issued. Is -1 if blinded and unknown to wallet.\n"
+            "    \"tokenamount\":\"X.XX\",     (numeric) The reissuance token amount issued. Is -1 if blinded and unknown to wallet.\n"
+            "    \"isreissuance\":\"<bool>\",  (bool) True if this is a reissuance.\n"
+            "    \"assetblinds\":\"<blinder>\" (string) Hex blinding factor for asset amounts.\n"
+            "    \"tokenblinds\":\"<blinder>\" (string) Hex blinding factor for token amounts.\n"
+            "  }\n"
+            "  ,...\n"
+            "]\n"
+            "\"\"                 (array) List of transaction issuances and information in wallet\n"
+            + HelpExampleCli("listissuances", "<asset>")
+            + HelpExampleRpc("listissuances", "<asset>")
+        );
+
+    LOCK2(cs_main, pwallet->cs_wallet);
+
+    std::string assetstr;
+    CAsset asset_filter;
+    if (request.params.size() > 0) {
+        assetstr = request.params[0].get_str();
+        asset_filter = GetAssetFromString(assetstr);
+    }
+
+    UniValue issuancelist(UniValue::VARR);
+    for (const auto& it : pwallet->mapWallet) {
+        const CWalletTx* pcoin = &it.second;
+        CAsset asset;
+        CAsset token;
+        uint256 entropy;
+        for (uint64_t vinIndex = 0; vinIndex < pcoin->tx->vin.size(); vinIndex++) {
+            UniValue item(UniValue::VOBJ);
+            const CAssetIssuance& issuance = pcoin->tx->vin[vinIndex].assetIssuance;
+            if (issuance.IsNull()) {
+                continue;
+            }
+            if (issuance.assetBlindingNonce.IsNull()) {
+                GenerateAssetEntropy(entropy, pcoin->tx->vin[vinIndex].prevout, issuance.assetEntropy);
+                CalculateAsset(asset, entropy);
+                // Null is considered explicit
+                CalculateReissuanceToken(token, entropy, issuance.nAmount.IsCommitment());
+                item.pushKV("isreissuance", false);
+                item.pushKV("token", token.GetHex());
+                CAmount itamount = pcoin->GetIssuanceAmount(vinIndex, true);
+                item.pushKV("tokenamount", (itamount == -1 ) ? -1 : ValueFromAmount(itamount));
+                item.pushKV("tokenblinds", pcoin->GetIssuanceBlindingFactor(vinIndex, true).GetHex());
+                item.pushKV("entropy", entropy.GetHex());
+            } else {
+                CalculateAsset(asset, issuance.assetEntropy);
+                item.pushKV("isreissuance", true);
+                item.pushKV("entropy", issuance.assetEntropy.GetHex());
+            }
+            item.pushKV("txid", pcoin->tx->GetHash().GetHex());
+            item.pushKV("vin", vinIndex);
+            item.pushKV("asset", asset.GetHex());
+            const std::string label = gAssetsDir.GetLabel(asset);
+            if (label != "") {
+                item.pushKV("assetlabel", label);
+            }
+            CAmount iaamount = pcoin->GetIssuanceAmount(vinIndex, false);
+            item.pushKV("assetamount", (iaamount == -1 ) ? -1 : ValueFromAmount(iaamount));
+            item.pushKV("assetblinds", pcoin->GetIssuanceBlindingFactor(vinIndex, false).GetHex());
+            if (!asset_filter.IsNull() && asset_filter != asset) {
+                continue;
+            }
+            issuancelist.push_back(item);
+        }
+    }
+    return issuancelist;
+
+}
+
+UniValue destroyamount(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(
+            "destroyamount asset amount ( \"comment\" )\n"
+            "\nDestroy an amount of a given asset.\n\n"
+            "\nArguments:\n"
+            "1. \"asset\"       (string, required) Hex asset id or asset label to destroy.\n"
+            "2. \"amount\"      (numeric or string, required) The amount to destroy (8 decimals above the minimal unit).\n"
+            "3. \"comment\"     (string, optional) A comment used to store what the transaction is for. \n"
+            "                             This is not part of the transaction, just kept in your wallet.\n"
+            "\nResult:\n"
+            "\"transactionid\"  (string) The transaction id.\n"
+            "\nExamples:\n"
+            + HelpExampleCli("destroyamount", "\"bitcoin\" 100")
+            + HelpExampleCli("destroyamount", "\"bitcoin\" 100 \"destroy assets\"")
+            + HelpExampleRpc("destroyamount", "\"bitcoin\" 100 \"destroy assets\"")
+        );
+
+    LOCK2(cs_main, pwallet->cs_wallet);
+
+    std::string strasset = request.params[0].get_str();
+    CAsset asset = GetAssetFromString(strasset);
+
+    CAmount nAmount = AmountFromValue(request.params[1]);
+    if (nAmount <= 0) {
+        throw JSONRPCError(RPC_TYPE_ERROR, "Invalid amount to destroy");
+    }
+
+    mapValue_t mapValue;
+    if (request.params.size() > 2 && !request.params[2].isNull() && !request.params[2].get_str().empty()) {
+        mapValue["comment"] = request.params[2].get_str();
+    }
+
+    EnsureWalletIsUnlocked(pwallet);
+
+    NullData nulldata;
+    CTxDestination address(nulldata);
+    CCoinControl no_coin_control; // This is a deprecated API
+    CTransactionRef tx = SendMoney(pwallet, address, nAmount, asset, false, no_coin_control, std::move(mapValue), true);
+
+    return tx->GetHash().GetHex();
+}
+
+
 // END ELEMENTS commands
 //
 
 UniValue abortrescan(const JSONRPCRequest& request); // in rpcdump.cpp
 UniValue dumpprivkey(const JSONRPCRequest& request); // in rpcdump.cpp
+UniValue importblindingkey(const JSONRPCRequest& request); // in rpcdump.cpp
+UniValue importissuanceblindingkey(const JSONRPCRequest& request); // in rpcdump.cpp
+UniValue dumpblindingkey(const JSONRPCRequest& request); // in rpcdump.cpp
+UniValue dumpissuanceblindingkey(const JSONRPCRequest& request); // in rpcdump.cpp
 UniValue importprivkey(const JSONRPCRequest& request);
 UniValue importaddress(const JSONRPCRequest& request);
 UniValue importpubkey(const JSONRPCRequest& request);
@@ -5082,8 +6093,8 @@ static const CRPCCommand commands[] =
     { "wallet",             "lockunspent",                      &lockunspent,                   {"unlock","transactions"} },
     { "wallet",             "removeprunedfunds",                &removeprunedfunds,             {"txid"} },
     { "wallet",             "rescanblockchain",                 &rescanblockchain,              {"start_height", "stop_height"} },
-    { "wallet",             "sendmany",                         &sendmany,                      {"dummy","amounts","minconf","comment","subtractfeefrom","replaceable","conf_target","estimate_mode"} },
-    { "wallet",             "sendtoaddress",                    &sendtoaddress,                 {"address","amount","comment","comment_to","subtractfeefromamount","replaceable","conf_target","estimate_mode"} },
+    { "wallet",             "sendmany",                         &sendmany,                      {"dummy","amounts","minconf","comment","subtractfeefrom","replaceable","conf_target","estimate_mode", "output_assets", "ignoreblindfail"} },
+    { "wallet",             "sendtoaddress",                    &sendtoaddress,                 {"address","amount","comment","comment_to","subtractfeefromamount","replaceable","conf_target","estimate_mode", "assetlabel", "ignoreblindfail"} },
     { "wallet",             "sethdseed",                        &sethdseed,                     {"newkeypool","seed"} },
     { "wallet",             "setlabel",                         &setlabel,                      {"address","label"} },
     { "wallet",             "settxfee",                         &settxfee,                      {"amount"} },
@@ -5099,11 +6110,20 @@ static const CRPCCommand commands[] =
     { "wallet",             "getpeginaddress",                  &getpeginaddress,               {} },
     { "wallet",             "claimpegin",                       &claimpegin,                    {"bitcoin_tx", "txoutproof", "claim_script"} },
     { "wallet",             "createrawpegin",                   &createrawpegin,                {"bitcoin_tx", "txoutproof", "claim_script"} },
+    { "wallet",             "blindrawtransaction",              &blindrawtransaction,           {"hexstring", "ignoreblindfail", "asset_commitments", "blind_issuances", "totalblinder"} },
+    { "wallet",             "unblindrawtransaction",            &unblindrawtransaction,         {"hex"} },
     { "wallet",             "sendtomainchain",                  &sendtomainchain,               {"address", "amount", "subtractfeefromamount"} },
     { "wallet",             "initpegoutwallet",                 &initpegoutwallet,              {"bitcoin_descriptor", "bip32_counter", "liquid_pak"} },
     { "wallet",             "getwalletpakinfo",                 &getwalletpakinfo,              {} },
-
+    { "wallet",             "importblindingkey",                &importblindingkey,             {"address", "hexkey", "key_is_master"}},
+    { "wallet",             "importissuanceblindingkey",        &importissuanceblindingkey,     {"txid", "vin", "blindingkey"}},
+    { "wallet",             "dumpblindingkey",                  &dumpblindingkey,               {"address"}},
+    { "wallet",             "dumpissuanceblindingkey",          &dumpissuanceblindingkey,       {"txid", "vin"}},
     { "wallet",             "signblock",                        &signblock,                     {"blockhex"}},
+    { "wallet",             "listissuances",                    &listissuances,                 {"asset"}},
+    { "wallet",             "issueasset",                       &issueasset,                    {"assetamount", "tokenamount", "blind"}},
+    { "wallet",             "reissueasset",                     &reissueasset,                  {"asset", "assetamount"}},
+    { "wallet",             "destroyamount",                    &destroyamount,                 {"asset", "amount", "comment"} },
 };
 // clang-format on
 
diff --git a/src/wallet/test/coinselector_tests.cpp b/src/wallet/test/coinselector_tests.cpp
index 6d1d09d5a57b5..d8145f3146fe8 100644
--- a/src/wallet/test/coinselector_tests.cpp
+++ b/src/wallet/test/coinselector_tests.cpp
@@ -36,12 +36,24 @@ CoinEligibilityFilter filter_confirmed(1, 1, 0);
 CoinEligibilityFilter filter_standard_extra(6, 6, 0);
 CoinSelectionParams coin_selection_params(false, 0, 0, CFeeRate(0), 0);
 
+// ELEMENTS: helper function wrapping a single-asset call to SelectCoinsMinConf
+static bool SimpleSelectCoinsMinConf(const CWallet& wallet, const CAmount& nTargetValue, const CoinEligibilityFilter& eligibility_filter, std::vector<OutputGroup> groups,
+                                 std::set<CInputCoin>& setCoinsRet, CAmount& nValueRet, const CoinSelectionParams& coin_selection_params, bool& bnb_used) {
+    CAmountMap mapTargetValue;
+    mapTargetValue[CAsset()] = nTargetValue;
+    CAmountMap mapValueRet;
+    bool ret = wallet.SelectCoinsMinConf(mapTargetValue, eligibility_filter, groups, setCoinsRet, mapValueRet, coin_selection_params, bnb_used);
+    nValueRet = mapValueRet[CAsset()];
+    return ret;
+}
+
 static void add_coin(const CAmount& nValue, int nInput, std::vector<CInputCoin>& set)
 {
     CMutableTransaction tx;
     tx.vout.resize(nInput + 1);
     tx.vout[nInput].nValue = nValue;
-    set.emplace_back(MakeTransactionRef(tx), nInput);
+    CWalletTx wtx(&testWallet, MakeTransactionRef(tx));
+    set.emplace_back(&wtx, nInput);
 }
 
 static void add_coin(const CAmount& nValue, int nInput, CoinSet& set)
@@ -49,7 +61,8 @@ static void add_coin(const CAmount& nValue, int nInput, CoinSet& set)
     CMutableTransaction tx;
     tx.vout.resize(nInput + 1);
     tx.vout[nInput].nValue = nValue;
-    set.emplace(MakeTransactionRef(tx), nInput);
+    CWalletTx wtx(&testWallet, MakeTransactionRef(tx));
+    set.emplace(&wtx, nInput);
 }
 
 static void add_coin(const CAmount& nValue, int nAge = 6*24, bool fIsFromMe = false, int nInput=0)
@@ -69,7 +82,7 @@ static void add_coin(const CAmount& nValue, int nAge = 6*24, bool fIsFromMe = fa
     if (fIsFromMe)
     {
         wtx->fDebitCached = true;
-        wtx->nDebitCached = 1;
+        wtx->nDebitCached[CAsset()] = 1;
     }
     COutput output(wtx.get(), nInput, nAge, true /* spendable */, true /* solvable */, true /* safe */);
     vCoins.push_back(output);
@@ -114,7 +127,7 @@ inline std::vector<OutputGroup>& GroupCoins(const std::vector<COutput>& coins)
 {
     static std::vector<OutputGroup> static_groups;
     static_groups.clear();
-    for (auto& coin : coins) static_groups.emplace_back(coin.GetInputCoin(), coin.nDepth, coin.tx->fDebitCached && coin.tx->nDebitCached == 1 /* HACK: we can't figure out the is_me flag so we use the conditions defined above; perhaps set safe to false for !fIsFromMe in add_coin() */, 0, 0);
+    for (auto& coin : coins) static_groups.emplace_back(coin.GetInputCoin(), coin.nDepth, coin.tx->fDebitCached && coin.tx->nDebitCached[CAsset()] == 1 /* HACK: we can't figure out the is_me flag so we use the conditions defined above; perhaps set safe to false for !fIsFromMe in add_coin() */, 0, 0);
     return static_groups;
 }
 
@@ -249,7 +262,7 @@ BOOST_AUTO_TEST_CASE(bnb_search_test)
     empty_wallet();
     add_coin(1);
     vCoins.at(0).nInputBytes = 40; // Make sure that it has a negative effective value. The next check should assert if this somehow got through. Otherwise it will fail
-    BOOST_CHECK(!testWallet.SelectCoinsMinConf( 1 * CENT, filter_standard, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params_bnb, bnb_used));
+    BOOST_CHECK(!SimpleSelectCoinsMinConf(testWallet,  1 * CENT, filter_standard, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params_bnb, bnb_used));
 
     // Make sure that we aren't using BnB when there are preset inputs
     empty_wallet();
@@ -259,7 +272,10 @@ BOOST_AUTO_TEST_CASE(bnb_search_test)
     CCoinControl coin_control;
     coin_control.fAllowOtherInputs = true;
     coin_control.Select(COutPoint(vCoins.at(0).tx->GetHash(), vCoins.at(0).i));
-    BOOST_CHECK(testWallet.SelectCoins(vCoins, 10 * CENT, setCoinsRet, nValueRet, coin_control, coin_selection_params_bnb, bnb_used));
+    CAmountMap mapTargetValue;
+    mapTargetValue[CAsset()] = 10 * CENT;
+    CAmountMap mapValueRet;
+    BOOST_CHECK(testWallet.SelectCoins(vCoins, mapTargetValue, setCoinsRet, mapValueRet, coin_control, coin_selection_params_bnb, bnb_used));
     BOOST_CHECK(!bnb_used);
     BOOST_CHECK(!coin_selection_params_bnb.use_bnb);
 }
@@ -278,24 +294,24 @@ BOOST_AUTO_TEST_CASE(knapsack_solver_test)
         empty_wallet();
 
         // with an empty wallet we can't even pay one cent
-        BOOST_CHECK(!testWallet.SelectCoinsMinConf( 1 * CENT, filter_standard, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
+        BOOST_CHECK(!SimpleSelectCoinsMinConf(testWallet,  1 * CENT, filter_standard, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
 
         add_coin(1*CENT, 4);        // add a new 1 cent coin
 
         // with a new 1 cent coin, we still can't find a mature 1 cent
-        BOOST_CHECK(!testWallet.SelectCoinsMinConf( 1 * CENT, filter_standard, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
+        BOOST_CHECK(!SimpleSelectCoinsMinConf(testWallet,  1 * CENT, filter_standard, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
 
         // but we can find a new 1 cent
-        BOOST_CHECK( testWallet.SelectCoinsMinConf( 1 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
+        BOOST_CHECK( SimpleSelectCoinsMinConf(testWallet,  1 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, 1 * CENT);
 
         add_coin(2*CENT);           // add a mature 2 cent coin
 
         // we can't make 3 cents of mature coins
-        BOOST_CHECK(!testWallet.SelectCoinsMinConf( 3 * CENT, filter_standard, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
+        BOOST_CHECK(!SimpleSelectCoinsMinConf(testWallet,  3 * CENT, filter_standard, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
 
         // we can make 3 cents of new coins
-        BOOST_CHECK( testWallet.SelectCoinsMinConf( 3 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
+        BOOST_CHECK( SimpleSelectCoinsMinConf(testWallet,  3 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, 3 * CENT);
 
         add_coin(5*CENT);           // add a mature 5 cent coin,
@@ -305,33 +321,33 @@ BOOST_AUTO_TEST_CASE(knapsack_solver_test)
         // now we have new: 1+10=11 (of which 10 was self-sent), and mature: 2+5+20=27.  total = 38
 
         // we can't make 38 cents only if we disallow new coins:
-        BOOST_CHECK(!testWallet.SelectCoinsMinConf(38 * CENT, filter_standard, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
+        BOOST_CHECK(!SimpleSelectCoinsMinConf(testWallet, 38 * CENT, filter_standard, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
         // we can't even make 37 cents if we don't allow new coins even if they're from us
-        BOOST_CHECK(!testWallet.SelectCoinsMinConf(38 * CENT, filter_standard_extra, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
+        BOOST_CHECK(!SimpleSelectCoinsMinConf(testWallet, 38 * CENT, filter_standard_extra, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
         // but we can make 37 cents if we accept new coins from ourself
-        BOOST_CHECK( testWallet.SelectCoinsMinConf(37 * CENT, filter_standard, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
+        BOOST_CHECK( SimpleSelectCoinsMinConf(testWallet, 37 * CENT, filter_standard, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, 37 * CENT);
         // and we can make 38 cents if we accept all new coins
-        BOOST_CHECK( testWallet.SelectCoinsMinConf(38 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
+        BOOST_CHECK( SimpleSelectCoinsMinConf(testWallet, 38 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, 38 * CENT);
 
         // try making 34 cents from 1,2,5,10,20 - we can't do it exactly
-        BOOST_CHECK( testWallet.SelectCoinsMinConf(34 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
+        BOOST_CHECK( SimpleSelectCoinsMinConf(testWallet, 34 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, 35 * CENT);       // but 35 cents is closest
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 3U);     // the best should be 20+10+5.  it's incredibly unlikely the 1 or 2 got included (but possible)
 
         // when we try making 7 cents, the smaller coins (1,2,5) are enough.  We should see just 2+5
-        BOOST_CHECK( testWallet.SelectCoinsMinConf( 7 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
+        BOOST_CHECK( SimpleSelectCoinsMinConf(testWallet,  7 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, 7 * CENT);
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 2U);
 
         // when we try making 8 cents, the smaller coins (1,2,5) are exactly enough.
-        BOOST_CHECK( testWallet.SelectCoinsMinConf( 8 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
+        BOOST_CHECK( SimpleSelectCoinsMinConf(testWallet,  8 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK(nValueRet == 8 * CENT);
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 3U);
 
         // when we try making 9 cents, no subset of smaller coins is enough, and we get the next bigger coin (10)
-        BOOST_CHECK( testWallet.SelectCoinsMinConf( 9 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
+        BOOST_CHECK( SimpleSelectCoinsMinConf(testWallet,  9 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, 10 * CENT);
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 1U);
 
@@ -345,30 +361,30 @@ BOOST_AUTO_TEST_CASE(knapsack_solver_test)
         add_coin(30*CENT); // now we have 6+7+8+20+30 = 71 cents total
 
         // check that we have 71 and not 72
-        BOOST_CHECK( testWallet.SelectCoinsMinConf(71 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
-        BOOST_CHECK(!testWallet.SelectCoinsMinConf(72 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
+        BOOST_CHECK( SimpleSelectCoinsMinConf(testWallet, 71 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
+        BOOST_CHECK(!SimpleSelectCoinsMinConf(testWallet, 72 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
 
         // now try making 16 cents.  the best smaller coins can do is 6+7+8 = 21; not as good at the next biggest coin, 20
-        BOOST_CHECK( testWallet.SelectCoinsMinConf(16 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
+        BOOST_CHECK( SimpleSelectCoinsMinConf(testWallet, 16 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, 20 * CENT); // we should get 20 in one coin
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 1U);
 
         add_coin( 5*CENT); // now we have 5+6+7+8+20+30 = 75 cents total
 
         // now if we try making 16 cents again, the smaller coins can make 5+6+7 = 18 cents, better than the next biggest coin, 20
-        BOOST_CHECK( testWallet.SelectCoinsMinConf(16 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
+        BOOST_CHECK( SimpleSelectCoinsMinConf(testWallet, 16 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, 18 * CENT); // we should get 18 in 3 coins
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 3U);
 
         add_coin( 18*CENT); // now we have 5+6+7+8+18+20+30
 
         // and now if we try making 16 cents again, the smaller coins can make 5+6+7 = 18 cents, the same as the next biggest coin, 18
-        BOOST_CHECK( testWallet.SelectCoinsMinConf(16 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
+        BOOST_CHECK( SimpleSelectCoinsMinConf(testWallet, 16 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, 18 * CENT);  // we should get 18 in 1 coin
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 1U); // because in the event of a tie, the biggest coin wins
 
         // now try making 11 cents.  we should get 5+6
-        BOOST_CHECK( testWallet.SelectCoinsMinConf(11 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
+        BOOST_CHECK( SimpleSelectCoinsMinConf(testWallet, 11 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, 11 * CENT);
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 2U);
 
@@ -377,11 +393,11 @@ BOOST_AUTO_TEST_CASE(knapsack_solver_test)
         add_coin( 2*COIN);
         add_coin( 3*COIN);
         add_coin( 4*COIN); // now we have 5+6+7+8+18+20+30+100+200+300+400 = 1094 cents
-        BOOST_CHECK( testWallet.SelectCoinsMinConf(95 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
+        BOOST_CHECK( SimpleSelectCoinsMinConf(testWallet, 95 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, 1 * COIN);  // we should get 1 BTC in 1 coin
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 1U);
 
-        BOOST_CHECK( testWallet.SelectCoinsMinConf(195 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
+        BOOST_CHECK( SimpleSelectCoinsMinConf(testWallet, 195 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, 2 * COIN);  // we should get 2 BTC in 1 coin
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 1U);
 
@@ -396,14 +412,14 @@ BOOST_AUTO_TEST_CASE(knapsack_solver_test)
 
         // try making 1 * MIN_CHANGE from the 1.5 * MIN_CHANGE
         // we'll get change smaller than MIN_CHANGE whatever happens, so can expect MIN_CHANGE exactly
-        BOOST_CHECK( testWallet.SelectCoinsMinConf(MIN_CHANGE, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
+        BOOST_CHECK( SimpleSelectCoinsMinConf(testWallet, MIN_CHANGE, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, MIN_CHANGE);
 
         // but if we add a bigger coin, small change is avoided
         add_coin(1111*MIN_CHANGE);
 
         // try making 1 from 0.1 + 0.2 + 0.3 + 0.4 + 0.5 + 1111 = 1112.5
-        BOOST_CHECK( testWallet.SelectCoinsMinConf(1 * MIN_CHANGE, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
+        BOOST_CHECK( SimpleSelectCoinsMinConf(testWallet, 1 * MIN_CHANGE, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, 1 * MIN_CHANGE); // we should get the exact amount
 
         // if we add more small coins:
@@ -411,7 +427,7 @@ BOOST_AUTO_TEST_CASE(knapsack_solver_test)
         add_coin(MIN_CHANGE * 7 / 10);
 
         // and try again to make 1.0 * MIN_CHANGE
-        BOOST_CHECK( testWallet.SelectCoinsMinConf(1 * MIN_CHANGE, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
+        BOOST_CHECK( SimpleSelectCoinsMinConf(testWallet, 1 * MIN_CHANGE, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, 1 * MIN_CHANGE); // we should get the exact amount
 
         // run the 'mtgox' test (see http://blockexplorer.com/tx/29a3efd3ef04f9153d47a990bd7b048a4b2d213daaa5fb8ed670fb85f13bdbcf)
@@ -420,7 +436,7 @@ BOOST_AUTO_TEST_CASE(knapsack_solver_test)
         for (int j = 0; j < 20; j++)
             add_coin(50000 * COIN);
 
-        BOOST_CHECK( testWallet.SelectCoinsMinConf(500000 * COIN, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
+        BOOST_CHECK( SimpleSelectCoinsMinConf(testWallet, 500000 * COIN, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, 500000 * COIN); // we should get the exact amount
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 10U); // in ten coins
 
@@ -433,7 +449,7 @@ BOOST_AUTO_TEST_CASE(knapsack_solver_test)
         add_coin(MIN_CHANGE * 6 / 10);
         add_coin(MIN_CHANGE * 7 / 10);
         add_coin(1111 * MIN_CHANGE);
-        BOOST_CHECK( testWallet.SelectCoinsMinConf(1 * MIN_CHANGE, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
+        BOOST_CHECK( SimpleSelectCoinsMinConf(testWallet, 1 * MIN_CHANGE, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, 1111 * MIN_CHANGE); // we get the bigger coin
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 1U);
 
@@ -443,7 +459,7 @@ BOOST_AUTO_TEST_CASE(knapsack_solver_test)
         add_coin(MIN_CHANGE * 6 / 10);
         add_coin(MIN_CHANGE * 8 / 10);
         add_coin(1111 * MIN_CHANGE);
-        BOOST_CHECK( testWallet.SelectCoinsMinConf(MIN_CHANGE, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
+        BOOST_CHECK( SimpleSelectCoinsMinConf(testWallet, MIN_CHANGE, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, MIN_CHANGE);   // we should get the exact amount
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 2U); // in two coins 0.4+0.6
 
@@ -454,12 +470,12 @@ BOOST_AUTO_TEST_CASE(knapsack_solver_test)
         add_coin(MIN_CHANGE * 100);
 
         // trying to make 100.01 from these three coins
-        BOOST_CHECK(testWallet.SelectCoinsMinConf(MIN_CHANGE * 10001 / 100, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
+        BOOST_CHECK(SimpleSelectCoinsMinConf(testWallet, MIN_CHANGE * 10001 / 100, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, MIN_CHANGE * 10105 / 100); // we should get all coins
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 3U);
 
         // but if we try to make 99.9, we should take the bigger of the two small coins to avoid small change
-        BOOST_CHECK(testWallet.SelectCoinsMinConf(MIN_CHANGE * 9990 / 100, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
+        BOOST_CHECK(SimpleSelectCoinsMinConf(testWallet, MIN_CHANGE * 9990 / 100, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
         BOOST_CHECK_EQUAL(nValueRet, 101 * MIN_CHANGE);
         BOOST_CHECK_EQUAL(setCoinsRet.size(), 2U);
       }
@@ -473,7 +489,7 @@ BOOST_AUTO_TEST_CASE(knapsack_solver_test)
 
            // We only create the wallet once to save time, but we still run the coin selection RUN_TESTS times.
            for (int i = 0; i < RUN_TESTS; i++) {
-             BOOST_CHECK(testWallet.SelectCoinsMinConf(2000, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
+             BOOST_CHECK(SimpleSelectCoinsMinConf(testWallet, 2000, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
 
              if (amt - 2000 < MIN_CHANGE) {
                  // needs more than one input:
@@ -499,8 +515,8 @@ BOOST_AUTO_TEST_CASE(knapsack_solver_test)
           for (int i = 0; i < RUN_TESTS; i++) {
             // picking 50 from 100 coins doesn't depend on the shuffle,
             // but does depend on randomness in the stochastic approximation code
-            BOOST_CHECK(testWallet.SelectCoinsMinConf(50 * COIN, filter_standard, GroupCoins(vCoins), setCoinsRet , nValueRet, coin_selection_params, bnb_used));
-            BOOST_CHECK(testWallet.SelectCoinsMinConf(50 * COIN, filter_standard, GroupCoins(vCoins), setCoinsRet2, nValueRet, coin_selection_params, bnb_used));
+            BOOST_CHECK(SimpleSelectCoinsMinConf(testWallet, 50 * COIN, filter_standard, GroupCoins(vCoins), setCoinsRet , nValueRet, coin_selection_params, bnb_used));
+            BOOST_CHECK(SimpleSelectCoinsMinConf(testWallet, 50 * COIN, filter_standard, GroupCoins(vCoins), setCoinsRet2, nValueRet, coin_selection_params, bnb_used));
             BOOST_CHECK(!equal_sets(setCoinsRet, setCoinsRet2));
 
             int fails = 0;
@@ -508,8 +524,8 @@ BOOST_AUTO_TEST_CASE(knapsack_solver_test)
             {
                 // selecting 1 from 100 identical coins depends on the shuffle; this test will fail 1% of the time
                 // run the test RANDOM_REPEATS times and only complain if all of them fail
-                BOOST_CHECK(testWallet.SelectCoinsMinConf(COIN, filter_standard, GroupCoins(vCoins), setCoinsRet , nValueRet, coin_selection_params, bnb_used));
-                BOOST_CHECK(testWallet.SelectCoinsMinConf(COIN, filter_standard, GroupCoins(vCoins), setCoinsRet2, nValueRet, coin_selection_params, bnb_used));
+                BOOST_CHECK(SimpleSelectCoinsMinConf(testWallet, COIN, filter_standard, GroupCoins(vCoins), setCoinsRet , nValueRet, coin_selection_params, bnb_used));
+                BOOST_CHECK(SimpleSelectCoinsMinConf(testWallet, COIN, filter_standard, GroupCoins(vCoins), setCoinsRet2, nValueRet, coin_selection_params, bnb_used));
                 if (equal_sets(setCoinsRet, setCoinsRet2))
                     fails++;
             }
@@ -531,8 +547,8 @@ BOOST_AUTO_TEST_CASE(knapsack_solver_test)
             {
                 // selecting 1 from 100 identical coins depends on the shuffle; this test will fail 1% of the time
                 // run the test RANDOM_REPEATS times and only complain if all of them fail
-                BOOST_CHECK(testWallet.SelectCoinsMinConf(90*CENT, filter_standard, GroupCoins(vCoins), setCoinsRet , nValueRet, coin_selection_params, bnb_used));
-                BOOST_CHECK(testWallet.SelectCoinsMinConf(90*CENT, filter_standard, GroupCoins(vCoins), setCoinsRet2, nValueRet, coin_selection_params, bnb_used));
+                BOOST_CHECK(SimpleSelectCoinsMinConf(testWallet, 90*CENT, filter_standard, GroupCoins(vCoins), setCoinsRet , nValueRet, coin_selection_params, bnb_used));
+                BOOST_CHECK(SimpleSelectCoinsMinConf(testWallet, 90*CENT, filter_standard, GroupCoins(vCoins), setCoinsRet2, nValueRet, coin_selection_params, bnb_used));
                 if (equal_sets(setCoinsRet, setCoinsRet2))
                     fails++;
             }
@@ -558,7 +574,7 @@ BOOST_AUTO_TEST_CASE(ApproximateBestSubset)
         add_coin(1000 * COIN);
     add_coin(3 * COIN);
 
-    BOOST_CHECK(testWallet.SelectCoinsMinConf(1003 * COIN, filter_standard, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
+    BOOST_CHECK(SimpleSelectCoinsMinConf(testWallet, 1003 * COIN, filter_standard, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));
     BOOST_CHECK_EQUAL(nValueRet, 1003 * COIN);
     BOOST_CHECK_EQUAL(setCoinsRet.size(), 2U);
 
@@ -596,8 +612,8 @@ BOOST_AUTO_TEST_CASE(SelectCoins_test)
         CoinSet out_set;
         CAmount out_value = 0;
         bool bnb_used = false;
-        BOOST_CHECK(testWallet.SelectCoinsMinConf(target, filter_standard, GroupCoins(vCoins), out_set, out_value, coin_selection_params_bnb, bnb_used) ||
-                    testWallet.SelectCoinsMinConf(target, filter_standard, GroupCoins(vCoins), out_set, out_value, coin_selection_params_knapsack, bnb_used));
+        BOOST_CHECK(SimpleSelectCoinsMinConf(testWallet, target, filter_standard, GroupCoins(vCoins), out_set, out_value, coin_selection_params_bnb, bnb_used) ||
+                    SimpleSelectCoinsMinConf(testWallet, target, filter_standard, GroupCoins(vCoins), out_set, out_value, coin_selection_params_knapsack, bnb_used));
         BOOST_CHECK_GE(out_value, target);
     }
 }
diff --git a/src/wallet/test/wallet_tests.cpp b/src/wallet/test/wallet_tests.cpp
index 3a8e6f751ac38..656421456431e 100644
--- a/src/wallet/test/wallet_tests.cpp
+++ b/src/wallet/test/wallet_tests.cpp
@@ -51,7 +51,7 @@ BOOST_FIXTURE_TEST_CASE(rescan, TestChain100Setup)
         WalletRescanReserver reserver(&wallet);
         reserver.reserve();
         BOOST_CHECK_EQUAL(nullBlock, wallet.ScanForWalletTransactions(oldTip, nullptr, reserver));
-        BOOST_CHECK_EQUAL(wallet.GetImmatureBalance(), 100 * COIN);
+        BOOST_CHECK_EQUAL(wallet.GetImmatureBalance()[CAsset()], 100 * COIN);
     }
 
     // Prune the older block file.
@@ -66,7 +66,7 @@ BOOST_FIXTURE_TEST_CASE(rescan, TestChain100Setup)
         WalletRescanReserver reserver(&wallet);
         reserver.reserve();
         BOOST_CHECK_EQUAL(oldTip, wallet.ScanForWalletTransactions(oldTip, nullptr, reserver));
-        BOOST_CHECK_EQUAL(wallet.GetImmatureBalance(), 50 * COIN);
+        BOOST_CHECK_EQUAL(wallet.GetImmatureBalance()[CAsset()], 50 * COIN);
     }
 
     // Verify importmulti RPC returns failure for a key whose creation time is
@@ -188,13 +188,13 @@ BOOST_FIXTURE_TEST_CASE(coin_mark_dirty_immature_credit, TestChain100Setup)
 
     // Call GetImmatureCredit() once before adding the key to the wallet to
     // cache the current immature credit amount, which is 0.
-    BOOST_CHECK_EQUAL(wtx.GetImmatureCredit(), 0);
+    BOOST_CHECK_EQUAL(wtx.GetImmatureCredit()[CAsset()], 0);
 
     // Invalidate the cached value, add the key, and make sure a new immature
     // credit amount is calculated.
     wtx.MarkDirty();
     wallet.AddKeyPubKey(coinbaseKey, coinbaseKey.GetPubKey());
-    BOOST_CHECK_EQUAL(wtx.GetImmatureCredit(), 50*COIN);
+    BOOST_CHECK_EQUAL(wtx.GetImmatureCredit()[CAsset()], 50*COIN);
 }
 
 static int64_t AddTx(CWallet& wallet, uint32_t lockTime, int64_t mockTime, int64_t blockTime)
@@ -255,7 +255,7 @@ BOOST_AUTO_TEST_CASE(ComputeTimeSmart)
 
 BOOST_AUTO_TEST_CASE(LoadReceiveRequests)
 {
-    CTxDestination dest = CKeyID();
+    CTxDestination dest = PKHash();
     LOCK(m_wallet.cs_wallet);
     m_wallet.AddDestData(dest, "misc", "val_misc");
     m_wallet.AddDestData(dest, "rr0", "val_rr0");
@@ -290,14 +290,15 @@ class ListCoinsTestingSetup : public TestChain100Setup
     CWalletTx& AddTx(CRecipient recipient)
     {
         CTransactionRef tx;
-        CReserveKey reservekey(wallet.get());
+        std::vector<std::unique_ptr<CReserveKey>> reservekeys;
+        reservekeys.push_back(std::unique_ptr<CReserveKey>(new CReserveKey(wallet.get())));
         CAmount fee;
         int changePos = -1;
         std::string error;
         CCoinControl dummy;
-        BOOST_CHECK(wallet->CreateTransaction({recipient}, tx, reservekey, fee, changePos, error, dummy));
+        BOOST_CHECK(wallet->CreateTransaction({recipient}, tx, reservekeys, fee, changePos, error, dummy));
         CValidationState state;
-        BOOST_CHECK(wallet->CommitTransaction(tx, {}, {}, reservekey, nullptr, state));
+        BOOST_CHECK(wallet->CommitTransaction(tx, {}, {}, reservekeys, nullptr, state));
         CMutableTransaction blocktx;
         {
             LOCK(wallet->cs_wallet);
@@ -326,23 +327,23 @@ BOOST_FIXTURE_TEST_CASE(ListCoins, ListCoinsTestingSetup)
         list = wallet->ListCoins();
     }
     BOOST_CHECK_EQUAL(list.size(), 1U);
-    BOOST_CHECK_EQUAL(boost::get<CKeyID>(list.begin()->first).ToString(), coinbaseAddress);
+    BOOST_CHECK_EQUAL(boost::get<PKHash>(list.begin()->first).ToString(), coinbaseAddress);
     BOOST_CHECK_EQUAL(list.begin()->second.size(), 1U);
 
     // Check initial balance from one mature coinbase transaction.
-    BOOST_CHECK_EQUAL(50 * COIN, wallet->GetAvailableBalance());
+    BOOST_CHECK_EQUAL(50 * COIN, wallet->GetAvailableBalance()[CAsset()]);
 
     // Add a transaction creating a change address, and confirm ListCoins still
     // returns the coin associated with the change address underneath the
     // coinbaseKey pubkey, even though the change address has a different
     // pubkey.
-    AddTx(CRecipient{GetScriptForRawPubKey({}), 1 * COIN, false /* subtract fee */});
+    AddTx(CRecipient{GetScriptForRawPubKey({}), 1 * COIN, CAsset(), CPubKey(), false /* subtract fee */});
     {
         LOCK2(cs_main, wallet->cs_wallet);
         list = wallet->ListCoins();
     }
     BOOST_CHECK_EQUAL(list.size(), 1U);
-    BOOST_CHECK_EQUAL(boost::get<CKeyID>(list.begin()->first).ToString(), coinbaseAddress);
+    BOOST_CHECK_EQUAL(boost::get<PKHash>(list.begin()->first).ToString(), coinbaseAddress);
     BOOST_CHECK_EQUAL(list.begin()->second.size(), 2U);
 
     // Lock both coins. Confirm number of available coins drops to 0.
@@ -371,7 +372,7 @@ BOOST_FIXTURE_TEST_CASE(ListCoins, ListCoinsTestingSetup)
         list = wallet->ListCoins();
     }
     BOOST_CHECK_EQUAL(list.size(), 1U);
-    BOOST_CHECK_EQUAL(boost::get<CKeyID>(list.begin()->first).ToString(), coinbaseAddress);
+    BOOST_CHECK_EQUAL(boost::get<PKHash>(list.begin()->first).ToString(), coinbaseAddress);
     BOOST_CHECK_EQUAL(list.begin()->second.size(), 2U);
 }
 
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
index 6a767156f9947..88b1b6c09331c 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -35,6 +35,11 @@
 
 #include <boost/algorithm/string/replace.hpp>
 
+#include <blind.h>
+#include <issuance.h>
+#include <crypto/hmac_sha256.h>
+#include <random.h>
+
 static const size_t OUTPUT_GROUP_MAX_ENTRIES = 10;
 
 static CCriticalSection cs_wallets;
@@ -101,7 +106,7 @@ const uint256 CMerkleTx::ABANDON_HASH(uint256S("00000000000000000000000000000000
 
 std::string COutput::ToString() const
 {
-    return strprintf("COutput(%s, %d, %d) [%s]", tx->GetHash().ToString(), i, nDepth, FormatMoney(tx->tx->vout[i].nValue));
+    return strprintf("COutput(%s, %d, %d) [%s] [%s]", tx->GetHash().ToString(), i, nDepth, FormatMoney(tx->GetOutputValueOut(i)), tx->GetOutputAsset(i).GetHex());
 }
 
 /** A class to identify which pubkeys a script and a keystore have in common. */
@@ -133,13 +138,15 @@ class CAffectedKeysVisitor : public boost::static_visitor<void> {
         }
     }
 
-    void operator()(const CKeyID &keyId) {
+    void operator()(const PKHash &pkhash) {
+        CKeyID keyId(pkhash);
         if (keystore.HaveKey(keyId))
             vKeys.push_back(keyId);
     }
 
-    void operator()(const CScriptID &scriptId) {
+    void operator()(const ScriptHash &scripthash) {
         CScript script;
+        CScriptID scriptId(scripthash);
         if (keystore.GetCScript(scriptId, script))
             Process(script);
     }
@@ -276,7 +283,7 @@ bool CWallet::AddKeyPubKeyWithDB(WalletBatch &batch, const CKey& secret, const C
 
     // check if we need to remove from watch-only
     CScript script;
-    script = GetScriptForDestination(pubkey.GetID());
+    script = GetScriptForDestination(PKHash(pubkey));
     if (HaveWatchOnly(script)) {
         RemoveWatchOnly(script);
     }
@@ -366,7 +373,7 @@ bool CWallet::LoadCScript(const CScript& redeemScript)
      * these. Do not add them to the wallet and warn. */
     if (redeemScript.size() > MAX_SCRIPT_ELEMENT_SIZE)
     {
-        std::string strAddr = EncodeDestination(CScriptID(redeemScript));
+        std::string strAddr = EncodeDestination(ScriptHash(redeemScript));
         WalletLogPrintf("%s: Warning: This wallet contains a redeemScript of size %i which exceeds maximum size %i thus can never be redeemed. Do not use address %s.\n", __func__, redeemScript.size(), MAX_SCRIPT_ELEMENT_SIZE, strAddr);
         return true;
     }
@@ -1232,7 +1239,7 @@ isminetype CWallet::IsMine(const CTxIn &txin) const
 
 // Note that this function doesn't distinguish between a 0-valued input,
 // and a not-"is mine" (according to the filter) input.
-CAmount CWallet::GetDebit(const CTxIn &txin, const isminefilter& filter) const
+CAmountMap CWallet::GetDebit(const CTxIn &txin, const isminefilter& filter) const
 {
     {
         LOCK(cs_wallet);
@@ -1241,11 +1248,14 @@ CAmount CWallet::GetDebit(const CTxIn &txin, const isminefilter& filter) const
         {
             const CWalletTx& prev = (*mi).second;
             if (txin.prevout.n < prev.tx->vout.size())
-                if (IsMine(prev.tx->vout[txin.prevout.n]) & filter)
-                    return prev.tx->vout[txin.prevout.n].nValue;
+                if (IsMine(prev.tx->vout[txin.prevout.n]) & filter) {
+                    CAmountMap amounts;
+                    amounts[prev.GetOutputAsset(txin.prevout.n)] = std::max<CAmount>(0, prev.GetOutputValueOut(txin.prevout.n));
+                    return amounts;
+                }
         }
     }
-    return 0;
+    return CAmountMap();
 }
 
 isminetype CWallet::IsMine(const CTxOut& txout) const
@@ -1253,11 +1263,19 @@ isminetype CWallet::IsMine(const CTxOut& txout) const
     return ::IsMine(*this, txout.scriptPubKey);
 }
 
-CAmount CWallet::GetCredit(const CTxOut& txout, const isminefilter& filter) const
+CAmountMap CWallet::GetCredit(const CTxOut& txout, const isminefilter& filter) const
 {
-    if (!MoneyRange(txout.nValue))
+    assert(false && "CWallet::GetCredit(const CTxOut&, const isminefilter&): this method should not be used anymore");
+
+    CAmountMap credit;
+    if (txout.nAsset.IsExplicit() && txout.nValue.IsExplicit()) {
+        credit[txout.nAsset.GetAsset()] = txout.nValue.GetAmount();
+    } else {
+        WalletLogPrintf("WARNING: Calculating credit of blinded transaction.\n");
+    }
+    if (!MoneyRange(credit))
         throw std::runtime_error(std::string(__func__) + ": value out of range");
-    return ((IsMine(txout) & filter) ? txout.nValue : 0);
+    return ((IsMine(txout) & filter) ? credit : CAmountMap());
 }
 
 bool CWallet::IsChange(const CTxOut& txout) const
@@ -1282,11 +1300,13 @@ bool CWallet::IsChange(const CTxOut& txout) const
     return false;
 }
 
-CAmount CWallet::GetChange(const CTxOut& txout) const
+CAmountMap CWallet::GetChange(const CTxOut& txout) const
 {
-    if (!MoneyRange(txout.nValue))
+    CAmountMap change;
+    change[txout.nAsset.GetAsset()] = txout.nValue.GetAmount();
+    if (!MoneyRange(change))
         throw std::runtime_error(std::string(__func__) + ": value out of range");
-    return (IsChange(txout) ? txout.nValue : 0);
+    return (IsChange(txout) ? change : CAmountMap());
 }
 
 bool CWallet::IsMine(const CTransaction& tx) const
@@ -1299,12 +1319,12 @@ bool CWallet::IsMine(const CTransaction& tx) const
 
 bool CWallet::IsFromMe(const CTransaction& tx) const
 {
-    return (GetDebit(tx, ISMINE_ALL) > 0);
+    return (GetDebit(tx, ISMINE_ALL) > CAmountMap());
 }
 
-CAmount CWallet::GetDebit(const CTransaction& tx, const isminefilter& filter) const
+CAmountMap CWallet::GetDebit(const CTransaction& tx, const isminefilter& filter) const
 {
-    CAmount nDebit = 0;
+    CAmountMap nDebit;
     for (const CTxIn& txin : tx.vin)
     {
         nDebit += GetDebit(txin, filter);
@@ -1335,9 +1355,27 @@ bool CWallet::IsAllFromMe(const CTransaction& tx, const isminefilter& filter) co
     return true;
 }
 
-CAmount CWallet::GetCredit(const CTransaction& tx, const isminefilter& filter) const
+CAmountMap CWallet::GetCredit(const CWalletTx& wtx, const isminefilter& filter) const {
+    CAmountMap nCredit;
+    for (unsigned int i = 0; i < wtx.tx->vout.size(); ++i) {
+        if (IsMine(wtx.tx->vout[i]) & filter) {
+            CAmount credit = std::max<CAmount>(0, wtx.GetOutputValueOut(i));
+            if (!MoneyRange(credit))
+                throw std::runtime_error(std::string(__func__) + ": value out of range");
+
+            nCredit[wtx.GetOutputAsset(i)] += credit;
+            if (!MoneyRange(nCredit))
+                throw std::runtime_error(std::string(__func__) + ": value out of range");
+        }
+    }
+    return nCredit;
+}
+
+CAmountMap CWallet::GetCredit(const CTransaction& tx, const isminefilter& filter) const
 {
-    CAmount nCredit = 0;
+    assert(false && "CWallet::GetCredit(const CTransaction&, const isminefilter&): this method should not be used anymore");
+
+    CAmountMap nCredit;
     for (const CTxOut& txout : tx.vout)
     {
         nCredit += GetCredit(txout, filter);
@@ -1347,9 +1385,29 @@ CAmount CWallet::GetCredit(const CTransaction& tx, const isminefilter& filter) c
     return nCredit;
 }
 
-CAmount CWallet::GetChange(const CTransaction& tx) const
+CAmountMap CWallet::GetChange(const CWalletTx& wtx) const {
+    CAmountMap nChange;
+    for (unsigned int i = 0; i < wtx.tx->vout.size(); ++i) {
+        if (IsChange(wtx.tx->vout[i])) {
+            CAmount change = wtx.GetOutputValueOut(i);
+            if (change < 0) {
+                continue;
+            }
+
+            if (!MoneyRange(change))
+                throw std::runtime_error(std::string(__func__) + ": value out of range");
+
+            nChange[wtx.GetOutputAsset(i)] += change;
+            if (!MoneyRange(nChange))
+                throw std::runtime_error(std::string(__func__) + ": value out of range");
+        }
+    }
+    return nChange;
+}
+
+CAmountMap CWallet::GetChange(const CTransaction& tx) const
 {
-    CAmount nChange = 0;
+    CAmountMap nChange;
     for (const CTxOut& txout : tx.vout)
     {
         nChange += GetChange(txout);
@@ -1534,22 +1592,23 @@ void CWalletTx::GetAmounts(std::list<COutputEntry>& listReceived,
     listSent.clear();
 
     // Compute fee:
-    CAmount nDebit = GetDebit(filter);
-    if (nDebit > 0) // debit>0 means we signed/sent this transaction
+    CAmountMap mapDebit = GetDebit(filter);
+    if (mapDebit > CAmountMap()) // debit>0 means we signed/sent this transaction
     {
-        CAmount nValueOut = tx->GetValueOut();
-        nFee = nDebit - nValueOut;
+        nFee = -GetFeeMap(*tx)[::policyAsset];
     }
 
     // Sent/received.
     for (unsigned int i = 0; i < tx->vout.size(); ++i)
     {
         const CTxOut& txout = tx->vout[i];
-        isminetype fIsMine = pwallet->IsMine(txout);
+        CAmount output_value = GetOutputValueOut(i);
+        // Don't list unknown assets
+        isminetype fIsMine = output_value != -1 ?  pwallet->IsMine(txout) : ISMINE_NO;
         // Only need to handle txouts if AT LEAST one of these is true:
         //   1) they debit from us (sent)
         //   2) the output is to us (received)
-        if (nDebit > 0)
+        if (mapDebit > CAmountMap())
         {
             // Don't report 'change' txouts
             if (pwallet->IsChange(txout))
@@ -1568,10 +1627,10 @@ void CWalletTx::GetAmounts(std::list<COutputEntry>& listReceived,
             address = CNoDestination();
         }
 
-        COutputEntry output = {address, txout.nValue, (int)i};
+        COutputEntry output = {address, output_value, (int)i, GetOutputAsset(i), GetOutputAmountBlindingFactor(i), GetOutputAssetBlindingFactor(i)};
 
         // If we are debited by the transaction, add the output as a "sent" entry
-        if (nDebit > 0)
+        if (mapDebit > CAmountMap() && !txout.IsFee())
             listSent.push_back(output);
 
         // If we are receiving the output, add it as a "received" entry
@@ -1771,12 +1830,12 @@ std::set<uint256> CWalletTx::GetConflicts() const
     return result;
 }
 
-CAmount CWalletTx::GetDebit(const isminefilter& filter) const
+CAmountMap CWalletTx::GetDebit(const isminefilter& filter) const
 {
     if (tx->vin.empty())
-        return 0;
+        return CAmountMap();
 
-    CAmount debit = 0;
+    CAmountMap debit;
     if(filter & ISMINE_SPENDABLE)
     {
         if (fDebitCached)
@@ -1802,13 +1861,13 @@ CAmount CWalletTx::GetDebit(const isminefilter& filter) const
     return debit;
 }
 
-CAmount CWalletTx::GetCredit(const isminefilter& filter) const
+CAmountMap CWalletTx::GetCredit(const isminefilter& filter) const
 {
     // Must wait until coinbase is safely deep enough in the chain before valuing it
     if (IsImmatureCoinBase())
-        return 0;
+        return CAmountMap();
 
-    CAmount credit = 0;
+    CAmountMap credit;
     if (filter & ISMINE_SPENDABLE)
     {
         // GetBalance can assume transactions in mapWallet won't change
@@ -1816,7 +1875,7 @@ CAmount CWalletTx::GetCredit(const isminefilter& filter) const
             credit += nCreditCached;
         else
         {
-            nCreditCached = pwallet->GetCredit(*tx, ISMINE_SPENDABLE);
+            nCreditCached = pwallet->GetCredit(*this, ISMINE_SPENDABLE);
             fCreditCached = true;
             credit += nCreditCached;
         }
@@ -1827,7 +1886,7 @@ CAmount CWalletTx::GetCredit(const isminefilter& filter) const
             credit += nWatchCreditCached;
         else
         {
-            nWatchCreditCached = pwallet->GetCredit(*tx, ISMINE_WATCH_ONLY);
+            nWatchCreditCached = pwallet->GetCredit(*this, ISMINE_WATCH_ONLY);
             fWatchCreditCached = true;
             credit += nWatchCreditCached;
         }
@@ -1835,29 +1894,29 @@ CAmount CWalletTx::GetCredit(const isminefilter& filter) const
     return credit;
 }
 
-CAmount CWalletTx::GetImmatureCredit(bool fUseCache) const
+CAmountMap CWalletTx::GetImmatureCredit(bool fUseCache) const
 {
     if (IsImmatureCoinBase() && IsInMainChain()) {
         if (fUseCache && fImmatureCreditCached)
             return nImmatureCreditCached;
-        nImmatureCreditCached = pwallet->GetCredit(*tx, ISMINE_SPENDABLE);
+        nImmatureCreditCached = pwallet->GetCredit(*this, ISMINE_SPENDABLE);
         fImmatureCreditCached = true;
         return nImmatureCreditCached;
     }
 
-    return 0;
+    return CAmountMap();
 }
 
-CAmount CWalletTx::GetAvailableCredit(bool fUseCache, const isminefilter& filter) const
+CAmountMap CWalletTx::GetAvailableCredit(bool fUseCache, const isminefilter& filter) const
 {
     if (pwallet == nullptr)
-        return 0;
+        return CAmountMap();
 
     // Must wait until coinbase is safely deep enough in the chain before valuing it
     if (IsImmatureCoinBase())
-        return 0;
+        return CAmountMap();
 
-    CAmount* cache = nullptr;
+    CAmountMap* cache = nullptr;
     bool* cache_used = nullptr;
 
     if (filter == ISMINE_SPENDABLE) {
@@ -1872,16 +1931,21 @@ CAmount CWalletTx::GetAvailableCredit(bool fUseCache, const isminefilter& filter
         return *cache;
     }
 
-    CAmount nCredit = 0;
+    CAmountMap nCredit;
     uint256 hashTx = GetHash();
     for (unsigned int i = 0; i < tx->vout.size(); i++)
     {
         if (!pwallet->IsSpent(hashTx, i))
         {
-            const CTxOut &txout = tx->vout[i];
-            nCredit += pwallet->GetCredit(txout, filter);
-            if (!MoneyRange(nCredit))
-                throw std::runtime_error(std::string(__func__) + " : value out of range");
+            if (pwallet->IsMine(tx->vout[i]) & filter) {
+                CAmount credit = std::max<CAmount>(0, GetOutputValueOut(i));
+                if (!MoneyRange(credit))
+                    throw std::runtime_error(std::string(__func__) + ": value out of range");
+
+                nCredit[GetOutputAsset(i)] += std::max<CAmount>(0, GetOutputValueOut(i));
+                if (!MoneyRange(nCredit))
+                    throw std::runtime_error(std::string(__func__) + ": value out of range");
+            }
         }
     }
 
@@ -1893,24 +1957,24 @@ CAmount CWalletTx::GetAvailableCredit(bool fUseCache, const isminefilter& filter
     return nCredit;
 }
 
-CAmount CWalletTx::GetImmatureWatchOnlyCredit(const bool fUseCache) const
+CAmountMap CWalletTx::GetImmatureWatchOnlyCredit(const bool fUseCache) const
 {
     if (IsImmatureCoinBase() && IsInMainChain()) {
         if (fUseCache && fImmatureWatchCreditCached)
             return nImmatureWatchCreditCached;
-        nImmatureWatchCreditCached = pwallet->GetCredit(*tx, ISMINE_WATCH_ONLY);
+        nImmatureWatchCreditCached = pwallet->GetCredit(*this, ISMINE_WATCH_ONLY);
         fImmatureWatchCreditCached = true;
         return nImmatureWatchCreditCached;
     }
 
-    return 0;
+    return CAmountMap();
 }
 
-CAmount CWalletTx::GetChange() const
+CAmountMap CWalletTx::GetChange() const
 {
     if (fChangeCached)
         return nChangeCached;
-    nChangeCached = pwallet->GetChange(*tx);
+    nChangeCached = pwallet->GetChange(*this);
     fChangeCached = true;
     return nChangeCached;
 }
@@ -2019,9 +2083,9 @@ void CWallet::ResendWalletTransactions(int64_t nBestBlockTime, CConnman* connman
  */
 
 
-CAmount CWallet::GetBalance(const isminefilter& filter, const int min_depth) const
+CAmountMap CWallet::GetBalance(const isminefilter& filter, const int min_depth) const
 {
-    CAmount nTotal = 0;
+    CAmountMap nTotal;
     {
         LOCK2(cs_main, cs_wallet);
         for (const auto& entry : mapWallet)
@@ -2036,9 +2100,9 @@ CAmount CWallet::GetBalance(const isminefilter& filter, const int min_depth) con
     return nTotal;
 }
 
-CAmount CWallet::GetUnconfirmedBalance() const
+CAmountMap CWallet::GetUnconfirmedBalance() const
 {
-    CAmount nTotal = 0;
+    CAmountMap nTotal;
     {
         LOCK2(cs_main, cs_wallet);
         for (const auto& entry : mapWallet)
@@ -2051,9 +2115,9 @@ CAmount CWallet::GetUnconfirmedBalance() const
     return nTotal;
 }
 
-CAmount CWallet::GetImmatureBalance() const
+CAmountMap CWallet::GetImmatureBalance() const
 {
-    CAmount nTotal = 0;
+    CAmountMap nTotal;
     {
         LOCK2(cs_main, cs_wallet);
         for (const auto& entry : mapWallet)
@@ -2065,9 +2129,9 @@ CAmount CWallet::GetImmatureBalance() const
     return nTotal;
 }
 
-CAmount CWallet::GetUnconfirmedWatchOnlyBalance() const
+CAmountMap CWallet::GetUnconfirmedWatchOnlyBalance() const
 {
-    CAmount nTotal = 0;
+    CAmountMap nTotal;
     {
         LOCK2(cs_main, cs_wallet);
         for (const auto& entry : mapWallet)
@@ -2080,9 +2144,9 @@ CAmount CWallet::GetUnconfirmedWatchOnlyBalance() const
     return nTotal;
 }
 
-CAmount CWallet::GetImmatureWatchOnlyBalance() const
+CAmountMap CWallet::GetImmatureWatchOnlyBalance() const
 {
-    CAmount nTotal = 0;
+    CAmountMap nTotal;
     {
         LOCK2(cs_main, cs_wallet);
         for (const auto& entry : mapWallet)
@@ -2100,11 +2164,11 @@ CAmount CWallet::GetImmatureWatchOnlyBalance() const
 // wallet, and then subtracts the values of TxIns spending from the wallet. This
 // also has fewer restrictions on which unconfirmed transactions are considered
 // trusted.
-CAmount CWallet::GetLegacyBalance(const isminefilter& filter, int minDepth) const
+CAmountMap CWallet::GetLegacyBalance(const isminefilter& filter, int minDepth) const
 {
     LOCK2(cs_main, cs_wallet);
 
-    CAmount balance = 0;
+    CAmountMap balance;
     for (const auto& entry : mapWallet) {
         const CWalletTx& wtx = entry.second;
         const int depth = wtx.GetDepthInMainChain();
@@ -2114,13 +2178,22 @@ CAmount CWallet::GetLegacyBalance(const isminefilter& filter, int minDepth) cons
 
         // Loop through tx outputs and add incoming payments. For outgoing txs,
         // treat change outputs specially, as part of the amount debited.
-        CAmount debit = wtx.GetDebit(filter);
-        const bool outgoing = debit > 0;
-        for (const CTxOut& out : wtx.tx->vout) {
+        CAmountMap debit = wtx.GetDebit(filter);
+        const bool outgoing = debit > CAmountMap();
+        for (unsigned int i = 0; i < wtx.tx->vout.size(); ++i) {
+            const CTxOut& out = wtx.tx->vout[i];
             if (outgoing && IsChange(out)) {
-                debit -= out.nValue;
+                CAmount amt = wtx.GetOutputValueOut(i);
+                if (amt < 0) {
+                    continue;
+                }
+                debit[wtx.GetOutputAsset(i)] -= amt;
             } else if (IsMine(out) & filter && depth >= minDepth) {
-                balance += out.nValue;
+                CAmount amt = wtx.GetOutputValueOut(i);
+                if (amt < 0) {
+                    continue;
+                }
+                balance[wtx.GetOutputAsset(i)] += amt;
             }
         }
 
@@ -2133,22 +2206,26 @@ CAmount CWallet::GetLegacyBalance(const isminefilter& filter, int minDepth) cons
     return balance;
 }
 
-CAmount CWallet::GetAvailableBalance(const CCoinControl* coinControl) const
+CAmountMap CWallet::GetAvailableBalance(const CCoinControl* coinControl) const
 {
     LOCK2(cs_main, cs_wallet);
 
-    CAmount balance = 0;
+    CAmountMap balance;
     std::vector<COutput> vCoins;
     AvailableCoins(vCoins, true, coinControl);
     for (const COutput& out : vCoins) {
         if (out.fSpendable) {
-            balance += out.tx->tx->vout[out.i].nValue;
+            CAmount amt = out.tx->GetOutputValueOut(out.i);
+            if (amt < 0) {
+                continue;
+            }
+            balance[out.tx->GetOutputAsset(out.i)] += amt;
         }
     }
     return balance;
 }
 
-void CWallet::AvailableCoins(std::vector<COutput> &vCoins, bool fOnlySafe, const CCoinControl *coinControl, const CAmount &nMinimumAmount, const CAmount &nMaximumAmount, const CAmount &nMinimumSumAmount, const uint64_t nMaximumCount, const int nMinDepth, const int nMaxDepth) const
+void CWallet::AvailableCoins(std::vector<COutput> &vCoins, bool fOnlySafe, const CCoinControl *coinControl, const CAmount &nMinimumAmount, const CAmount &nMaximumAmount, const CAmount &nMinimumSumAmount, const uint64_t nMaximumCount, const int nMinDepth, const int nMaxDepth, const CAsset* asset_filter) const
 {
     AssertLockHeld(cs_main);
     AssertLockHeld(cs_wallet);
@@ -2217,7 +2294,12 @@ void CWallet::AvailableCoins(std::vector<COutput> &vCoins, bool fOnlySafe, const
             continue;
 
         for (unsigned int i = 0; i < pcoin->tx->vout.size(); i++) {
-            if (pcoin->tx->vout[i].nValue < nMinimumAmount || pcoin->tx->vout[i].nValue > nMaximumAmount)
+            CAmount outValue = pcoin->GetOutputValueOut(i);
+            CAsset asset = pcoin->GetOutputAsset(i);
+            if (asset_filter && asset != *asset_filter) {
+                continue;
+            }
+            if (outValue < nMinimumAmount || outValue > nMaximumAmount)
                 continue;
 
             if (coinControl && coinControl->HasSelected() && !coinControl->fAllowOtherInputs && !coinControl->IsSelected(COutPoint(entry.first, i)))
@@ -2242,7 +2324,7 @@ void CWallet::AvailableCoins(std::vector<COutput> &vCoins, bool fOnlySafe, const
 
             // Checks the sum amount of all UTXO's.
             if (nMinimumSumAmount != MAX_MONEY) {
-                nTotal += pcoin->tx->vout[i].nValue;
+                nTotal += outValue;
 
                 if (nTotal >= nMinimumSumAmount) {
                     return;
@@ -2312,14 +2394,34 @@ const CTxOut& CWallet::FindNonChangeParentOutput(const CTransaction& tx, int out
     return ptx->vout[n];
 }
 
-bool CWallet::SelectCoinsMinConf(const CAmount& nTargetValue, const CoinEligibilityFilter& eligibility_filter, std::vector<OutputGroup> groups,
-                                 std::set<CInputCoin>& setCoinsRet, CAmount& nValueRet, const CoinSelectionParams& coin_selection_params, bool& bnb_used) const
+bool CWallet::SelectCoinsMinConf(const CAmountMap& mapTargetValue, const CoinEligibilityFilter& eligibility_filter, std::vector<OutputGroup> groups,
+                                 std::set<CInputCoin>& setCoinsRet, CAmountMap& mapValueRet, const CoinSelectionParams& coin_selection_params, bool& bnb_used) const
 {
     setCoinsRet.clear();
-    nValueRet = 0;
+    mapValueRet.clear();
 
     std::vector<OutputGroup> utxo_pool;
-    if (coin_selection_params.use_bnb) {
+    if (coin_selection_params.use_bnb && mapTargetValue.size() == 1) {
+        // ELEMENTS:
+        CAsset asset = mapTargetValue.begin()->first;
+        CAmount nTargetValue = mapTargetValue.begin()->second;
+        // Get output groups that only contain this asset.
+        std::vector<OutputGroup> asset_groups;
+        for (OutputGroup g : groups) {
+            bool add = true;
+            for (CInputCoin c : g.m_outputs) {
+                if (c.asset != asset) {
+                    add = false;
+                    break;
+                }
+            }
+
+            if (add) {
+                asset_groups.push_back(g);
+            }
+        }
+        // END ELEMENTS
+
         // Get long term estimate
         FeeCalculation feeCalc;
         CCoinControl temp;
@@ -2330,7 +2432,7 @@ bool CWallet::SelectCoinsMinConf(const CAmount& nTargetValue, const CoinEligibil
         CAmount cost_of_change = GetDiscardRate(*this, ::feeEstimator).GetFee(coin_selection_params.change_spend_size) + coin_selection_params.effective_fee.GetFee(coin_selection_params.change_output_size);
 
         // Filter by the min conf specs and add to utxo_pool and calculate effective value
-        for (OutputGroup& group : groups) {
+        for (OutputGroup& group : asset_groups) {
             if (!group.EligibleForSpending(eligibility_filter)) continue;
 
             group.fee = 0;
@@ -2338,7 +2440,7 @@ bool CWallet::SelectCoinsMinConf(const CAmount& nTargetValue, const CoinEligibil
             group.effective_value = 0;
             for (auto it = group.m_outputs.begin(); it != group.m_outputs.end(); ) {
                 const CInputCoin& coin = *it;
-                CAmount effective_value = coin.txout.nValue - (coin.m_input_bytes < 0 ? 0 : coin_selection_params.effective_fee.GetFee(coin.m_input_bytes));
+                CAmount effective_value = coin.value - (coin.m_input_bytes < 0 ? 0 : coin_selection_params.effective_fee.GetFee(coin.m_input_bytes));
                 // Only include outputs that are positive effective value (i.e. not dust)
                 if (effective_value > 0) {
                     group.fee += coin.m_input_bytes < 0 ? 0 : coin_selection_params.effective_fee.GetFee(coin.m_input_bytes);
@@ -2354,7 +2456,10 @@ bool CWallet::SelectCoinsMinConf(const CAmount& nTargetValue, const CoinEligibil
         // Calculate the fees for things that aren't inputs
         CAmount not_input_fees = coin_selection_params.effective_fee.GetFee(coin_selection_params.tx_noinputs_size);
         bnb_used = true;
-        return SelectCoinsBnB(utxo_pool, nTargetValue, cost_of_change, setCoinsRet, nValueRet, not_input_fees);
+        CAmount nValueRet;
+        bool ret = SelectCoinsBnB(utxo_pool, nTargetValue, cost_of_change, setCoinsRet, nValueRet, not_input_fees);
+        mapValueRet[asset] = nValueRet;
+        return ret;
     } else {
         // Filter by the min conf specs and add to utxo_pool
         for (const OutputGroup& group : groups) {
@@ -2362,11 +2467,11 @@ bool CWallet::SelectCoinsMinConf(const CAmount& nTargetValue, const CoinEligibil
             utxo_pool.push_back(group);
         }
         bnb_used = false;
-        return KnapsackSolver(nTargetValue, utxo_pool, setCoinsRet, nValueRet);
+        return KnapsackSolver(mapTargetValue, utxo_pool, setCoinsRet, mapValueRet);
     }
 }
 
-bool CWallet::SelectCoins(const std::vector<COutput>& vAvailableCoins, const CAmount& nTargetValue, std::set<CInputCoin>& setCoinsRet, CAmount& nValueRet, const CCoinControl& coin_control, CoinSelectionParams& coin_selection_params, bool& bnb_used) const
+bool CWallet::SelectCoins(const std::vector<COutput>& vAvailableCoins, const CAmountMap& mapTargetValue, std::set<CInputCoin>& setCoinsRet, CAmountMap& mapValueRet, const CCoinControl& coin_control, CoinSelectionParams& coin_selection_params, bool& bnb_used) const
 {
     std::vector<COutput> vCoins(vAvailableCoins);
 
@@ -2380,15 +2485,20 @@ bool CWallet::SelectCoins(const std::vector<COutput>& vAvailableCoins, const CAm
         {
             if (!out.fSpendable)
                  continue;
-            nValueRet += out.tx->tx->vout[out.i].nValue;
+
+            CAmount amt = out.tx->GetOutputValueOut(out.i);
+            if (amt < 0) {
+                continue;
+            }
+            mapValueRet[out.tx->GetOutputAsset(out.i)] += amt;
             setCoinsRet.insert(out.GetInputCoin());
         }
-        return (nValueRet >= nTargetValue);
+        return (mapValueRet >= mapTargetValue);
     }
 
     // calculate value from preset inputs and store them
     std::set<CInputCoin> setPresetCoins;
-    CAmount nValueFromPresetInputs = 0;
+    CAmountMap mapValueFromPresetInputs;
 
     std::vector<COutPoint> vPresetInputs;
     coin_control.ListSelected(vPresetInputs);
@@ -2405,9 +2515,14 @@ bool CWallet::SelectCoins(const std::vector<COutput>& vAvailableCoins, const CAm
             // Clearly invalid input, fail
             if (pcoin->tx->vout.size() <= outpoint.n)
                 return false;
+
             // Just to calculate the marginal byte size
-            nValueFromPresetInputs += pcoin->tx->vout[outpoint.n].nValue;
-            setPresetCoins.insert(CInputCoin(pcoin->tx, outpoint.n));
+            CAmount amt = pcoin->GetOutputValueOut(outpoint.n);
+            if (amt < 0) {
+                continue;
+            }
+            mapValueFromPresetInputs[pcoin->GetOutputAsset(outpoint.n)] += amt;
+            setPresetCoins.insert(CInputCoin(pcoin, outpoint.n));
         } else
             return false; // TODO: Allow non-wallet inputs
     }
@@ -2421,13 +2536,23 @@ bool CWallet::SelectCoins(const std::vector<COutput>& vAvailableCoins, const CAm
             ++it;
     }
 
+    // ELEMENTS: filter coins for assets we are interested in; always keep policyAsset for fees
+    for (std::vector<COutput>::iterator it = vCoins.begin(); it != vCoins.end() && coin_control.HasSelected();) {
+        CAsset asset = it->GetInputCoin().asset;
+        if (asset != ::policyAsset && mapTargetValue.find(asset) == mapTargetValue.end()) {
+            it = vCoins.erase(it);
+        } else {
+            ++it;
+        }
+    }
+
     // form groups from remaining coins; note that preset coins will not
     // automatically have their associated (same address) coins included
     if (coin_control.m_avoid_partial_spends && vCoins.size() > OUTPUT_GROUP_MAX_ENTRIES) {
         // Cases where we have 11+ outputs all pointing to the same destination may result in
         // privacy leaks as they will potentially be deterministically sorted. We solve that by
         // explicitly shuffling the outputs before processing
-        std::shuffle(vCoins.begin(), vCoins.end(), FastRandomContext());
+        Shuffle(vCoins.begin(), vCoins.end(), FastRandomContext());
     }
     std::vector<OutputGroup> groups = GroupOutputs(vCoins, !coin_control.m_avoid_partial_spends);
 
@@ -2435,20 +2560,32 @@ bool CWallet::SelectCoins(const std::vector<COutput>& vAvailableCoins, const CAm
     size_t max_descendants = (size_t)std::max<int64_t>(1, gArgs.GetArg("-limitdescendantcount", DEFAULT_DESCENDANT_LIMIT));
     bool fRejectLongChains = gArgs.GetBoolArg("-walletrejectlongchains", DEFAULT_WALLET_REJECT_LONG_CHAINS);
 
-    bool res = nTargetValue <= nValueFromPresetInputs ||
-        SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, CoinEligibilityFilter(1, 6, 0), groups, setCoinsRet, nValueRet, coin_selection_params, bnb_used) ||
-        SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, CoinEligibilityFilter(1, 1, 0), groups, setCoinsRet, nValueRet, coin_selection_params, bnb_used) ||
-        (m_spend_zero_conf_change && SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, CoinEligibilityFilter(0, 1, 2), groups, setCoinsRet, nValueRet, coin_selection_params, bnb_used)) ||
-        (m_spend_zero_conf_change && SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, CoinEligibilityFilter(0, 1, std::min((size_t)4, max_ancestors/3), std::min((size_t)4, max_descendants/3)), groups, setCoinsRet, nValueRet, coin_selection_params, bnb_used)) ||
-        (m_spend_zero_conf_change && SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, CoinEligibilityFilter(0, 1, max_ancestors/2, max_descendants/2), groups, setCoinsRet, nValueRet, coin_selection_params, bnb_used)) ||
-        (m_spend_zero_conf_change && SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, CoinEligibilityFilter(0, 1, max_ancestors-1, max_descendants-1), groups, setCoinsRet, nValueRet, coin_selection_params, bnb_used)) ||
-        (m_spend_zero_conf_change && !fRejectLongChains && SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, CoinEligibilityFilter(0, 1, std::numeric_limits<uint64_t>::max()), groups, setCoinsRet, nValueRet, coin_selection_params, bnb_used));
+    // We will have to do coin selection on the difference between the target and the provided values.
+    // However, some inputs can be provided with assets that are not in the target, we need to make sure
+    // the map of the difference does not have negative values.
+    CAmountMap mapTargetMinusPreset = mapTargetValue - mapValueFromPresetInputs;
+    for (CAmountMap::const_iterator it = mapTargetMinusPreset.begin(); it != mapTargetMinusPreset.end();) {
+        if (it->second <= 0) {
+            it = mapTargetMinusPreset.erase(it);
+        } else {
+            ++it;
+        }
+    }
+
+    bool res = mapTargetValue <= mapValueFromPresetInputs ||
+        SelectCoinsMinConf(mapTargetMinusPreset, CoinEligibilityFilter(1, 6, 0), groups, setCoinsRet, mapValueRet, coin_selection_params, bnb_used) ||
+        SelectCoinsMinConf(mapTargetMinusPreset, CoinEligibilityFilter(1, 1, 0), groups, setCoinsRet, mapValueRet, coin_selection_params, bnb_used) ||
+        (m_spend_zero_conf_change && SelectCoinsMinConf(mapTargetMinusPreset, CoinEligibilityFilter(0, 1, 2), groups, setCoinsRet, mapValueRet, coin_selection_params, bnb_used)) ||
+        (m_spend_zero_conf_change && SelectCoinsMinConf(mapTargetMinusPreset, CoinEligibilityFilter(0, 1, std::min((size_t)4, max_ancestors/3), std::min((size_t)4, max_descendants/3)), groups, setCoinsRet, mapValueRet, coin_selection_params, bnb_used)) ||
+        (m_spend_zero_conf_change && SelectCoinsMinConf(mapTargetMinusPreset, CoinEligibilityFilter(0, 1, max_ancestors/2, max_descendants/2), groups, setCoinsRet, mapValueRet, coin_selection_params, bnb_used)) ||
+        (m_spend_zero_conf_change && SelectCoinsMinConf(mapTargetMinusPreset, CoinEligibilityFilter(0, 1, max_ancestors-1, max_descendants-1), groups, setCoinsRet, mapValueRet, coin_selection_params, bnb_used)) ||
+        (m_spend_zero_conf_change && !fRejectLongChains && SelectCoinsMinConf(mapTargetMinusPreset, CoinEligibilityFilter(0, 1, std::numeric_limits<uint64_t>::max()), groups, setCoinsRet, mapValueRet, coin_selection_params, bnb_used));
 
     // because SelectCoinsMinConf clears the setCoinsRet, we now add the possible inputs to the coinset
     util::insert(setCoinsRet, setPresetCoins);
 
     // add preset inputs to the total value selected
-    nValueRet += nValueFromPresetInputs;
+    mapValueRet += mapValueFromPresetInputs;
 
     return res;
 }
@@ -2465,7 +2602,7 @@ bool CWallet::SignTransaction(CMutableTransaction &tx)
             return false;
         }
         const CScript& scriptPubKey = mi->second.tx->vout[input.prevout.n].scriptPubKey;
-        const CAmount& amount = mi->second.tx->vout[input.prevout.n].nValue;
+        const CConfidentialValue& amount = mi->second.tx->vout[input.prevout.n].nValue;
         SignatureData sigdata;
         if (!ProduceSignature(*this, MutableTransactionSignatureCreator(&tx, nIn, amount, SIGHASH_ALL), scriptPubKey, sigdata)) {
             return false;
@@ -2479,11 +2616,28 @@ bool CWallet::SignTransaction(CMutableTransaction &tx)
 bool CWallet::FundTransaction(CMutableTransaction& tx, CAmount& nFeeRet, int& nChangePosInOut, std::string& strFailReason, bool lockUnspents, const std::set<int>& setSubtractFeeFromOutputs, CCoinControl coinControl)
 {
     std::vector<CRecipient> vecSend;
+    std::set<CAsset> setAssets;
+    std::vector<std::unique_ptr<CReserveKey>> vChangeKey;
 
     // Turn the txout set into a CRecipient vector.
     for (size_t idx = 0; idx < tx.vout.size(); idx++) {
         const CTxOut& txOut = tx.vout[idx];
-        CRecipient recipient = {txOut.scriptPubKey, txOut.nValue, setSubtractFeeFromOutputs.count(idx) == 1};
+
+        // ELEMENTS:
+        if (!txOut.nValue.IsExplicit() || !txOut.nAsset.IsExplicit()) {
+            strFailReason = _("Pre-funded amounts must be non-blinded");
+            return false;
+        }
+
+        // Account for the asset in the possible change destinations.
+        setAssets.insert(txOut.nAsset.GetAsset());
+
+        // Fee outputs should not be added to avoid overpayment of fees
+        if (txOut.IsFee()) {
+            continue;
+        }
+
+        CRecipient recipient = {txOut.scriptPubKey, txOut.nValue.GetAmount(), txOut.nAsset.GetAsset(), CPubKey(txOut.nNonce.vchCommitment), setSubtractFeeFromOutputs.count(idx) == 1};
         vecSend.push_back(recipient);
     }
 
@@ -2493,27 +2647,44 @@ bool CWallet::FundTransaction(CMutableTransaction& tx, CAmount& nFeeRet, int& nC
         coinControl.Select(txin.prevout);
     }
 
+    // Also account for the assets in the preset inputs.
+    std::vector<COutPoint> vPresetInputs;
+    coinControl.ListSelected(vPresetInputs);
+    for (const COutPoint& presetInput : vPresetInputs) {
+        std::map<uint256, CWalletTx>::const_iterator it = mapWallet.find(presetInput.hash);
+        if (it != mapWallet.end()) {
+            setAssets.insert(it->second.GetOutputAsset(presetInput.n));
+        }
+    }
+
+    // Then reserve a key for each asset. Account for policyAsset always.
+    setAssets.insert(::policyAsset);
+    for (size_t i = 0; i < setAssets.size(); ++i) {
+        vChangeKey.push_back(std::unique_ptr<CReserveKey>(new CReserveKey(this)));
+    }
+
     // Acquire the locks to prevent races to the new locked unspents between the
     // CreateTransaction call and LockCoin calls (when lockUnspents is true).
     LOCK2(cs_main, cs_wallet);
 
-    CReserveKey reservekey(this);
     CTransactionRef tx_new;
-    if (!CreateTransaction(vecSend, tx_new, reservekey, nFeeRet, nChangePosInOut, strFailReason, coinControl, false)) {
+    BlindDetails* blind_details = g_con_elementsmode ? new BlindDetails() : NULL;
+    if (!CreateTransaction(vecSend, tx_new, vChangeKey, nFeeRet, nChangePosInOut, strFailReason, coinControl, false, blind_details)) {
         return false;
     }
 
-    if (nChangePosInOut != -1) {
-        tx.vout.insert(tx.vout.begin() + nChangePosInOut, tx_new->vout[nChangePosInOut]);
-        // We don't have the normal Create/Commit cycle, and don't want to risk
-        // reusing change, so just remove the key from the keypool here.
-        reservekey.KeepKey();
-    }
-
-    // Copy output sizes from new transaction; they may have had the fee
-    // subtracted from them.
-    for (unsigned int idx = 0; idx < tx.vout.size(); idx++) {
-        tx.vout[idx].nValue = tx_new->vout[idx].nValue;
+    // Wipe outputs and output witness and re-add one by one
+    tx.vout.clear();
+    tx.witness.vtxoutwit.clear();
+    for (unsigned int i = 0; i < tx_new->vout.size(); i++) {
+        const CTxOut& out = tx_new->vout[i];
+        tx.vout.push_back(out);
+        if (tx_new->witness.vtxoutwit.size() > i) {
+            // We want to re-add previously existing outwitnesses
+            // even though we don't create any new ones
+            const CTxOutWitness& outwit = tx_new->witness.vtxoutwit[i];
+            tx.witness.vtxoutwit.push_back(outwit);
+        }
     }
 
     // Add new txins while keeping original txin scriptSig/order.
@@ -2558,20 +2729,132 @@ OutputType CWallet::TransactionChangeType(OutputType change_type, const std::vec
     return m_default_address_type;
 }
 
-bool CWallet::CreateTransaction(const std::vector<CRecipient>& vecSend, CTransactionRef& tx, CReserveKey& reservekey, CAmount& nFeeRet,
-                         int& nChangePosInOut, std::string& strFailReason, const CCoinControl& coin_control, bool sign)
-{
-    CAmount nValue = 0;
+// Reset all non-global blinding details.
+void resetBlindDetails(BlindDetails* det) {
+    det->i_amount_blinds.clear();
+    det->i_asset_blinds.clear();
+    det->i_assets.clear();
+    det->i_amounts.clear();
+
+    det->o_amounts.clear();
+    det->o_pubkeys.clear();
+    det->o_amount_blinds.clear();
+    det->o_assets.clear();
+    det->o_asset_blinds.clear();
+
+    det->tx_unblinded_unsigned = CMutableTransaction();
+    det->num_to_blind = 0;
+    det->change_to_blind = 0;
+    det->only_recipient_blind_index = -1;
+    det->only_change_pos = -1;
+}
+
+bool fillBlindDetails(BlindDetails* det, CWallet* wallet, CMutableTransaction& txNew, std::vector<CInputCoin>& selected_coins, std::string& strFailReason) {
+    int num_inputs_blinded = 0;
+
+    // Fill in input blinding details
+    for (const CInputCoin& coin : selected_coins) {
+        det->i_amount_blinds.push_back(coin.bf_value);
+        det->i_asset_blinds.push_back(coin.bf_asset);
+        det->i_assets.push_back(coin.asset);
+        det->i_amounts.push_back(coin.value);
+        if (coin.txout.nValue.IsCommitment() || coin.txout.nAsset.IsCommitment()) {
+            num_inputs_blinded++;
+        }
+    }
+    // Fill in output blinding details
+    for (size_t nOut = 0; nOut < txNew.vout.size(); nOut++) {
+        //TODO(CA) consider removing all blind setting before BlindTransaction as they get cleared anyway
+        det->o_amount_blinds.push_back(uint256());
+        det->o_asset_blinds.push_back(uint256());
+        det->o_assets.push_back(txNew.vout[nOut].nAsset.GetAsset());
+        det->o_amounts.push_back(txNew.vout[nOut].nValue.GetAmount());
+    }
+
+    // There are a few edge-cases of blinding we need to take care of
+    //
+    // First, if there are blinded inputs but not outputs to blind
+    // We need this to go through, even though no privacy is gained.
+    if (num_inputs_blinded > 0 &&  det->num_to_blind == 0) {
+        // We need to make sure to dupe an asset that is in input set
+        //TODO Have blinding do some extremely minimal rangeproof
+        CTxOut newTxOut(det->o_assets.back(), 0, CScript() << OP_RETURN);
+        txNew.vout.push_back(newTxOut);
+        det->o_pubkeys.push_back(wallet->GetBlindingPubKey(newTxOut.scriptPubKey));
+        det->o_amount_blinds.push_back(uint256());
+        det->o_asset_blinds.push_back(uint256());
+        det->o_amounts.push_back(0);
+        det->o_assets.push_back(det->o_assets.back());
+        det->num_to_blind++;
+        wallet->WalletLogPrintf("Adding OP_RETURN output to complete blinding since there are %d blinded inputs and no blinded outputs\n", num_inputs_blinded);
+
+        // No blinded inputs, but 1 blinded output
+    } else if (num_inputs_blinded == 0 && det->num_to_blind == 1) {
+        if (det->change_to_blind == 1) {
+            // Only 1 blinded change, unblind the change
+            //TODO Split up change instead if possible
+            if (det->ignore_blind_failure) {
+                det->num_to_blind--;
+                det->change_to_blind--;
+                txNew.vout[det->only_change_pos].nNonce.SetNull();
+                det->o_pubkeys[det->only_change_pos] = CPubKey();
+                det->o_amount_blinds[det->only_change_pos] = uint256();
+                det->o_asset_blinds[det->only_change_pos] = uint256();
+                wallet->WalletLogPrintf("Unblinding change at index %d due to lack of inputs and other outputs being blinded.\n", det->only_change_pos);
+            } else {
+                strFailReason = _("Change output could not be blinded as there are no blinded inputs and no other blinded outputs.");
+                return false;
+            }
+        } else {
+            // 1 blinded destination
+            // TODO Attempt to get a blinded input, OR add unblinded coin to make blinded change
+            assert(det->only_recipient_blind_index != -1);
+            if (det->ignore_blind_failure) {
+                det->num_to_blind--;
+                txNew.vout[det->only_recipient_blind_index].nNonce.SetNull();
+                det->o_pubkeys[det->only_recipient_blind_index] = CPubKey();
+                det->o_amount_blinds[det->only_recipient_blind_index] = uint256();
+                det->o_asset_blinds[det->only_recipient_blind_index] = uint256();
+                wallet->WalletLogPrintf("Unblinding single blinded output at index %d due to lack of inputs and other outputs being blinded.\n", det->only_recipient_blind_index);
+            } else {
+                strFailReason = _("Transaction output could not be blinded as there are no blinded inputs and no other blinded outputs.");
+                return false;
+            }
+        }
+    }
+    // All other combinations should work.
+    return true;
+}
+
+bool CWallet::CreateTransaction(const std::vector<CRecipient>& vecSend, CTransactionRef& tx, std::vector<std::unique_ptr<CReserveKey>>& reserveKeys, CAmount& nFeeRet, int& nChangePosInOut, std::string& strFailReason, const CCoinControl& coin_control, bool sign, BlindDetails* blind_details, const IssuanceDetails* issuance_details) {
+    if (blind_details || issuance_details) {
+        assert(g_con_elementsmode);
+    }
+
+    CAmountMap mapValue;
+    // Always assume that we are at least sending policyAsset.
+    mapValue[::policyAsset] = 0;
     int nChangePosRequest = nChangePosInOut;
+    std::map<CAsset, int> vChangePosInOut;
     unsigned int nSubtractFeeFromAmount = 0;
+
     for (const auto& recipient : vecSend)
     {
-        if (nValue < 0 || recipient.nAmount < 0)
-        {
+        // Skip over issuance outputs, no need to select those coins
+        if (recipient.asset == CAsset(uint256S("1")) || recipient.asset == CAsset(uint256S("2"))) {
+            continue;
+        }
+
+        if (g_con_elementsmode && recipient.asset.IsNull()) {
+            strFailReason = _("No asset provided for recipient");
+            return false;
+        }
+
+        if (mapValue[recipient.asset] < 0 || recipient.nAmount < 0) {
             strFailReason = _("Transaction amounts must not be negative");
             return false;
         }
-        nValue += recipient.nAmount;
+        mapValue[recipient.asset] += recipient.nAmount;
 
         if (recipient.fSubtractFeeFromAmount)
             nSubtractFeeFromAmount++;
@@ -2620,20 +2903,26 @@ bool CWallet::CreateTransaction(const std::vector<CRecipient>& vecSend, CTransac
     int nBytes;
     {
         std::set<CInputCoin> setCoins;
+
+        // Preserve order of selected inputs for surjection proofs
+        std::vector<CInputCoin> selected_coins;
+
+        // A map that keeps track of the change script for each asset and also
+        // the index of the reserveKeys used for that script (-1 if none).
+        std::map<CAsset, std::pair<int, CScript>> mapScriptChange;
+
         LOCK2(cs_main, cs_wallet);
         {
             std::vector<COutput> vAvailableCoins;
             AvailableCoins(vAvailableCoins, true, &coin_control);
             CoinSelectionParams coin_selection_params; // Parameters for coin selection, init with dummy
 
-            // Create change script that will be used if we need change
-            // TODO: pass in scriptChange instead of reservekey so
-            // change transaction isn't always pay-to-bitcoin-address
-            CScript scriptChange;
-
-            // coin control: send change to custom address
-            if (!boost::get<CNoDestination>(&coin_control.destChange)) {
-                scriptChange = GetScriptForDestination(coin_control.destChange);
+            mapScriptChange.clear();
+            if (coin_control.destChange.size() > 0) {
+                for (const std::pair<CAsset, CTxDestination>& dest : coin_control.destChange) {
+                    // No need to test we cover all assets.  We produce error for that later.
+                    mapScriptChange[dest.first] = std::pair<int, CScript>(-1, GetScriptForDestination(dest.second));
+                }
             } else { // no coin control: send change to newly generated address
                 // Note: We use a new key here to keep it from being obvious which side is the change.
                 //  The drawback is that by not reusing a previous key, the change may be lost if a
@@ -2647,31 +2936,73 @@ bool CWallet::CreateTransaction(const std::vector<CRecipient>& vecSend, CTransac
                     strFailReason = _("Can't generate a change-address key. Private keys are disabled for this wallet.");
                     return false;
                 }
-                CPubKey vchPubKey;
-                bool ret;
-                ret = reservekey.GetReservedKey(vchPubKey, true);
-                if (!ret)
-                {
-                    strFailReason = _("Keypool ran out, please call keypoolrefill first");
-                    return false;
-                }
 
                 const OutputType change_type = TransactionChangeType(coin_control.m_change_type ? *coin_control.m_change_type : m_default_change_type, vecSend);
+                // One change script per output asset.
+                size_t index = 0;
+                for (const std::pair<CAsset, CAmount>& value : mapValue) {
+                    CPubKey vchPubKey;
+                    if (index >= reserveKeys.size() || !reserveKeys[index]->GetReservedKey(vchPubKey, true)) {
+                        strFailReason = _("Keypool ran out, please call keypoolrefill first");
+                        return false;
+                    }
+
+                    LearnRelatedScripts(vchPubKey, change_type);
+                    mapScriptChange[value.first] = std::pair<int, CScript>(index,
+                            GetScriptForDestination(GetDestinationForKey(vchPubKey, change_type)));
+                    ++index;
+                }
+
+                // Also make sure we have change scripts for the pre-selected inputs.
+                std::vector<COutPoint> vPresetInputs;
+                coin_control.ListSelected(vPresetInputs);
+                for (const COutPoint& presetInput : vPresetInputs) {
+                    std::map<uint256, CWalletTx>::const_iterator it = mapWallet.find(presetInput.hash);
+                    if (it == mapWallet.end()) {
+                        // Ignore this here, will fail more gracefully later.
+                        continue;
+                    }
+
+                    CAsset asset = it->second.GetOutputAsset(presetInput.n);
+                    if (mapScriptChange.find(asset) != mapScriptChange.end()) {
+                        // This asset already has a change script.
+                        continue;
+                    }
+
+                    CPubKey vchPubKey;
+                    if (index >= reserveKeys.size() || !reserveKeys[index]->GetReservedKey(vchPubKey, true)) {
+                        strFailReason = _("Keypool ran out, please call keypoolrefill first");
+                        return false;
+                    }
 
-                LearnRelatedScripts(vchPubKey, change_type);
-                scriptChange = GetScriptForDestination(GetDestinationForKey(vchPubKey, change_type));
+                    LearnRelatedScripts(vchPubKey, change_type);
+                    mapScriptChange[asset] = std::pair<int, CScript>(index,
+                            GetScriptForDestination(GetDestinationForKey(vchPubKey, change_type)));
+                    ++index;
+                }
             }
-            CTxOut change_prototype_txout(0, scriptChange);
+            assert(mapScriptChange.size() > 0);
+
+            CTxOut change_prototype_txout(mapScriptChange.begin()->first, 0, mapScriptChange.begin()->second.second);
+            // TODO CA: Set this for each change output
             coin_selection_params.change_output_size = GetSerializeSize(change_prototype_txout);
+            if (g_con_elementsmode) {
+                // Assume blinded output for coin selection purposes. Over-paying is ok!
+                change_prototype_txout.nAsset.vchCommitment.resize(33);
+                coin_selection_params.change_output_size = GetSerializeSize(change_prototype_txout);
+                coin_selection_params.change_output_size += DEFAULT_RANGEPROOF_SIZE/WITNESS_SCALE_FACTOR;
+            }
 
             CFeeRate discard_rate = GetDiscardRate(*this, ::feeEstimator);
 
             // Get the fee rate to use effective values in coin selection
             CFeeRate nFeeRateNeeded = GetMinimumFeeRate(*this, coin_control, ::mempool, ::feeEstimator, &feeCalc);
 
-            nFeeRet = 0;
+            // ELEMENTS:
+            // Start with tiny non-zero fee for issuance entropy and loop until there is enough fee
+            nFeeRet = 1;
             bool pick_new_inputs = true;
-            CAmount nValueIn = 0;
+            CAmountMap mapValueIn;
 
             // BnB selector is the only selector used when this is true.
             // That should only happen on the first pass through the loop.
@@ -2679,40 +3010,61 @@ bool CWallet::CreateTransaction(const std::vector<CRecipient>& vecSend, CTransac
             // Start with no fee and loop until there is enough fee
             while (true)
             {
-                nChangePosInOut = nChangePosRequest;
+                if (blind_details) {
+                    // Clear out previous blinding/data info as needed
+                    resetBlindDetails(blind_details);
+                }
+
+                // We need to output the position of the policyAsset change output.
+                // So we keep track of the change position of all assets
+                // individually and set the export variable in the end.
+                vChangePosInOut.clear();
+                if (nChangePosRequest >= 0) {
+                    vChangePosInOut[::policyAsset] = nChangePosRequest;
+                }
+
                 txNew.vin.clear();
                 txNew.vout.clear();
+                txNew.witness.SetNull();
                 bool fFirst = true;
 
-                CAmount nValueToSelect = nValue;
+                CAmountMap mapValueToSelect = mapValue;
                 if (nSubtractFeeFromAmount == 0)
-                    nValueToSelect += nFeeRet;
+                    mapValueToSelect[::policyAsset] += nFeeRet;
 
                 // vouts to the payees
                 coin_selection_params.tx_noinputs_size = 11; // Static vsize overhead + outputs vsize. 4 nVersion, 4 nLocktime, 1 input count, 1 output count, 1 witness overhead (dummy, flag, stack size)
-                for (const auto& recipient : vecSend)
+                for (const CRecipient& recipient : vecSend)
                 {
-                    CTxOut txout(recipient.nAmount, recipient.scriptPubKey);
+                    CTxOut txout(recipient.asset, recipient.nAmount, recipient.scriptPubKey);
+                    txout.nNonce.vchCommitment = std::vector<unsigned char>(recipient.confidentiality_key.begin(), recipient.confidentiality_key.end());
 
                     if (recipient.fSubtractFeeFromAmount)
                     {
+                        if (recipient.asset != policyAsset) {
+                            strFailReason = strprintf("Wallet does not support more than one type of fee at a time, therefore can not subtract fee from address amount, which is of a different asset id. fee asset: %s recipient asset: %s", policyAsset.GetHex(), recipient.asset.GetHex());
+                            return false;
+                        }
+
                         assert(nSubtractFeeFromAmount != 0);
-                        txout.nValue -= nFeeRet / nSubtractFeeFromAmount; // Subtract fee equally from each selected recipient
+                        txout.nValue = txout.nValue.GetAmount() - nFeeRet / nSubtractFeeFromAmount; // Subtract fee equally from each selected recipient
 
                         if (fFirst) // first receiver pays the remainder not divisible by output count
                         {
                             fFirst = false;
-                            txout.nValue -= nFeeRet % nSubtractFeeFromAmount;
+                            txout.nValue = txout.nValue.GetAmount() - nFeeRet % nSubtractFeeFromAmount;
                         }
                     }
                     // Include the fee cost for outputs. Note this is only used for BnB right now
                     coin_selection_params.tx_noinputs_size += ::GetSerializeSize(txout, PROTOCOL_VERSION);
-
-                    if (IsDust(txout, ::dustRelayFee))
+                    // ELEMENTS: Core's logic isn't great here. We should be computing
+                    // cost of making output + future spend. We're not as concerned
+                    // about dust anyways, so let's focus upstream.
+                    if (recipient.asset == policyAsset && IsDust(txout, ::dustRelayFee))
                     {
                         if (recipient.fSubtractFeeFromAmount && nFeeRet > 0)
                         {
-                            if (txout.nValue < 0)
+                            if (txout.nValue.GetAmount() < 0)
                                 strFailReason = _("The transaction amount is too small to pay the fee");
                             else
                                 strFailReason = _("The transaction amount is too small to send after the fee has been deducted");
@@ -2722,16 +3074,23 @@ bool CWallet::CreateTransaction(const std::vector<CRecipient>& vecSend, CTransac
                         return false;
                     }
                     txNew.vout.push_back(txout);
+                    if (blind_details) {
+                        blind_details->o_pubkeys.push_back(recipient.confidentiality_key);
+                        if (blind_details->o_pubkeys.back().IsFullyValid()) {
+                            blind_details->num_to_blind++;
+                            blind_details->only_recipient_blind_index = txNew.vout.size()-1;
+                        }
+                    }
                 }
 
                 // Choose coins to use
                 bool bnb_used;
                 if (pick_new_inputs) {
-                    nValueIn = 0;
+                    mapValueIn.clear();
                     setCoins.clear();
                     coin_selection_params.change_spend_size = CalculateMaximumSignedInputSize(change_prototype_txout, this);
                     coin_selection_params.effective_fee = nFeeRateNeeded;
-                    if (!SelectCoins(vAvailableCoins, nValueToSelect, setCoins, nValueIn, coin_control, coin_selection_params, bnb_used))
+                    if (!SelectCoins(vAvailableCoins, mapValueToSelect, setCoins, mapValueIn, coin_control, coin_selection_params, bnb_used))
                     {
                         // If BnB was used, it was the first pass. No longer the first pass and continue loop with knapsack.
                         if (bnb_used) {
@@ -2745,44 +3104,193 @@ bool CWallet::CreateTransaction(const std::vector<CRecipient>& vecSend, CTransac
                     }
                 }
 
-                const CAmount nChange = nValueIn - nValueToSelect;
-                if (nChange > 0)
-                {
+                const CAmountMap mapChange = mapValueIn - mapValueToSelect;
+
+                for(const std::pair<CAsset, CAmount>& assetChange : mapChange) {
+                    if (assetChange.second == 0) {
+                        vChangePosInOut.erase(assetChange.first);
+                        continue;
+                    }
+
                     // Fill a vout to ourself
-                    CTxOut newTxOut(nChange, scriptChange);
+                    const std::map<CAsset, std::pair<int, CScript>>::const_iterator itScript = mapScriptChange.find(assetChange.first);
+                    if (itScript == mapScriptChange.end()) {
+                        strFailReason = strprintf("No change destination provided for asset %s", assetChange.first.GetHex());
+                        return false;
+                    }
+
+                    CTxOut newTxOut(assetChange.first, assetChange.second, itScript->second.second);
 
                     // Never create dust outputs; if we would, just
                     // add the dust to the fee.
                     // The nChange when BnB is used is always going to go to fees.
-                    if (IsDust(newTxOut, discard_rate) || bnb_used)
+                    if (assetChange.first == policyAsset && (IsDust(newTxOut, discard_rate) || bnb_used))
                     {
-                        nChangePosInOut = -1;
-                        nFeeRet += nChange;
+                        vChangePosInOut.erase(assetChange.first);
+                        nFeeRet += assetChange.second;
                     }
                     else
                     {
-                        if (nChangePosInOut == -1)
+                        std::map<CAsset, int>::const_iterator itPos = vChangePosInOut.find(assetChange.first);
+                        if (itPos == vChangePosInOut.end())
                         {
                             // Insert change txn at random position:
-                            nChangePosInOut = GetRandInt(txNew.vout.size()+1);
+                            int newPos = GetRandInt(txNew.vout.size()+1);
+
+                            // Update existing entries in vChangePos that have been moved.
+                            for (std::map<CAsset, int>::iterator it = vChangePosInOut.begin(); it != vChangePosInOut.end(); ++it) {
+                                if (it->second >= newPos) {
+                                    it->second++;
+                                }
+                            }
+
+                            vChangePosInOut[assetChange.first] = newPos;
                         }
-                        else if ((unsigned int)nChangePosInOut > txNew.vout.size())
+                        else if ((unsigned int)itPos->second > txNew.vout.size())
                         {
                             strFailReason = _("Change index out of range");
                             return false;
                         }
 
-                        std::vector<CTxOut>::iterator position = txNew.vout.begin()+nChangePosInOut;
+                        std::vector<CTxOut>::iterator position = txNew.vout.begin()+vChangePosInOut[assetChange.first];
                         txNew.vout.insert(position, newTxOut);
+                        CPubKey blind_pub = GetBlindingPubKey(itScript->second.second);
+                        if (blind_details) {
+                            blind_details->o_pubkeys.insert(blind_details->o_pubkeys.begin() + vChangePosInOut[assetChange.first], blind_pub);
+                            assert(blind_pub.IsFullyValid());
+                            blind_details->num_to_blind++;
+                            blind_details->change_to_blind++;
+                            blind_details->only_change_pos = vChangePosInOut[assetChange.first];
+                        }
                     }
+                }
+                // Set the correct nChangePosInOut for output.  Should be policyAsset's position.
+                std::map<CAsset, int>::const_iterator itPos = vChangePosInOut.find(::policyAsset);
+                if (itPos != vChangePosInOut.end()) {
+                    nChangePosInOut = itPos->second;
                 } else {
+                    // no policy change inserted; others assets may have been
                     nChangePosInOut = -1;
                 }
 
+                // Add fee output.
+                if (g_con_elementsmode) {
+                    CTxOut fee(::policyAsset, nFeeRet, CScript());
+                    assert(fee.IsFee());
+                    txNew.vout.push_back(fee);
+                    if (blind_details) {
+                        blind_details->o_pubkeys.push_back(CPubKey());
+                    }
+                }
+
+                // Set token input if reissuing
+                int reissuance_index = -1;
+                uint256 token_blinding;
+
+                // Elements: Shuffle here to preserve random ordering for surjection proofs
+                selected_coins = std::vector<CInputCoin>(setCoins.begin(), setCoins.end());
+                Shuffle(selected_coins.begin(), selected_coins.end(), FastRandomContext());
+
                 // Dummy fill vin for maximum size estimation
                 //
-                for (const auto& coin : setCoins) {
-                    txNew.vin.push_back(CTxIn(coin.outpoint,CScript()));
+                for (const CInputCoin& coin : selected_coins) {
+                    txNew.vin.push_back(CTxIn(coin.outpoint, CScript()));
+
+                    if (issuance_details && coin.asset == issuance_details->reissuance_token) {
+                        reissuance_index = txNew.vin.size() - 1;
+                        token_blinding = coin.bf_asset;
+                    }
+                }
+
+                std::vector<CKey> issuance_asset_keys;
+                std::vector<CKey> issuance_token_keys;
+                if (issuance_details) {
+                    // Fill in issuances now that inputs are set
+                    assert(txNew.vin.size() > 0);
+                    int asset_index = -1;
+                    int token_index = -1;
+                    for (unsigned int i = 0; i < txNew.vout.size(); i++) {
+                        if (txNew.vout[i].nAsset.IsExplicit() && txNew.vout[i].nAsset.GetAsset()  == CAsset(uint256S("1"))) {
+                            asset_index = i;
+                        } else if (txNew.vout[i].nAsset.IsExplicit() && txNew.vout[i].nAsset.GetAsset() == CAsset(uint256S("2"))) {
+                            token_index = i;
+                        }
+                    }
+                    // Initial issuance request
+                    if (issuance_details->reissuance_asset.IsNull() && issuance_details->reissuance_token.IsNull() && (asset_index != -1 || token_index != -1)) {
+                        uint256 entropy;
+                        CAsset asset;
+                        CAsset token;
+                        //TODO take optional contract hash
+                        // Initial issuance always uses vin[0]
+                        GenerateAssetEntropy(entropy, txNew.vin[0].prevout, uint256());
+                        CalculateAsset(asset, entropy);
+                        CalculateReissuanceToken(token, entropy, issuance_details->blind_issuance);
+                        CScript blindingScript(CScript() << OP_RETURN << std::vector<unsigned char>(txNew.vin[0].prevout.hash.begin(), txNew.vin[0].prevout.hash.end()) << txNew.vin[0].prevout.n);
+                        // We're making asset outputs, fill out asset type and issuance input
+                        if (asset_index != -1) {
+                            txNew.vin[0].assetIssuance.nAmount = txNew.vout[asset_index].nValue;
+
+                            txNew.vout[asset_index].nAsset = asset;
+                            if (issuance_details->blind_issuance && blind_details) {
+                                issuance_asset_keys.push_back(GetBlindingKey(&blindingScript));
+                                blind_details->num_to_blind++;
+                            }
+                        }
+                        // We're making reissuance token outputs
+                        if (token_index != -1) {
+                            txNew.vin[0].assetIssuance.nInflationKeys = txNew.vout[token_index].nValue;
+                            txNew.vout[token_index].nAsset = token;
+                            if (issuance_details->blind_issuance && blind_details) {
+                                issuance_token_keys.push_back(GetBlindingKey(&blindingScript));
+                                blind_details->num_to_blind++;
+
+                                // If we're blinding a token issuance and no assets, we must make
+                                // the asset issuance a blinded commitment to 0
+                                if (asset_index == -1) {
+                                    txNew.vin[0].assetIssuance.nAmount = 0;
+                                    issuance_asset_keys.push_back(GetBlindingKey(&blindingScript));
+                                    blind_details->num_to_blind++;
+                                }
+                            }
+                        }
+                    // Asset being reissued with explicitly named asset/token
+                    } else if (asset_index != -1) {
+                        assert(reissuance_index != -1);
+                        // Fill in output with issuance
+                        txNew.vout[asset_index].nAsset = issuance_details->reissuance_asset;
+
+                        // Fill in issuance
+                        // Blinding revealing underlying asset
+                        txNew.vin[reissuance_index].assetIssuance.assetBlindingNonce = token_blinding;
+                        txNew.vin[reissuance_index].assetIssuance.assetEntropy = issuance_details->entropy;
+                        txNew.vin[reissuance_index].assetIssuance.nAmount = txNew.vout[asset_index].nValue;
+
+                        // If blinded token derivation, blind the issuance
+                        CAsset temp_token;
+                        CalculateReissuanceToken(temp_token, issuance_details->entropy, true);
+                        if (temp_token == issuance_details->reissuance_token && blind_details) {
+                            CScript blindingScript(CScript() << OP_RETURN << std::vector<unsigned char>(txNew.vin[reissuance_index].prevout.hash.begin(), txNew.vin[reissuance_index].prevout.hash.end()) << txNew.vin[reissuance_index].prevout.n);
+                            issuance_asset_keys.resize(reissuance_index);
+                            issuance_asset_keys.push_back(GetBlindingKey(&blindingScript));
+                            blind_details->num_to_blind++;
+                        }
+                    }
+                }
+
+                if (blind_details) {
+                    if (!fillBlindDetails(blind_details, this, txNew, selected_coins, strFailReason)) {
+                        return false;
+                    }
+
+                    // Keep a backup of transaction in case re-blinding necessary
+                    blind_details->tx_unblinded_unsigned = txNew;
+                    int ret = BlindTransaction(blind_details->i_amount_blinds, blind_details->i_asset_blinds, blind_details->i_assets, blind_details->i_amounts, blind_details->o_amount_blinds, blind_details->o_asset_blinds,  blind_details->o_pubkeys, issuance_asset_keys, issuance_token_keys, txNew);
+                    assert(ret != -1);
+                    if (ret != blind_details->num_to_blind) {
+                        strFailReason = _("Unable to blind the transaction properly. This should not happen.");
+                        return false;
+                    }
                 }
 
                 nBytes = CalculateMaximumSignedTxSize(txNew, this, coin_control.fAllowWatchOnly);
@@ -2791,6 +3299,11 @@ bool CWallet::CreateTransaction(const std::vector<CRecipient>& vecSend, CTransac
                     return false;
                 }
 
+                // Remove blinding if we're not actually signing
+                if (blind_details && !sign) {
+                    txNew = blind_details->tx_unblinded_unsigned;
+                }
+
                 nFeeNeeded = GetMinimumFee(*this, nBytes, coin_control, ::mempool, ::feeEstimator, &feeCalc);
                 if (feeCalc.reason == FeeReason::FALLBACK && !m_allow_fallback_fee) {
                     // eventually allow a fallback fee
@@ -2831,9 +3344,39 @@ bool CWallet::CreateTransaction(const std::vector<CRecipient>& vecSend, CTransac
                     // If we have change output already, just increase it
                     if (nFeeRet > nFeeNeeded && nChangePosInOut != -1 && nSubtractFeeFromAmount == 0) {
                         CAmount extraFeePaid = nFeeRet - nFeeNeeded;
-                        std::vector<CTxOut>::iterator change_position = txNew.vout.begin()+nChangePosInOut;
-                        change_position->nValue += extraFeePaid;
-                        nFeeRet -= extraFeePaid;
+
+                        // If blinding we need to edit the unblinded tx and re-blind. Otherwise just edit the tx.
+                        if (blind_details) {
+                            txNew = blind_details->tx_unblinded_unsigned;
+                            std::vector<CTxOut>::iterator change_position = txNew.vout.begin() + nChangePosInOut;
+                            change_position->nValue = change_position->nValue.GetAmount() + extraFeePaid;
+                            blind_details->o_amounts[nChangePosInOut] = change_position->nValue.GetAmount();
+
+                            nFeeRet -= extraFeePaid;
+                            txNew.vout.back().nValue = nFeeRet; // update fee output
+                            blind_details->o_amounts.back() = nFeeRet;
+
+                            // Wipe output blinding factors and start over
+                            blind_details->o_amount_blinds.clear();
+
+                            blind_details->o_asset_blinds.clear();
+
+                            // Re-blind tx after editing and change.
+                            blind_details->tx_unblinded_unsigned = txNew;
+                            int ret = BlindTransaction(blind_details->i_amount_blinds, blind_details->i_asset_blinds, blind_details->i_assets, blind_details->i_amounts, blind_details->o_amount_blinds, blind_details->o_asset_blinds,  blind_details->o_pubkeys, issuance_asset_keys, issuance_token_keys, txNew);
+                            assert(ret != -1);
+                            if (ret != blind_details->num_to_blind) {
+                                strFailReason = _("Unable to blind the transaction properly. This should not happen.");
+                                return false;
+                            }
+                        } else {
+                            std::vector<CTxOut>::iterator change_position = txNew.vout.begin() + nChangePosInOut;
+                            change_position->nValue = change_position->nValue.GetAmount() + extraFeePaid;
+                            nFeeRet -= extraFeePaid;
+                            if (g_con_elementsmode) {
+                                txNew.vout.back().nValue = nFeeRet; // update fee output
+                            }
+                        }
                     }
                     break; // Done, enough fee included.
                 }
@@ -2849,12 +3392,45 @@ bool CWallet::CreateTransaction(const std::vector<CRecipient>& vecSend, CTransac
                 // Try to reduce change to include necessary fee
                 if (nChangePosInOut != -1 && nSubtractFeeFromAmount == 0) {
                     CAmount additionalFeeNeeded = nFeeNeeded - nFeeRet;
-                    std::vector<CTxOut>::iterator change_position = txNew.vout.begin()+nChangePosInOut;
-                    // Only reduce change if remaining amount is still a large enough output.
-                    if (change_position->nValue >= MIN_FINAL_CHANGE + additionalFeeNeeded) {
-                        change_position->nValue -= additionalFeeNeeded;
-                        nFeeRet += additionalFeeNeeded;
-                        break; // Done, able to increase fee from change
+
+                    // If blinding we need to edit the unblinded tx and re-blind. Otherwise just edit the tx.
+                    if (blind_details) {
+                        txNew = blind_details->tx_unblinded_unsigned;
+                        std::vector<CTxOut>::iterator change_position = txNew.vout.begin() + nChangePosInOut;
+                        // Only reduce change if remaining amount is still a large enough output.
+                        if (change_position->nValue.GetAmount() >= MIN_FINAL_CHANGE + additionalFeeNeeded) {
+                            change_position->nValue = change_position->nValue.GetAmount() - additionalFeeNeeded;
+                            blind_details->o_amounts[nChangePosInOut] = change_position->nValue.GetAmount();
+
+                            nFeeRet += additionalFeeNeeded;
+                            txNew.vout.back().nValue = nFeeRet; // update fee output
+                            blind_details->o_amounts.back() = nFeeRet; // update change details
+                            // Wipe output blinding factors and start over
+                            blind_details->o_amount_blinds.clear();
+
+                            blind_details->o_asset_blinds.clear();
+
+                            // Re-blind tx after editing and change.
+                            blind_details->tx_unblinded_unsigned = txNew;
+                            int ret = BlindTransaction(blind_details->i_amount_blinds, blind_details->i_asset_blinds, blind_details->i_assets, blind_details->i_amounts, blind_details->o_amount_blinds, blind_details->o_asset_blinds,  blind_details->o_pubkeys, issuance_asset_keys, issuance_token_keys, txNew);
+                            assert(ret != -1);
+                            if (ret != blind_details->num_to_blind) {
+                                strFailReason = _("Unable to blind the transaction properly. This should not happen.");
+                                return false;
+                            }
+                            break; // Done, able to increase fee from change
+                        }
+                    } else {
+                        std::vector<CTxOut>::iterator change_position = txNew.vout.begin() + nChangePosInOut;
+                        // Only reduce change if remaining amount is still a large enough output.
+                        if (change_position->nValue.GetAmount() >= MIN_FINAL_CHANGE + additionalFeeNeeded) {
+                            change_position->nValue = change_position->nValue.GetAmount() - additionalFeeNeeded;
+                            nFeeRet += additionalFeeNeeded;
+                            if (g_con_elementsmode) {
+                                txNew.vout.back().nValue = nFeeRet; // update fee output
+                            }
+                            break; // Done, able to increase fee from change
+                        }
                     }
                 }
 
@@ -2871,12 +3447,17 @@ bool CWallet::CreateTransaction(const std::vector<CRecipient>& vecSend, CTransac
             }
         }
 
-        if (nChangePosInOut == -1) reservekey.ReturnKey(); // Return any reserved key if we don't have change
+        // Release any change keys that we didn't use.
+        for (const std::pair<CAsset, std::pair<int, CScript>>& it : mapScriptChange) {
+            int index = it.second.first;
+            if (index < 0) {
+                continue;
+            }
 
-        // Shuffle selected coins and fill in final vin
-        txNew.vin.clear();
-        std::vector<CInputCoin> selected_coins(setCoins.begin(), setCoins.end());
-        std::shuffle(selected_coins.begin(), selected_coins.end(), FastRandomContext());
+            if (vChangePosInOut.find(it.first) == vChangePosInOut.end()) {
+                reserveKeys[index]->ReturnKey();
+            }
+        }
 
         // Note how the sequence number is set to non-maxint so that
         // the nLockTime set above actually works.
@@ -2887,8 +3468,21 @@ bool CWallet::CreateTransaction(const std::vector<CRecipient>& vecSend, CTransac
         // and in the spirit of "smallest possible change from prior
         // behavior."
         const uint32_t nSequence = coin_control.m_signal_bip125_rbf.get_value_or(m_signal_rbf) ? MAX_BIP125_RBF_SEQUENCE : (CTxIn::SEQUENCE_FINAL - 1);
-        for (const auto& coin : selected_coins) {
-            txNew.vin.push_back(CTxIn(coin.outpoint, CScript(), nSequence));
+        for (auto& input : txNew.vin) {
+            // Remove sigs and then set sequence
+            input.scriptSig = CScript();
+            input.nSequence = nSequence;
+        }
+        // Also remove witness data for scripts
+        for (auto& inwit : txNew.witness.vtxinwit) {
+            inwit.scriptWitness.SetNull();
+        }
+
+        // Do the same things for unblinded version of tx when applicable
+        if (blind_details) {
+            for (auto& input : blind_details->tx_unblinded_unsigned.vin) {
+                input.nSequence = nSequence;
+            }
         }
 
         if (sign)
@@ -2909,6 +3503,15 @@ bool CWallet::CreateTransaction(const std::vector<CRecipient>& vecSend, CTransac
 
                 nIn++;
             }
+        } else if (blind_details) {
+            // "sign" also means blind for the purposes of making a complete tx
+            // or just funding one properly
+            txNew = blind_details->tx_unblinded_unsigned;
+        }
+
+        // Normalize the witness in case it is not serialized before mempool
+        if (!txNew.HasWitness()) {
+            txNew.witness.SetNull();
         }
 
         // Return the constructed transaction data.
@@ -2920,6 +3523,37 @@ bool CWallet::CreateTransaction(const std::vector<CRecipient>& vecSend, CTransac
             strFailReason = _("Transaction too large");
             return false;
         }
+
+        // Print unblinded transaction overview.
+        if (blind_details) {
+            std::string summary = "CreateTransaction created blinded transaction:\nIN: ";
+            for (unsigned int i = 0; i < selected_coins.size(); ++i) {
+                if (i > 0) {
+                    summary += "    ";
+                }
+                summary += strprintf("#%d: %s [%s] (%s [%s])\n", i,
+                    selected_coins[i].value,
+                    selected_coins[i].txout.nValue.IsExplicit() ? "explicit" : "blinded",
+                    selected_coins[i].asset.GetHex(),
+                    selected_coins[i].txout.nAsset.IsExplicit() ? "explicit" : "blinded"
+                );
+            }
+            summary += "OUT: ";
+            for (unsigned int i = 0; i < tx->vout.size(); ++i) {
+                if (i > 0) {
+                    summary += "     ";
+                }
+                CTxOut unblinded = blind_details->tx_unblinded_unsigned.vout[i];
+                summary += strprintf("#%d: %s%s [%s] (%s [%s])\n", i,
+                    tx->vout[i].IsFee() ? "[fee] " : "",
+                    unblinded.nValue.GetAmount(),
+                    tx->vout[i].nValue.IsExplicit() ? "explicit" : "blinded",
+                    unblinded.nAsset.GetAsset().GetHex(),
+                    tx->vout[i].nAsset.IsExplicit() ? "explicit" : "blinded"
+                );
+            }
+            WalletLogPrintf(summary+"\n");
+        }
     }
 
     if (gArgs.GetBoolArg("-walletrejectlongchains", DEFAULT_WALLET_REJECT_LONG_CHAINS)) {
@@ -2954,7 +3588,7 @@ bool CWallet::CreateTransaction(const std::vector<CRecipient>& vecSend, CTransac
 /**
  * Call after CreateTransaction unless you want to abort
  */
-bool CWallet::CommitTransaction(CTransactionRef tx, mapValue_t mapValue, std::vector<std::pair<std::string, std::string>> orderForm, CReserveKey& reservekey, CConnman* connman, CValidationState& state)
+bool CWallet::CommitTransaction(CTransactionRef tx, mapValue_t mapValue, std::vector<std::pair<std::string, std::string>> orderForm, std::vector<std::unique_ptr<CReserveKey>>& reservekeys, CConnman* connman, CValidationState& state, const BlindDetails* blind_details)
 {
     {
         LOCK2(cs_main, cs_wallet);
@@ -2965,10 +3599,22 @@ bool CWallet::CommitTransaction(CTransactionRef tx, mapValue_t mapValue, std::ve
         wtxNew.fTimeReceivedIsTxTime = true;
         wtxNew.fFromMe = true;
 
+        // Write down blinding information
+        if (blind_details) {
+            assert(blind_details->o_amounts.size() == wtxNew.tx->vout.size());
+            assert(blind_details->o_asset_blinds.size() == wtxNew.tx->vout.size());
+            assert(blind_details->o_amount_blinds.size() == wtxNew.tx->vout.size());
+            for (unsigned int i = 0; i < blind_details->o_amounts.size(); i++) {
+                wtxNew.SetBlindingData(i, blind_details->o_pubkeys[i], blind_details->o_amounts[i], blind_details->o_amount_blinds[i], blind_details->o_assets[i], blind_details->o_asset_blinds[i]);
+            }
+        }
+
         WalletLogPrintf("CommitTransaction:\n%s", wtxNew.tx->ToString()); /* Continued */
         {
             // Take key pair from key pool so it won't be used again
-            reservekey.KeepKey();
+            for (auto& reservekey : reservekeys) {
+                reservekey->KeepKey();
+            }
 
             // Add tx to wallet, because if it has change it's also ours,
             // otherwise just for transaction history.
@@ -3419,10 +4065,13 @@ std::map<CTxDestination, CAmount> CWallet::GetAddressBalances()
                 if(!ExtractDestination(pcoin->tx->vout[i].scriptPubKey, addr))
                     continue;
 
-                CAmount n = IsSpent(walletEntry.first, i) ? 0 : pcoin->tx->vout[i].nValue;
-
+                CAmount n = IsSpent(walletEntry.first, i) ? 0 : pcoin->GetOutputValueOut(i);
                 if (!balances.count(addr))
                     balances[addr] = 0;
+
+                if (n < 0) {
+                    continue;
+                }
                 balances[addr] += n;
             }
         }
@@ -3651,7 +4300,7 @@ void CWallet::GetKeyBirthTimes(std::map<CTxDestination, int64_t> &mapKeyBirth) c
     // get birth times for keys with metadata
     for (const auto& entry : mapKeyMetadata) {
         if (entry.second.nCreateTime) {
-            mapKeyBirth[entry.first] = entry.second.nCreateTime;
+            mapKeyBirth[PKHash(entry.first)] = entry.second.nCreateTime;
         }
     }
 
@@ -3659,7 +4308,7 @@ void CWallet::GetKeyBirthTimes(std::map<CTxDestination, int64_t> &mapKeyBirth) c
     CBlockIndex *pindexMax = chainActive[std::max(0, chainActive.Height() - 144)]; // the tip can be reorganized; use a 144-block safety margin
     std::map<CKeyID, CBlockIndex*> mapKeyFirstBlock;
     for (const CKeyID &keyid : GetKeys()) {
-        if (mapKeyBirth.count(keyid) == 0)
+        if (mapKeyBirth.count(PKHash(keyid)) == 0)
             mapKeyFirstBlock[keyid] = pindexMax;
     }
 
@@ -3692,7 +4341,7 @@ void CWallet::GetKeyBirthTimes(std::map<CTxDestination, int64_t> &mapKeyBirth) c
 
     // Extract block timestamps for those keys
     for (const auto& entry : mapKeyFirstBlock)
-        mapKeyBirth[entry.first] = entry.second->GetBlockTime() - TIMESTAMP_WINDOW; // block times can be 2h off
+        mapKeyBirth[PKHash(entry.first)] = entry.second->GetBlockTime() - TIMESTAMP_WINDOW; // block times can be 2h off
 }
 
 /**
@@ -4308,15 +4957,16 @@ void CWallet::LearnAllRelatedScripts(const CPubKey& key)
 
 std::vector<OutputGroup> CWallet::GroupOutputs(const std::vector<COutput>& outputs, bool single_coin) const {
     std::vector<OutputGroup> groups;
-    std::map<CTxDestination, OutputGroup> gmap;
-    CTxDestination dst;
+    std::map<std::pair<CAsset, CTxDestination>, OutputGroup> gmap;
+    std::pair<CAsset, CTxDestination> dst;
     for (const auto& output : outputs) {
         if (output.fSpendable) {
             CInputCoin input_coin = output.GetInputCoin();
+            dst.first = input_coin.asset;
 
             size_t ancestors, descendants;
             mempool.GetTransactionAncestry(output.tx->GetHash(), ancestors, descendants);
-            if (!single_coin && ExtractDestination(output.tx->tx->vout[output.i].scriptPubKey, dst)) {
+            if (!single_coin && ExtractDestination(output.tx->tx->vout[output.i].scriptPubKey, dst.second)) {
                 // Limit output groups to no more than 10 entries, to protect
                 // against inadvertently creating a too-large transaction
                 // when using -avoidpartialspends
@@ -4362,6 +5012,10 @@ bool CWallet::GetKeyOrigin(const CKeyID& keyID, KeyOriginInfo& info) const
     return true;
 }
 
+//
+// ELEMENTS WALLET ADDITIONS
+//
+
 bool CWallet::SetOnlinePubKey(const CPubKey& online_key_in)
 {
     LOCK(cs_wallet);
@@ -4399,4 +5053,351 @@ bool CWallet::SetOfflineCounter(int counter) {
     }
     offline_counter = counter;
     return true;
-}
\ No newline at end of file
+}
+
+unsigned int CWalletTx::GetPseudoInputOffset(const unsigned int input_index, const bool reissuance_token) const
+{
+    // There is no mapValue space for null issuances
+    assert(reissuance_token ? !tx->vin[input_index].assetIssuance.nInflationKeys.IsNull() : !tx->vin[input_index].assetIssuance.nAmount.IsNull());
+    unsigned int mapvalue_loc = 0;
+    for (unsigned int i = 0; i < tx->vin.size()*2; i++) {
+        if (input_index == i/2 && (reissuance_token ? 1 : 0) == i % 2) {
+            break;
+        }
+        if (!tx->vin[i/2].assetIssuance.IsNull()) {
+            if ((i % 2 == 0 && !tx->vin[i/2].assetIssuance.nAmount.IsNull()) ||
+                    (i % 2 == 1 && !tx->vin[i/2].assetIssuance.nInflationKeys.IsNull())) {
+                mapvalue_loc++;
+            }
+        }
+    }
+    return mapvalue_loc;
+}
+
+void CWalletTx::SetBlindingData(const unsigned int map_index, const CPubKey& blinding_pubkey, const CAmount value, const uint256& value_factor, const CAsset& asset, const uint256& asset_factor)
+{
+    if (mapValue["blindingdata"].size() < (map_index + 1) * 138) {
+        mapValue["blindingdata"].resize((tx->vout.size() + GetNumIssuances(*tx)) * 138);
+    }
+
+    unsigned char* it = (unsigned char*)(&mapValue["blindingdata"][0]) + 138 * map_index;
+
+    *it = 1;
+    memcpy(&*(it + 1), &value, 8);
+    memcpy(&*(it + 9), value_factor.begin(), 32);
+    memcpy(&*(it + 41), asset_factor.begin(), 32);
+    memcpy(&*(it + 73), asset.begin(), 32);
+    if (blinding_pubkey.IsFullyValid()) {
+        memcpy(&*(it + 105), blinding_pubkey.begin(), 33);
+    } else {
+        memset(&*(it + 105), 0, 33);
+    }
+
+}
+
+void CWalletTx::GetBlindingData(const unsigned int map_index, const std::vector<unsigned char>& vchRangeproof, const CConfidentialValue& conf_value, const CConfidentialAsset& conf_asset, const CConfidentialNonce nonce, const CScript& scriptPubKey, CPubKey* blinding_pubkey_out, CAmount* value_out, uint256* value_factor_out, CAsset* asset_out, uint256* asset_factor_out) const
+{
+    // Blinding data is cached in a serialized record mapWallet["blindingdata"].
+    // It contains a concatenation byte vectors, 74 bytes per txout or pseudo-input.
+    // Each consists of:
+    // * 1 byte boolean marker (has the output been computed)?
+    // * 8 bytes value (-1 if unknown)
+    // * 32 bytes value blinding factor
+    // * 32 bytes asset blinding factor
+    // * 32 bytes asset
+    // * 33 bytes blinding pubkey (ECDH pubkey of the destination)
+    // This is really ugly, and should use CDataStream serialization instead.
+
+    if (mapValue["blindingdata"].size() < (map_index + 1) * 138) {
+        mapValue["blindingdata"].resize((tx->vout.size() + GetNumIssuances(*tx)) * 138);
+    }
+
+    unsigned char* it = (unsigned char*)(&mapValue["blindingdata"][0]) + 138 * map_index;
+
+    CAmount amount = -1;
+    CPubKey pubkey;
+    uint256 value_factor;
+    CAsset asset_tag;
+    uint256 asset_factor;
+
+    if (*it == 1) {
+        memcpy(&amount, &*(it + 1), 8);
+        memcpy(value_factor.begin(), &*(it + 9), 32);
+        memcpy(asset_factor.begin(), &*(it + 41), 32);
+        memcpy(asset_tag.begin(), &*(it + 73), 32);
+        pubkey.Set(it + 105, it + 138);
+
+        if (conf_value.IsExplicit()) {
+            assert(conf_value.GetAmount() == amount);
+        }
+    } else {
+        pwallet->ComputeBlindingData(conf_value, conf_asset, nonce, scriptPubKey, vchRangeproof, amount, pubkey, value_factor, asset_tag, asset_factor);
+        *it = 1;
+        memcpy(&*(it + 1), &amount, 8);
+        memcpy(&*(it + 9), value_factor.begin(), 32);
+        memcpy(&*(it + 41), asset_factor.begin(), 32);
+        memcpy(&*(it + 73), asset_tag.begin(), 32);
+        if (pubkey.IsFullyValid()) {
+            memcpy(&*(it + 105), pubkey.begin(), 33);
+        } else {
+            memset(&*(it + 105), 0, 33);
+        }
+    }
+
+    if (value_out) *value_out = amount;
+    if (blinding_pubkey_out) *blinding_pubkey_out = pubkey;
+    if (value_factor_out) *value_factor_out = value_factor;
+    if (asset_factor_out) *asset_factor_out = asset_factor;
+    if (asset_out) *asset_out = asset_tag;
+}
+
+CAmount CWalletTx::GetOutputValueOut(unsigned int output_index) const {
+    assert(output_index < tx->vout.size());
+    const CTxOut& out = tx->vout[output_index];
+    const CTxWitness& wit = tx->witness;
+    CAmount ret;
+    GetBlindingData(output_index, wit.vtxoutwit.size() <= output_index ? std::vector<unsigned char>() : wit.vtxoutwit[output_index].vchRangeproof, out.nValue, out.nAsset, out.nNonce, out.scriptPubKey, nullptr, &ret, nullptr, nullptr, nullptr);
+    return ret;
+}
+
+uint256 CWalletTx::GetOutputAmountBlindingFactor(unsigned int output_index) const {
+    assert(output_index < tx->vout.size());
+    const CTxOut& out = tx->vout[output_index];
+    const CTxWitness& wit = tx->witness;
+    uint256 ret;
+    GetBlindingData(output_index, wit.vtxoutwit.size() <= output_index ? std::vector<unsigned char>() : wit.vtxoutwit[output_index].vchRangeproof, out.nValue, out.nAsset, out.nNonce, out.scriptPubKey, nullptr, nullptr, &ret, nullptr, nullptr);
+    return ret;
+}
+
+uint256 CWalletTx::GetOutputAssetBlindingFactor(unsigned int output_index) const {
+    assert(output_index < tx->vout.size());
+    const CTxOut& out = tx->vout[output_index];
+    const CTxWitness& wit = tx->witness;
+    uint256 ret;
+    GetBlindingData(output_index, wit.vtxoutwit.size() <= output_index ? std::vector<unsigned char>() : wit.vtxoutwit[output_index].vchRangeproof, out.nValue, out.nAsset, out.nNonce, out.scriptPubKey, nullptr, nullptr, nullptr, nullptr, &ret);
+    return ret;
+}
+
+CAsset CWalletTx::GetOutputAsset(unsigned int output_index) const {
+    assert(output_index < tx->vout.size());
+    const CTxOut& out = tx->vout[output_index];
+    const CTxWitness& wit = tx->witness;
+    CAsset ret;
+    GetBlindingData(output_index, wit.vtxoutwit.size() <= output_index ? std::vector<unsigned char>() : wit.vtxoutwit[output_index].vchRangeproof, out.nValue, out.nAsset, out.nNonce, out.scriptPubKey, nullptr, nullptr, nullptr, &ret, nullptr);
+    return ret;
+}
+
+CPubKey CWalletTx::GetOutputBlindingPubKey(unsigned int output_index) const {
+    assert(output_index < tx->vout.size());
+    const CTxOut& out = tx->vout[output_index];
+    const CTxWitness& wit = tx->witness;
+    CPubKey ret;
+    GetBlindingData(output_index, wit.vtxoutwit.size() <= output_index ? std::vector<unsigned char>() : wit.vtxoutwit[output_index].vchRangeproof, out.nValue, out.nAsset, out.nNonce, out.scriptPubKey, &ret, nullptr, nullptr, nullptr, nullptr);
+    return ret;
+}
+
+uint256 CWalletTx::GetIssuanceBlindingFactor(unsigned int input_index, bool reissuance_token) const {
+    assert(input_index < tx->vin.size());
+    CAsset asset;
+    const CAssetIssuance& issuance = tx->vin[input_index].assetIssuance;
+    const CTxWitness& wit = tx->witness;
+    if ((issuance.nAmount.IsNull() && !reissuance_token) || (issuance.nInflationKeys.IsNull() && reissuance_token)) {
+        return uint256();
+    }
+    const std::vector<unsigned char>& rangeproof = wit.vtxinwit.size() <= input_index ? std::vector<unsigned char>() : (reissuance_token ? wit.vtxinwit[input_index].vchInflationKeysRangeproof : wit.vtxinwit[input_index].vchIssuanceAmountRangeproof);
+    unsigned int mapValueInd = GetPseudoInputOffset(input_index, reissuance_token)+tx->vout.size();
+  if (issuance.assetBlindingNonce.IsNull()) {
+        uint256 entropy;
+        GenerateAssetEntropy(entropy, tx->vin[input_index].prevout, issuance.assetEntropy);
+        if (reissuance_token) {
+            CalculateReissuanceToken(asset, entropy, issuance.nInflationKeys.IsCommitment());
+        } else {
+            CalculateAsset(asset, entropy);
+        }
+  }
+    else {
+        if (reissuance_token) {
+            // Re-issuances don't emit issuance tokens
+            return uint256();
+        }
+        CalculateAsset(asset, issuance.assetEntropy);
+    }
+
+    uint256 ret;
+    CScript blindingScript(CScript() << OP_RETURN << std::vector<unsigned char>(tx->vin[input_index].prevout.hash.begin(), tx->vin[input_index].prevout.hash.end()) << tx->vin[input_index].prevout.n);
+    GetBlindingData(mapValueInd, rangeproof, reissuance_token ? issuance.nInflationKeys : issuance.nAmount, CConfidentialAsset(asset), CConfidentialNonce(), blindingScript, nullptr, nullptr, &ret, nullptr, nullptr);
+    return ret;
+}
+
+CAmount CWalletTx::GetIssuanceAmount(unsigned int input_index, bool reissuance_token) const {
+    assert(input_index < tx->vin.size());
+    CAsset asset;
+    CAsset token;
+    const CAssetIssuance& issuance = tx->vin[input_index].assetIssuance;
+    const CTxWitness& wit = tx->witness;
+    if ((issuance.nAmount.IsNull() && !reissuance_token) || (issuance.nInflationKeys.IsNull() && reissuance_token)) {
+        return 0;
+    }
+    unsigned int mapValueInd = GetPseudoInputOffset(input_index, reissuance_token)+tx->vout.size();
+    const std::vector<unsigned char>& rangeproof = wit.vtxinwit.size() <= input_index ? std::vector<unsigned char>() : (reissuance_token ? wit.vtxinwit[input_index].vchInflationKeysRangeproof : wit.vtxinwit[input_index].vchIssuanceAmountRangeproof);
+    if (issuance.assetBlindingNonce.IsNull()) {
+        uint256 entropy;
+        GenerateAssetEntropy(entropy, tx->vin[input_index].prevout, issuance.assetEntropy);
+        CalculateReissuanceToken(token, entropy, issuance.nAmount.IsCommitment());
+        CalculateAsset(asset, entropy);
+    }
+    else {
+        if (reissuance_token) {
+            // Re-issuances don't emit issuance tokens
+            return -1;
+        }
+        CalculateAsset(asset, issuance.assetEntropy);
+    }
+
+    CAmount ret;
+    CScript blindingScript(CScript() << OP_RETURN << std::vector<unsigned char>(tx->vin[input_index].prevout.hash.begin(), tx->vin[input_index].prevout.hash.end()) << tx->vin[input_index].prevout.n);
+    GetBlindingData(mapValueInd, rangeproof, reissuance_token ? issuance.nInflationKeys : issuance.nAmount, CConfidentialAsset((reissuance_token ? token : asset)), CConfidentialNonce(), blindingScript, nullptr, &ret, nullptr, nullptr, nullptr);
+    return ret;
+}
+
+void CWallet::ComputeBlindingData(const CConfidentialValue& conf_value, const CConfidentialAsset& conf_asset, const CConfidentialNonce& nonce, const CScript& scriptPubKey, const std::vector<unsigned char>& vchRangeproof, CAmount& value, CPubKey& blinding_pubkey, uint256& value_factor, CAsset& asset, uint256& asset_factor) const
+{
+    if (conf_value.IsExplicit() && conf_asset.IsExplicit()) {
+        value = conf_value.GetAmount();
+        asset = conf_asset.GetAsset();
+        blinding_pubkey = CPubKey();
+        value_factor.SetNull();
+        asset_factor.SetNull();
+        return;
+    }
+
+    CKey blinding_key;
+    if ((blinding_key = GetBlindingKey(&scriptPubKey)).IsValid()) {
+        // For outputs using derived blinding.
+        if (UnblindConfidentialPair(blinding_key, conf_value, conf_asset, nonce, scriptPubKey, vchRangeproof, value, value_factor, asset, asset_factor)) {
+            // TODO: make sure SetBlindingData sets it as receiver's blinding pubkey
+            blinding_pubkey = blinding_key.GetPubKey();
+            return;
+        }
+    }
+
+    value = -1;
+    blinding_pubkey = CPubKey();
+    value_factor.SetNull();
+    asset.SetNull();
+    asset_factor.SetNull();
+}
+
+void CWalletTx::WipeUnknownBlindingData()
+{
+    for (unsigned int n = 0; n < tx->vout.size(); n++) {
+        if (GetOutputValueOut(n) == -1) {
+            mapValue["blindingdata"][138 * n] = 0;
+        }
+    }
+    for (unsigned int n = 0; n < tx->vin.size(); n++) {
+        if (!tx->vin[n].assetIssuance.nAmount.IsNull()) {
+            if (GetIssuanceAmount(n, false) == -1) {
+                mapValue["blindingdata"][138 * (tx->vout.size() + GetPseudoInputOffset(n, false))] = 0;
+            }
+        }
+        if (!tx->vin[n].assetIssuance.nInflationKeys.IsNull()) {
+            if (GetIssuanceAmount(n, true) == -1) {
+                mapValue["blindingdata"][138 * (tx->vout.size() + GetPseudoInputOffset(n, true))] = 0;
+            }
+        }
+    }
+}
+
+std::map<uint256, std::pair<CAsset, CAsset> > CWallet::GetReissuanceTokenTypes() const {
+    std::map<uint256, std::pair<CAsset, CAsset> > tokenMap;
+    {
+        LOCK2(cs_main, cs_wallet);
+        for (std::map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it) {
+            const CWalletTx* pcoin = &(*it).second;
+            CAsset asset;
+            CAsset token;
+            uint256 entropy;
+            for (unsigned int input_index = 0; input_index < pcoin->tx->vin.size(); input_index++) {
+                const CAssetIssuance& issuance = pcoin->tx->vin[input_index].assetIssuance;
+                if (issuance.IsNull()) {
+                    continue;
+                }
+                // Only looking at initial issuances
+                if (issuance.assetBlindingNonce.IsNull()) {
+                    GenerateAssetEntropy(entropy, pcoin->tx->vin[input_index].prevout, issuance.assetEntropy);
+                    CalculateAsset(asset, entropy);
+                    // TODO handle the case with null nAmount (not decided yet)
+                    CalculateReissuanceToken(token, entropy, issuance.nAmount.IsCommitment());
+                    tokenMap[entropy] = std::make_pair(token, asset);
+                }
+            }
+        }
+    }
+    return tokenMap;
+}
+
+CKey CWallet::GetBlindingKey(const CScript* script) const
+{
+    CKey key;
+
+    if (script != NULL) {
+        std::map<CScriptID, uint256>::const_iterator it = mapSpecificBlindingKeys.find(CScriptID(*script));
+        if (it != mapSpecificBlindingKeys.end()) {
+            key.Set(it->second.begin(), it->second.end(), true);
+            if (key.IsValid()) {
+                return key;
+            }
+        }
+    }
+
+    if (script != NULL && !blinding_derivation_key.IsNull()) {
+        unsigned char vch[32];
+        CHMAC_SHA256(blinding_derivation_key.begin(), blinding_derivation_key.size()).Write(&((*script)[0]), script->size()).Finalize(vch);
+        key.Set(&vch[0], &vch[32], true);
+        if (key.IsValid()) {
+            return key;
+        }
+    }
+
+    return CKey();
+}
+
+CPubKey CWallet::GetBlindingPubKey(const CScript& script) const
+{
+    CKey key = GetBlindingKey(&script);
+    if (key.IsValid()) {
+        return key.GetPubKey();
+    }
+
+    return CPubKey();
+}
+
+bool CWallet::LoadSpecificBlindingKey(const CScriptID& scriptid, const uint256& key)
+{
+    AssertLockHeld(cs_wallet); // mapSpecificBlindingKeys
+    mapSpecificBlindingKeys[scriptid] = key;
+    return true;
+}
+
+bool CWallet::AddSpecificBlindingKey(const CScriptID& scriptid, const uint256& key)
+{
+    AssertLockHeld(cs_wallet); // mapSpecificBlindingKeys
+    if (!LoadSpecificBlindingKey(scriptid, key))
+        return false;
+
+    return WalletBatch(*database).WriteSpecificBlindingKey(scriptid, key);
+}
+
+bool CWallet::SetMasterBlindingKey(const uint256& key)
+{
+    AssertLockHeld(cs_wallet);
+    if (!WalletBatch(*database).WriteBlindingDerivationKey(key)) {
+        return false;
+    }
+    blinding_derivation_key = key;
+    return true;
+}
+
+// END ELEMENTS
+//
diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h
index 9b8d3614a7a15..71524f3ddecde 100644
--- a/src/wallet/wallet.h
+++ b/src/wallet/wallet.h
@@ -7,6 +7,7 @@
 #define BITCOIN_WALLET_WALLET_H
 
 #include <amount.h>
+#include <asset.h>
 #include <outputtype.h>
 #include <policy/feerate.h>
 #include <streams.h>
@@ -173,6 +174,8 @@ struct CRecipient
 {
     CScript scriptPubKey;
     CAmount nAmount;
+    CAsset asset;
+    CPubKey confidentiality_key;
     bool fSubtractFeeFromAmount;
 };
 
@@ -202,6 +205,9 @@ struct COutputEntry
     CTxDestination destination;
     CAmount amount;
     int vout;
+    CAsset asset;
+    uint256 amount_blinding_factor;
+    uint256 asset_blinding_factor;
 };
 
 /** A transaction with a merkle branch linking it to the block chain. */
@@ -320,7 +326,7 @@ class CWalletTx : public CMerkleTx
      *     "spent"           - serialized vfSpent value that existed prior to
      *                         2014 (removed in commit 93a18a3)
      */
-    mapValue_t mapValue;
+    mutable mapValue_t mapValue;
     std::vector<std::pair<std::string, std::string> > vOrderForm;
     unsigned int fTimeReceivedIsTxTime;
     unsigned int nTimeReceived; //!< time received by this node
@@ -354,15 +360,15 @@ class CWalletTx : public CMerkleTx
     mutable bool fAvailableWatchCreditCached;
     mutable bool fChangeCached;
     mutable bool fInMempool;
-    mutable CAmount nDebitCached;
-    mutable CAmount nCreditCached;
-    mutable CAmount nImmatureCreditCached;
-    mutable CAmount nAvailableCreditCached;
-    mutable CAmount nWatchDebitCached;
-    mutable CAmount nWatchCreditCached;
-    mutable CAmount nImmatureWatchCreditCached;
-    mutable CAmount nAvailableWatchCreditCached;
-    mutable CAmount nChangeCached;
+    mutable CAmountMap nDebitCached;
+    mutable CAmountMap nCreditCached;
+    mutable CAmountMap nImmatureCreditCached;
+    mutable CAmountMap nAvailableCreditCached;
+    mutable CAmountMap nWatchDebitCached;
+    mutable CAmountMap nWatchCreditCached;
+    mutable CAmountMap nImmatureWatchCreditCached;
+    mutable CAmountMap nAvailableWatchCreditCached;
+    mutable CAmountMap nChangeCached;
 
     CWalletTx(const CWallet* pwalletIn, CTransactionRef arg) : CMerkleTx(std::move(arg))
     {
@@ -388,15 +394,15 @@ class CWalletTx : public CMerkleTx
         fAvailableWatchCreditCached = false;
         fChangeCached = false;
         fInMempool = false;
-        nDebitCached = 0;
-        nCreditCached = 0;
-        nImmatureCreditCached = 0;
-        nAvailableCreditCached = 0;
-        nWatchDebitCached = 0;
-        nWatchCreditCached = 0;
-        nAvailableWatchCreditCached = 0;
-        nImmatureWatchCreditCached = 0;
-        nChangeCached = 0;
+        nDebitCached = CAmountMap();
+        nCreditCached = CAmountMap();
+        nImmatureCreditCached = CAmountMap();
+        nAvailableCreditCached = CAmountMap();
+        nWatchDebitCached = CAmountMap();
+        nWatchCreditCached = CAmountMap();
+        nAvailableWatchCreditCached = CAmountMap();
+        nImmatureWatchCreditCached = CAmountMap();
+        nChangeCached = CAmountMap();
         nOrderPos = -1;
     }
 
@@ -448,6 +454,7 @@ class CWalletTx : public CMerkleTx
         fImmatureWatchCreditCached = false;
         fDebitCached = false;
         fChangeCached = false;
+        WipeUnknownBlindingData();
     }
 
     void BindWallet(CWallet *pwalletIn)
@@ -457,12 +464,12 @@ class CWalletTx : public CMerkleTx
     }
 
     //! filter decides which addresses will count towards the debit
-    CAmount GetDebit(const isminefilter& filter) const;
-    CAmount GetCredit(const isminefilter& filter) const EXCLUSIVE_LOCKS_REQUIRED(cs_main);
-    CAmount GetImmatureCredit(bool fUseCache=true) const EXCLUSIVE_LOCKS_REQUIRED(cs_main);
-    CAmount GetAvailableCredit(bool fUseCache=true, const isminefilter& filter=ISMINE_SPENDABLE) const EXCLUSIVE_LOCKS_REQUIRED(cs_main);
-    CAmount GetImmatureWatchOnlyCredit(const bool fUseCache=true) const EXCLUSIVE_LOCKS_REQUIRED(cs_main);
-    CAmount GetChange() const;
+    CAmountMap GetDebit(const isminefilter& filter) const;
+    CAmountMap GetCredit(const isminefilter& filter) const EXCLUSIVE_LOCKS_REQUIRED(cs_main);
+    CAmountMap GetImmatureCredit(bool fUseCache=true) const EXCLUSIVE_LOCKS_REQUIRED(cs_main);
+    CAmountMap GetAvailableCredit(bool fUseCache=true, const isminefilter& filter=ISMINE_SPENDABLE) const EXCLUSIVE_LOCKS_REQUIRED(cs_main);
+    CAmountMap GetImmatureWatchOnlyCredit(const bool fUseCache=true) const EXCLUSIVE_LOCKS_REQUIRED(cs_main);
+    CAmountMap GetChange() const;
 
     // Get the marginal bytes if spending the specified output from this transaction
     int GetSpendSize(unsigned int out, bool use_max_sig = false) const
@@ -475,7 +482,7 @@ class CWalletTx : public CMerkleTx
 
     bool IsFromMe(const isminefilter& filter) const
     {
-        return (GetDebit(filter) > 0);
+        return (GetDebit(filter) > CAmountMap());
     }
 
     // True if only scriptSigs are different
@@ -493,6 +500,48 @@ class CWalletTx : public CMerkleTx
     bool AcceptToMemoryPool(const CAmount& nAbsurdFee, CValidationState& state) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
 
     std::set<uint256> GetConflicts() const;
+
+    // ELEMENTS:
+
+private:
+    /* Computes, stores and returns the unblinded info, or retrieves if already computed previously.
+    * @param[in]    map_index - Where to store the blinding data. Issuance data is stored after the output data, with additional index offset calculated via GetPseudoInputOffset
+    * @param[in]    vchRangeproof - The rangeproof to unwind
+    * @param[in]    conf_value - The value to unblind
+    * @param[in]    conf_asset - The asset to unblind
+    * @param[in]    nonce - The nonce used to ECDH with the blinding key. This is null for issuance as blinding key is directly used as nonce
+    * @param[in]    scriptPubKey - The script being committed to by the rangeproof
+    * @param[out]   blinding_pubkey_out - Pointer to the recovered pubkey of the destination
+    * @param[out]   value_out - Pointer to the CAmount where the unblinded amount will be stored
+    * @param[out]   value_factor_out - Pointer to the recovered value blinding factor of the output
+    * @param[out]   asset_out - Pointer to the recovered underlying asset type
+    * @param[out]   asset_factor_out - Pointer to the recovered asset blinding factor of the output
+    */
+    void GetBlindingData(const unsigned int map_index, const std::vector<unsigned char>& vchRangeproof, const CConfidentialValue& conf_value, const CConfidentialAsset& conf_asset, const CConfidentialNonce nonce, const CScript& scriptPubKey, CPubKey* blinding_pubkey_out, CAmount* value_out, uint256* value_factor_out, CAsset* asset_out, uint256* asset_factor_out) const;
+    void WipeUnknownBlindingData();
+
+public:
+    // For use in wallet transaction creation to remember 3rd party values
+    // Unneeded for issuance.
+    void SetBlindingData(const unsigned int output_index, const CPubKey& blinding_pubkey, const CAmount value, const uint256& value_factor, const CAsset& asset, const uint256& asset_factor);
+
+    //! Returns either the value out (if it is known) or -1
+    CAmount GetOutputValueOut(unsigned int ouput_index) const;
+
+    //! Returns either the blinding factor (if it is to us) or 0
+    uint256 GetOutputAmountBlindingFactor(unsigned int output_index) const;
+    uint256 GetOutputAssetBlindingFactor(unsigned int output_index) const;
+    //! Returns the underlying asset type, or 0 if unknown
+    CAsset GetOutputAsset(unsigned int output_index) const;
+    // ! Returns receiver's blinding pubkey
+    CPubKey GetOutputBlindingPubKey(unsigned int output_index) const;
+    //! Get the issuance blinder for either the asset itself or the issuing tokens
+    uint256 GetIssuanceBlindingFactor(unsigned int input_index, bool reissuance_token) const;
+    //! Get the issuance amount for either the asset itself or the issuing tokens
+    CAmount GetIssuanceAmount(unsigned int input_index, bool reissuance_token) const;
+
+    //! Get the mapValue offset for a specific vin index and type of issuance pseudo-input
+    unsigned int GetPseudoInputOffset(unsigned int input_index, bool reissuance_token) const;
 };
 
 class COutput
@@ -535,7 +584,7 @@ class COutput
 
     inline CInputCoin GetInputCoin() const
     {
-        return CInputCoin(tx->tx, i, nInputBytes);
+        return CInputCoin(tx, i, nInputBytes);
     }
 };
 
@@ -578,6 +627,40 @@ struct CoinSelectionParams
     CoinSelectionParams() {}
 };
 
+struct IssuanceDetails {
+    bool issuing = false;
+
+    bool blind_issuance = true;
+    CAsset reissuance_asset;
+    CAsset reissuance_token;
+    uint256 entropy;
+};
+
+struct BlindDetails {
+    bool ignore_blind_failure = true; // Certain corner-cases are hard to avoid
+
+    // Temporary tx-specific details.
+    std::vector<uint256> i_amount_blinds;
+    std::vector<uint256> i_asset_blinds;
+    std::vector<CAsset>  i_assets;
+    std::vector<CAmount> i_amounts;
+    std::vector<CAmount> o_amounts;
+    std::vector<CPubKey> o_pubkeys;
+    std::vector<uint256> o_amount_blinds;
+    std::vector<CAsset>  o_assets;
+    std::vector<uint256> o_asset_blinds;
+    // We need to store an unblinded and unsigned version of the transaction
+    // in case of !sign
+    CMutableTransaction tx_unblinded_unsigned;
+
+    int num_to_blind;
+    int change_to_blind;
+    // Only used to strip blinding if its the only blind output in certain situations
+    int only_recipient_blind_index;
+    // Needed in case of one blinded output that is change and no blind inputs
+    int only_change_pos;
+};
+
 class WalletRescanReserver; //forward declarations for ScanForWalletTransactions/RescanFromTime
 /**
  * A CWallet is an extension of a keystore, which also maintains a set of transactions and balances,
@@ -708,7 +791,7 @@ class CWallet final : public CCryptoKeyStore, public CValidationInterface
      * all coins from coinControl are selected; Never select unconfirmed coins
      * if they are not ours
      */
-    bool SelectCoins(const std::vector<COutput>& vAvailableCoins, const CAmount& nTargetValue, std::set<CInputCoin>& setCoinsRet, CAmount& nValueRet,
+    bool SelectCoins(const std::vector<COutput>& vAvailableCoins, const CAmountMap& mapTargetValue, std::set<CInputCoin>& setCoinsRet, CAmountMap& mapValueRet,
                     const CCoinControl& coin_control, CoinSelectionParams& coin_selection_params, bool& bnb_used) const;
 
     /** Get a name for this wallet for logging/debugging purposes.
@@ -765,6 +848,11 @@ class CWallet final : public CCryptoKeyStore, public CValidationInterface
     //The offline xpub aka `bitcoin_xpub` in the wallet set by `initpegoutwallet`
     CExtPubKey offline_xpub;
 
+    // Master derivation blinding key
+    uint256 blinding_derivation_key;
+    // Specifically imported blinding keys
+    std::map<CScriptID, uint256> mapSpecificBlindingKeys;
+
     // END ELEMENTS
 
     const CWalletTx* GetWalletTx(const uint256& hash) const;
@@ -775,7 +863,7 @@ class CWallet final : public CCryptoKeyStore, public CValidationInterface
     /**
      * populate vCoins with vector of available COutputs.
      */
-    void AvailableCoins(std::vector<COutput>& vCoins, bool fOnlySafe=true, const CCoinControl *coinControl = nullptr, const CAmount& nMinimumAmount = 1, const CAmount& nMaximumAmount = MAX_MONEY, const CAmount& nMinimumSumAmount = MAX_MONEY, const uint64_t nMaximumCount = 0, const int nMinDepth = 0, const int nMaxDepth = 9999999) const EXCLUSIVE_LOCKS_REQUIRED(cs_main, cs_wallet);
+    void AvailableCoins(std::vector<COutput>& vCoins, bool fOnlySafe=true, const CCoinControl *coinControl = nullptr, const CAmount& nMinimumAmount = 1, const CAmount& nMaximumAmount = MAX_MONEY, const CAmount& nMinimumSumAmount = MAX_MONEY, const uint64_t nMaximumCount = 0, const int nMinDepth = 0, const int nMaxDepth = 9999999, const CAsset* = nullptr) const EXCLUSIVE_LOCKS_REQUIRED(cs_main, cs_wallet);
 
     /**
      * Return list of available coins and locked coins grouped by non-change output address.
@@ -793,8 +881,8 @@ class CWallet final : public CCryptoKeyStore, public CValidationInterface
      * completion the coin set and corresponding actual target value is
      * assembled
      */
-    bool SelectCoinsMinConf(const CAmount& nTargetValue, const CoinEligibilityFilter& eligibility_filter, std::vector<OutputGroup> groups,
-        std::set<CInputCoin>& setCoinsRet, CAmount& nValueRet, const CoinSelectionParams& coin_selection_params, bool& bnb_used) const;
+    bool SelectCoinsMinConf(const CAmountMap& mapTargetValue, const CoinEligibilityFilter& eligibility_filter, std::vector<OutputGroup> groups,
+        std::set<CInputCoin>& setCoinsRet, CAmountMap& mapValueRet, const CoinSelectionParams& coin_selection_params, bool& bnb_used) const;
 
     bool IsSpent(const uint256& hash, unsigned int n) const EXCLUSIVE_LOCKS_REQUIRED(cs_main);
     std::vector<OutputGroup> GroupOutputs(const std::vector<COutput>& outputs, bool single_coin) const;
@@ -883,13 +971,13 @@ class CWallet final : public CCryptoKeyStore, public CValidationInterface
     void ResendWalletTransactions(int64_t nBestBlockTime, CConnman* connman) override EXCLUSIVE_LOCKS_REQUIRED(cs_main);
     // ResendWalletTransactionsBefore may only be called if fBroadcastTransactions!
     std::vector<uint256> ResendWalletTransactionsBefore(int64_t nTime, CConnman* connman) EXCLUSIVE_LOCKS_REQUIRED(cs_main);
-    CAmount GetBalance(const isminefilter& filter=ISMINE_SPENDABLE, const int min_depth=0) const;
-    CAmount GetUnconfirmedBalance() const;
-    CAmount GetImmatureBalance() const;
-    CAmount GetUnconfirmedWatchOnlyBalance() const;
-    CAmount GetImmatureWatchOnlyBalance() const;
-    CAmount GetLegacyBalance(const isminefilter& filter, int minDepth) const;
-    CAmount GetAvailableBalance(const CCoinControl* coinControl = nullptr) const;
+    CAmountMap GetBalance(const isminefilter& filter=ISMINE_SPENDABLE, const int min_depth=0) const;
+    CAmountMap GetUnconfirmedBalance() const;
+    CAmountMap GetImmatureBalance() const;
+    CAmountMap GetUnconfirmedWatchOnlyBalance() const;
+    CAmountMap GetImmatureWatchOnlyBalance() const;
+    CAmountMap GetLegacyBalance(const isminefilter& filter, int minDepth) const;
+    CAmountMap GetAvailableBalance(const CCoinControl* coinControl = nullptr) const;
 
     OutputType TransactionChangeType(OutputType change_type, const std::vector<CRecipient>& vecSend);
 
@@ -905,9 +993,9 @@ class CWallet final : public CCryptoKeyStore, public CValidationInterface
      * selected by SelectCoins(); Also create the change output, when needed
      * @note passing nChangePosInOut as -1 will result in setting a random position
      */
-    bool CreateTransaction(const std::vector<CRecipient>& vecSend, CTransactionRef& tx, CReserveKey& reservekey, CAmount& nFeeRet, int& nChangePosInOut,
-                           std::string& strFailReason, const CCoinControl& coin_control, bool sign = true);
-    bool CommitTransaction(CTransactionRef tx, mapValue_t mapValue, std::vector<std::pair<std::string, std::string>> orderForm, CReserveKey& reservekey, CConnman* connman, CValidationState& state);
+    bool CreateTransaction(const std::vector<CRecipient>& vecSend, CTransactionRef& tx, std::vector<std::unique_ptr<CReserveKey>>& reservekey, CAmount& nFeeRet, int& nChangePosInOut,
+                           std::string& strFailReason, const CCoinControl& coin_control, bool sign = true, BlindDetails* blind_details = nullptr, const IssuanceDetails* issuance_details = nullptr);
+    bool CommitTransaction(CTransactionRef tx, mapValue_t mapValue, std::vector<std::pair<std::string, std::string>> orderForm, std::vector<std::unique_ptr<CReserveKey>>& reservekey, CConnman* connman, CValidationState& state, const BlindDetails* blind_details = nullptr);
 
     bool DummySignTx(CMutableTransaction &txNew, const std::set<CTxOut> &txouts, bool use_max_sig = false) const
     {
@@ -973,19 +1061,24 @@ class CWallet final : public CCryptoKeyStore, public CValidationInterface
      * Returns amount of debit if the input matches the
      * filter, otherwise returns 0
      */
-    CAmount GetDebit(const CTxIn& txin, const isminefilter& filter) const;
+    CAmountMap GetDebit(const CTxIn& txin, const isminefilter& filter) const;
     isminetype IsMine(const CTxOut& txout) const;
-    CAmount GetCredit(const CTxOut& txout, const isminefilter& filter) const;
+    CAmountMap GetCredit(const CTxOut& txout, const isminefilter& filter) const;
     bool IsChange(const CTxOut& txout) const;
-    CAmount GetChange(const CTxOut& txout) const;
+    CAmountMap GetChange(const CTxOut& txout) const;
     bool IsMine(const CTransaction& tx) const;
     /** should probably be renamed to IsRelevantToMe */
     bool IsFromMe(const CTransaction& tx) const;
-    CAmount GetDebit(const CTransaction& tx, const isminefilter& filter) const;
+    CAmountMap GetDebit(const CTransaction& tx, const isminefilter& filter) const;
     /** Returns whether all of the inputs match the filter */
     bool IsAllFromMe(const CTransaction& tx, const isminefilter& filter) const;
-    CAmount GetCredit(const CTransaction& tx, const isminefilter& filter) const;
-    CAmount GetChange(const CTransaction& tx) const;
+    CAmountMap GetCredit(const CTransaction& tx, const isminefilter& filter) const;
+    CAmountMap GetChange(const CTransaction& tx) const;
+
+    // ELEMENTS:
+    CAmountMap GetCredit(const CWalletTx& wtx, const isminefilter& filter) const;
+    CAmountMap GetChange(const CWalletTx& wtx) const;
+
     void ChainStateFlushed(const CBlockLocator& loc) override;
 
     DBErrors LoadWallet(bool& fFirstRunRet);
@@ -1149,6 +1242,20 @@ class CWallet final : public CCryptoKeyStore, public CValidationInterface
     bool SetOfflineCounter(int counter);
     bool SetOfflineDescriptor(const std::string& offline_desc_in);
     bool SetOfflineXPubKey(const CExtPubKey& offline_xpub_in);
+
+    void ComputeBlindingData(const CConfidentialValue& conf_value, const CConfidentialAsset& conf_asset, const CConfidentialNonce& nonce, const CScript& scriptPubKey, const std::vector<unsigned char>& vchRangeproof, CAmount& value, CPubKey& blinding_pubkey, uint256& value_factor, CAsset& asset, uint256& asset_factor) const;
+
+    // First looks in imported blinding key store, then derives on its own
+    CKey GetBlindingKey(const CScript* script) const;
+    // Pubkey accessor for GetBlindingKey
+    CPubKey GetBlindingPubKey(const CScript& script) const;
+
+    bool LoadSpecificBlindingKey(const CScriptID& scriptid, const uint256& key);
+    bool AddSpecificBlindingKey(const CScriptID& scriptid, const uint256& key);
+    bool SetMasterBlindingKey(const uint256& key);
+
+    /// Returns a map of entropy to the respective pair of reissuance token and issuance asset.
+    std::map<uint256, std::pair<CAsset, CAsset> > GetReissuanceTokenTypes() const;
 };
 
 /** A key allocated from the key pool. */
@@ -1170,6 +1277,18 @@ class CReserveKey final : public CReserveScript
     CReserveKey() = default;
     CReserveKey(const CReserveKey&) = delete;
     CReserveKey& operator=(const CReserveKey&) = delete;
+    // ELEMENTS:
+    CReserveKey& operator=(CReserveKey&&) = delete;
+    CReserveKey(CReserveKey&& in) {
+        // Copy fields over
+        pwallet = in.pwallet;
+        nIndex = in.nIndex;
+        vchPubKey = in.vchPubKey;
+        fInternal = in.fInternal;
+        // Invalidate the object being moved from
+        in.nIndex = -1;
+        in.vchPubKey = CPubKey();
+    }
 
     ~CReserveKey()
     {
diff --git a/src/wallet/walletdb.cpp b/src/wallet/walletdb.cpp
index 2ae72d056996a..47acfaae047f0 100644
--- a/src/wallet/walletdb.cpp
+++ b/src/wallet/walletdb.cpp
@@ -174,6 +174,14 @@ bool WalletBatch::WriteOfflineCounter(int counter)
     return WriteIC(std::string("offlinecounter"), counter);
 }
 
+bool WalletBatch::WriteBlindingDerivationKey(const uint256& key) {
+     return WriteIC(std::string("blindingderivationkey"), key);
+}
+
+bool WalletBatch::WriteSpecificBlindingKey(const uint160& scriptid, const uint256& key) {
+    return WriteIC(std::make_pair(std::string("specificblindingkey"), scriptid), key);
+}
+
 class CWalletScanState {
 public:
     unsigned int nKeys;
@@ -466,6 +474,24 @@ ReadKeyValue(CWallet* pwallet, CDataStream& ssKey, CDataStream& ssValue,
             std::string descriptor;
             ssValue >> descriptor;
             pwallet->offline_desc = descriptor;
+        }
+        else if (strType == "blindingderivationkey")
+        {
+            assert(pwallet->blinding_derivation_key.IsNull());
+            uint256 key;
+            ssValue >> key;
+            pwallet->blinding_derivation_key = key;
+        }
+        else if (strType == "specificblindingkey")
+        {
+            CScriptID scriptid;
+            ssKey >> scriptid;
+            uint256 key;
+            ssValue >> key;
+            if (!pwallet->LoadSpecificBlindingKey(scriptid, key)) {
+                strErr = "Error reading wallet database: LoadSpecificBlindingKey failed";
+                return false;
+            }
        } else if (strType != "bestblock" && strType != "bestblock_nomerkle" &&
                 strType != "minversion" && strType != "acentry") {
             wss.m_unknown_records++;
@@ -555,6 +581,16 @@ DBErrors WalletBatch::LoadWallet(CWallet* pwallet)
     if (fNoncriticalErrors && result == DBErrors::LOAD_OK)
         result = DBErrors::NONCRITICAL_ERROR;
 
+    if (pwallet->blinding_derivation_key.IsNull()) {
+        CKey key;
+        key.MakeNewKey(true);
+        uint256 keybin;
+        memcpy(keybin.begin(), key.begin(), key.size());
+        if (!pwallet->SetMasterBlindingKey(keybin)) {
+            result = DBErrors::LOAD_FAIL;
+        }
+    }
+
     // Any wallet corruption at all: skip any rewriting or
     // upgrading, we don't want to make it worse.
     if (result != DBErrors::LOAD_OK)
diff --git a/src/wallet/walletdb.h b/src/wallet/walletdb.h
index cf8884d6a7410..9c21a3876a85b 100644
--- a/src/wallet/walletdb.h
+++ b/src/wallet/walletdb.h
@@ -206,8 +206,9 @@ class WalletBatch
     bool WriteOnlineKey(const CPubKey& online_key);
     bool WriteOfflineCounter(int counter);
     bool WriteOfflineDescriptor(const std::string& offline_desc);
-    // DEPRECATED
     bool WriteOfflineXPubKey(const CExtPubKey& offline_xpub);
+    bool WriteBlindingDerivationKey(const uint256& key);
+    bool WriteSpecificBlindingKey(const uint160& scriptid, const uint256& key);
 
     DBErrors LoadWallet(CWallet* pwallet);
     DBErrors FindWalletTx(std::vector<uint256>& vTxHash, std::vector<CWalletTx>& vWtx);
diff --git a/test/bitcoin_functional/functional/rpc_rawtransaction.py b/test/bitcoin_functional/functional/rpc_rawtransaction.py
index d86b546c7d14c..954700ce98321 100755
--- a/test/bitcoin_functional/functional/rpc_rawtransaction.py
+++ b/test/bitcoin_functional/functional/rpc_rawtransaction.py
@@ -74,7 +74,7 @@ def run_test(self):
         assert_raises_rpc_error(-1, "createrawtransaction", self.nodes[0].createrawtransaction, [])
 
         # Test `createrawtransaction` invalid extra parameters
-        assert_raises_rpc_error(-1, "createrawtransaction", self.nodes[0].createrawtransaction, [], {}, 0, False, 'foo')
+        #assert_raises_rpc_error(-1, "createrawtransaction", self.nodes[0].createrawtransaction, [], {}, 0, False, 'foo')
 
         # Test `createrawtransaction` invalid `inputs`
         txid = '1d1d4e24ed99057e84c3f80fd8fbec79ed9e1acee37da269356ecea000000000'
diff --git a/test/bitcoin_functional/functional/test_framework/util.py b/test/bitcoin_functional/functional/test_framework/util.py
index 3d4c3e471cc29..5c279c3ff137f 100644
--- a/test/bitcoin_functional/functional/test_framework/util.py
+++ b/test/bitcoin_functional/functional/test_framework/util.py
@@ -307,7 +307,7 @@ def initialize_datadir(dirname, n, chain):
         f.write("con_connect_coinbase=0\n")
         f.write("anyonecanspendaremine=0\n")
         f.write("con_blockheightinheader=0\n")
-        f.write("con_elementswitness=0\n")
+        f.write("con_elementsmode=0\n")
         f.write("con_signed_blocks=0\n")
         f.write("multi_data_permitted=0\n")
         f.write("walletrbf=0\n") # Default is 1 in Elements
@@ -316,6 +316,7 @@ def initialize_datadir(dirname, n, chain):
         f.write("con_bip66height=1251\n")
         f.write("con_genesis_style=bitcoin\n")
         f.write("con_csv_deploy_start=0\n") # Default is -1 (always active)
+        f.write("blindedaddresses=0\n")
         os.makedirs(os.path.join(datadir, 'stderr'), exist_ok=True)
         os.makedirs(os.path.join(datadir, 'stdout'), exist_ok=True)
     return datadir
diff --git a/test/functional/data/rpc_getblockstats.json b/test/functional/data/rpc_getblockstats.json
index f20ce845b591b..e9467ca460f3d 100644
--- a/test/functional/data/rpc_getblockstats.json
+++ b/test/functional/data/rpc_getblockstats.json
@@ -1,117 +1,117 @@
 {
   "blocks": [
-    "0100000000000000000000000000000000000000000000000000000000000000000000007598567fa9cac9236823eb32b293121c11b51e39e14c35fb7114840d9883d23bdae5494d00000000015100010100000000010000000000000000000000000000000000000000000000000000000000000000ffffffff212000c7ac6641f4d9f883879df37385a9998553114d01c2c8e47608581773d7db37ffffffff010000000000000000016a00000000",
-    "0000002066d931a80634d0faa37b4cbb8a02f205677bb1ca3ba9a7cc52aa35e7ba15b8fe406dbfcd6f199cbde669d09fc693c9bfa16e4dd1328a2af3d5e56a9ed778c8091194485c01000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff03510101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020e1ef218614ed1c754db1ebfd03ba09a02b98e1da25a51c92fb7549b11b8d7f6730dc3ca7036a1b897e3363e9e60afb5c7f0d0cb0541e108456c0c13221ac567f1294485c02000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff03520101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "000000206f89bd6fdabdee0b88214ec4c88c0ee67af61e1e0a19f98c1b152d06cff10880a55f1f7d55d836e89be3562aa82f04ece8beb56b068c9d15569336c47f44ddc51294485c03000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff03530101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020ac82a0e1088a94229f736534f2b6742e0f956bfed021f11a80c2804acafe53270756391af8f25cc9d9421647fe44ec6bb259505e8308890b35e6b0fab8d272291394485c04000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff03540101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020ec145895e6b8eb9f09f8d2092341e41f8b242ea1886f9f19647aeab12eaa43f65dbaa591d1fea2f722f758c7b227a40f44049a9603d5f9691716b179b2d62e1f1394485c05000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff03550101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "000000208cb70e5924d7d4ab2b17d59bc40457b5437988af0d89d6965a377b0b90f28337bd0ad9b5a44141e2afaa94df473b264aca483dc41328f206dc88336be18fddf11394485c06000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff03560101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "000000206c37cf4f672674df3e44338d8d65c0a81b49c8e760f950bef5bc495f4441a8f1f6ed5658305e579bd629e7e8ad582c028444aaaa1807588c8b1d485a40d59c591394485c07000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff03570101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002068b268edf1bd7faf7d22471519023cb8b4948e4974b20cab6bde9d943dbe9b98b5bd331d8c1817e329f8610c9b9dfff5ef797ba4846f65f70a69d13cd9d886a01494485c08000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff03580101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "000000208e58d5fd78e06af9785faa1688cb37554d7853e5587dc8dfd89e5682429a8c0fe38196eb52284e4a469f66f8ff0f2bb1d2d0bcf427d360d664d63b4160ab98121494485c09000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff03590101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020c4c3e11a9c2e87f28adc1efb671ce10cfb1ad8568401e8b70ad137cae0b0ce6c4ec6fbd4262409af7f35e749b6b60ef4f4667a204eac56b599fb56ab46a1c1981494485c0a000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff035a0101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020567680d46a94b563266ab59233a54c212981764bd48361463b59ebac1bbd9852986399ed6b74d59e090eddfca832982b53aeafe8446d1dfa50564995fdc57d9b1494485c0b000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff035b0101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020d22320cfa272faa61637f3f710b56ac02c93e8ca7cbe3c66f3a35fe2f814a7674fe5db02251a552e8eebf6dd5a7aa87783c90f5f7245d095dfeaadca18910ad01494485c0c000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff035c0101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020c2306ba70c5a8b35513f6f3d5927e7a025d901f6e21bb8ecdbdd55caf9750cc06ba2cf26811d9474d81c46d4960d81d5ed2921d902ec6edce703a70735975d981494485c0d000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff035d0101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020bb5111dcf92969e8ab1b49905696cbb0a794eebf5d14185a76e1e3798aa4410eeee7e285a9f51697b426358f387ea8fc793fde3fd3e2b7555733fa89b0a0634a1594485c0e000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff035e0101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "000000209017c1e6a52bdc1a28aea391e53150ad2d3ac21a126608ffefcd508f462751858a17a5bbfaba9bb802b2ee313b6d0386660a681825c0e71699966126d2a2e39d1594485c0f000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff035f0101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002007f2cb80ace987e15d4892166f137112288e844eebc018b84a9125a7401842f3ac8ce0aefeffea4f60559731a4e083b400b25878e303299218553517725bff9f1594485c10000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff03600101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020b5b80518a6e768d027130a0f2b54cd853856d161c465362c9c60ff737119aaba818bb93f1f00b31c26c44bcd3f55a170f367e10a8f779ce25826fd3bc309d59b1594485c11000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401110101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002082e8dc946cf72bec61b933d5cf1eca879989ffa3c2224969892db3f7203a4c3138f278135cdafeb9cf93013b5c88f47df9dc9029a3a0026b5629966b4745246e1594485c12000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401120101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020b75376b259b8a0e3a6a5dacd6889531d8fcb7dd2594bbdf33e05951e9e5154a484c8129703dd8bce26207fe95b415fda811639e223cd1d0e235104c3dc7483211594485c13000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401130101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "000000206105dfa6504ca3efcd9d995f5880d7b33bb74e8f5bedb005a312f84fc2ff37e2ebf7f6b1221d0a58fb8a88b7b62c7757802ac0dfe4c929f02bb08c85eac71c401694485c14000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401140101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002040c6037d1d5e63dbdb1894aad148f68cb317375058bf0bd4399071f62bcaa13518e389c4e88004d92294b18dcd78323398ca862e1c221e4f6977bb4ee20b888a1694485c15000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401150101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020381f204215b8163868074585ee3334275c61674130be4bcfa0a752c3fd4fc8c359cc1f49f5ca20c64a93a2900ffb3f2a2f4e50b2a8680e545c04c85beec467d91694485c16000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401160101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "000000202bc5e2b05f4e46aae3010f175bb4873647a4468e9323cd8348fadac43cbda2de5ef148efbf7e4c9c984688aee720cbd2468c67c099543288462d9f794fc1a6961694485c17000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401170101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "000000200cbd694b4f469d67e428881d5734a62d1b5de761682ec070d590ece1ea4786c321d4c2afd1b036b19a148742f97759f800f924ddba7b2621a319d963835fe0611694485c18000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401180101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "000000209f8cdf1b1eb3cb7c2927ccd97a47cc798fd69d050be0624e3e092eca828315601b0dd077a09a8c603c5b0af4b7c5927dabc281b104ac14a795828aa2277338f51694485c19000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401190101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020075928cae94535cc70fb8f8008b51113ffda0bdcc99ea1525bb77396a7e72dc1c070d8e57f6517697ce447589ae83d9d8b81ad0e17c1e70b86af889cd1f3f4fc1794485c1a000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04011a0101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002060dd6dac54c2688e53124bbef30accb7665e080aa6f144cc9be9430385de77c76300b9151ef45a73671852fb6bc9f3394bc2805959a07318b52256aae1f0cb091794485c1b000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04011b0101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002077ec9d71f61286f0a53b5175c0405a413c4c51ca0a62aab6b93cee6148fb8fca8eec7884ee73bdd519dc329b3f9f07bd392e97c439376a37ddc5492afe9367c51794485c1c000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04011c0101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "000000201f3bea06f93b9491197fde6a37c059fb829aac2f4a5c98d57b4c177500cac51f02f100035d48eee4cdc05cc0a443270c874cff599a021e2d7ab34419dd8cc91f1794485c1d000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04011d0101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002003ef1998abc89439eb094618c521cde00153dff220c80e6c6d6195e5d17f172f25dbc6a4098a842dc1338cd5f461304a134e236dc3d3ecffbea509d027bb661b1794485c1e000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04011e0101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020a6a5e46e17384b4d41f1f4c549df3cb035bc7bac05df01f1d5179fae76582aded2e79cf61b93f3788b5b54050201b68b6ff35afa21205eb5342af05d720bc3d11794485c1f000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04011f0101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020afe9b51f2e0f079639bbd5dbec7208bfcc236107c03aa51b6f357a730e8bafd0358d77e708080c9af7543fecd791bd77d0f26ca403df0a76ccf1d31e6c9f73c71894485c20000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401200101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020975f224cbd66e11d99e8eb21c545592bc620be18ff28b04e9dbd12010e16198e9898f5d8be2b25bbca000ba12bf1fd64699f452941ca05037a98642a967d2ca51894485c21000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401210101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "000000207e349f5b00946744ced973a5a03021ca934763f09716fab04cd7297fd6ccf3433dda375ba4376d214bc8f7008a3cc7d0c71dbf1569b098f2f3cf83558b89b05d1894485c22000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401220101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "000000205a249f8b4fba9b3a2a1d32a7bfbed8345ce25e9407f74cf1e6d363b6d8979bff44a6610ddf01669b04174df2262b700489006c21ff2310e95ab763492384bb411894485c23000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401230101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "000000201ab3897da0ea266fdd6227e5f481a49260fc73187f2bcb8549d77c11572a45ed4d5af81abcef369dd26df0c3a715df275ce7d9db28b801dd3fabfa79773cb33e1894485c24000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401240101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "000000203e533d81eba3851e8993514889b216f6eb07a27b5321eaf59db6ef80081100b852a0ce8f0c5318a661d0fa0063d9646fc3270d40f497f97ca5fb62845a3244251894485c25000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401250101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020038dfd54be3feffba12f4a4b8135c1a89f92ac641bb991c3c8327674458e4bd0d6d78bed0c6222652cdc19fcd860e407e8760e2ccd718299d392cb16b037c7e31994485c26000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401260101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002078647f4feedc4a0b2ef759d83f4d05a2fbb931550bfaadb5e87723ebce582eb21c51755259cb5849f7094617702fe2be87d636322a95c1506278359ced4ab9b51994485c27000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401270101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020285a03442ee19f7fbcde632b1cac616958ed743f83e4ea0bd097ebbe84fa506c1edb45fc35ac0ca66285f89400927ab2cef1609a547babd17af669a5bd44a52f1994485c28000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401280101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020722f73cf91ac7748a793e0ac5989d9826b0bdfb157c0ab02e3906c002cdead61025a5bb3b576e4acbe13ef778bf0c805beaeff9de0ce7a67935f4be7ff073e411994485c29000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401290101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020b22dc34ad29fc2050ebe1ad587abf056a09d7d76ab84af5501b3afef18e601ff523646d2754f5b4157b04814b815cfdc0045d67abe16e2ce6d841518f7d675801994485c2a000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04012a0101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002051904b6439acb096794c9f9729066b0a9353d32b13d02d4072308b0a149572be0b9a943939843b8fd7a8747937a1eb628bc84168bc70d1f9566700a5c6a90ca61994485c2b000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04012b0101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020f8010e22f4fec6c21bc5fe08d6e7cdd2a7f8e6e8586e150e21f740d55f58c21c75204a06f18631273980aef5bfee39c0c72b5d6122a4f87161a276f93707371e1a94485c2c000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04012c0101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "000000208ad30b06401edc96a6fcf4461059386ea53b8c8243e258ec31b42e2170eb1b5e08bd5b23980db05061170163dfa68d611e84cf212a69dfc2bac89894092fb5f01a94485c2d000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04012d0101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020abe780b5f4e2b7819fab1bc1e29bd2682049890b809480a85c2734cb070f31901b8b5d14c71cb5dc9689563bbdeb506dc01c5e04b43060e097391e03a05c4d251a94485c2e000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04012e0101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "000000209b9a96818c3274ac923400711639056373155fdf2dcd45eb559b4a5b9e3aa50ccbcdf9c2ef2d812079bccd147c3eb406d2c57e1139f2dabec44c80078d82be861a94485c2f000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04012f0101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002051243db1bfe9321f7d474b61abd0a0fe8ff601d4d7fedb037c18ea0926e556da339eaeb0776a22b8aa91de95b32f08f1f630f2ccf969d11bfdae055cf80929d81a94485c30000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401300101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020f455d1b01454b2b1e9ccbce18f1a0fe0a9c3dc36dcb437ca2af2d636465228014c2fd897df770175f1bbb30f5875d52341c26d971a28742488371e53b450b2761a94485c31000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401310101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020aaf15d370dceafd10320c629db9e3510672ea7e552d8fb7f596439da210e177c15bf85c0de2eeb0eac3ba5a22daa7bc4872f58a6e9b24aa87a0be1403a800a4a1b94485c32000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401320101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "000000202064af4b2a01947e6c5f60301f50cea1e911a9f4c7efc33b6d40b3ba5bb955871c4d4f7e4be7112399d2026632b99ee96e1b320f6f6341020f1a5c45358eca611b94485c33000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401330101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002096547d2e54e556c3bb3e60bc8292a2fa71f88ca037dce0cea6400412ba02e13a8724df616628435f026cf80b2b60cf8c4e5cbf0d91fdd9b353376a24f052e84d1b94485c34000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401340101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "000000204484e29eade1230005694cd5e42f2241d6c908a2c9320436b4b375e769faf3115375dfd165ba20c7f44be9a64fe4c88c6a75992567973bbc50ede5f5778ea1c71b94485c35000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401350101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002066b781a861448e1f5530a7183610340a89e73f09e44acbde6d75d511c512145cd89deddaecfe6a5906aa4ccd5ed87e8c8afe3c136966e403b94a1edee0d3886a1b94485c36000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401360101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020561e9ae40ad375ab6250f1511503d7793ad8713f6627d8637e9e3f8e3bbfb671161c266a79a4ac0f73ce72e693a7a7ebfb43e1db61026aeaa56f7ae956f508a61b94485c37000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401370101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020d520466bcc57031c5a5668dbde0331e892e88214ce9c87a534bf6afb1db9c2c9ae1b96a2143a1748c034d5e6db2cb04d2fb58720cdc120a6f6f801472f5745521c94485c38000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401380101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "000000209ea17e59179d6a0210901e381b5b53209a8d5ee8523ce03031804b7f52df682316ff97f5e27c866ba18f912de54ade046f73385982de9a7af7b626c109e4ef281c94485c39000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401390101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020d08bcc1f2cb409803a5819dc95e415afd37adb0902ced2cf713585de31009aec4eddb0ee7650081d28e774c42b49d3468d2bc6b38579b4f44da580b124e1e2381c94485c3a000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04013a0101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020331c7f4dae2206c47e68bf14b49eaf95d6436b90b66aba37394df72aaa28b05a815064858c2b9dc80f669deeefb79d25abc6ec6224ed67b2704f8611c9d526fd1c94485c3b000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04013b0101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020bf3c1626a3c70345124b9ce1b0c269216788dfeabaa0346831a405645bc8cbe00b9c98a421479ae9a06c6da1b4339838b6998ae7a87053a61c9b0bda3e3707f11c94485c3c000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04013c0101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "000000204b1cfbc2f7f1b206d76ce233ee2d97cb8bff35d2c66b0170734748444f7ef8caebed3d60cc21fef288ab6376bf30091d1eb1761fb6a22fd8c5db1d3ffd5be6e61c94485c3d000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04013d0101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020dd893834f13d6b922b05c764a1146fba095ac521e97e3ad8accca31de12431e828ceeff16aabf29080e3198043ac9bfd166b324fd02f123cc1858dae6a53c0e51d94485c3e000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04013e0101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002068f0624d88bff3322a84de1ce434de3ae053f1d453df0ab9d043f920e0130b5a2d69f02fb14d31e9bf7274c8d008a45ff7d465b221a65c7609c4a2970895c4901d94485c3f000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04013f0101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020f52b91661ccd0e534dd2288dbc2344e15c871a64a757a050ca9cf4e38f9cad2215c4d67b92d64130918f8b075e82ac55ba5a7c23e7a742c5a197e013391c34291d94485c40000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401400101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "000000203bdbde3de1cecbeee84a1cfa873f735ae624efaa703472bc9da219b458769d01bdbfe3bb853322fe5126817ec7b3866d86da94104b2bf9a198fb952a5cace4691d94485c41000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401410101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002064b8ef38cc37bb7ea4fbccb0c805efba66b9cb069ec59219d10abba7dd2cdbcf4a6241542321faa75b5819888faff7bd55b2c6fb933a6045ec97560c05d453891d94485c42000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401420101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020b9cc62a3b91bec65f1270b43b2a628ac5e58a27cc66f4f9f201eb514d084492b1ca0c811d00fb7bb07b6d0cdf20d95a63868be34b02948d2bab2b8c24af664b21d94485c43000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401430101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020f6fc241741200209aee295ac02fc28534c0c859baf01a9a8a6edabf5a7da47e7721ebb23e72e3c0caec8eba8a50d9962a32eebf1f6f2822ad1cf97abb876f57b1e94485c44000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401440101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002081fd3ec936e08cc76bd4e9bdbb76d2b572d0da2f1c4aa56d8745a0e1c671a74a9872323259654bcbecaf03d659594b05ada5aa270caf0e8611db8b3bf74dfdd41e94485c45000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401450101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020f6e319ebf9d622aa6803edda3f855658118410098a2adeffe33d135a2e260552525d4e6fb86d02aec0d6a0b0d99cd6b7a556e4aeca317f84567a41c3f532017c1e94485c46000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401460101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020a8a5489b4f0d5cec7c457079b41adbc0df68f4d5f3d1e21e8090b1afb0ad097d656204f99599b93b91654100ef5023c7e3bead10fe853158418d15826142d4be1e94485c47000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401470101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020595552d02db74e4b8426aaf00da1804f28532e25f353b71778f565a4288b802761d973b668db6107f8e375ad0cc696f2aa301d17d5df8c72acdfabd09e3425c11e94485c48000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401480101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "000000208a7eb98cdadc6b294105b27abe6ee617951fd89c2d1ac2610130e79de75cfb3fcf8c7daf6ac82f12e4085ba1d6a4e4bb37987a19aeb955cd1d3ca52e5cb94fcb1e94485c49000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401490101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "000000200a25f2f5137da2ef048e11211278a64c63554bf791250d9bfe85ba9d2d269833d0cec20593f73178d7ada10e5d39d2c354e604a1564e1fbd44fbbbb8730e33c51f94485c4a000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04014a0101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002045fe5aa1b1ad10a8a102530b46c622a8ad0928231c51aebd855f311c8d0b1e22afd4f46f62189477bc4c363a3b8ddea763bcd03bce17c675a0a8233238172ed31f94485c4b000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04014b0101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020b793ef685f3ceb67158e44e01bcac490699c57bdf90cf7a82e8f23d7150eb850d8caf96ab291f7aface4cf3d326e3a26869ae332aabf29268ff2caec3179d8641f94485c4c000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04014c0101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "000000208a87cd963e394675944a818df597d9248bebbd37cbe5ebd2ffc7622f3f7715b9028955f4d9cba51b3f20e5a57d5cba5d293caee2c22f39d2896babf408a6a1ec1f94485c4d000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04014d0101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020152005678b0eb36f0cd76b9391bfe85cc8bc9608e8def41a72ea866c9c4d50678d4b2c8a206131aa133a52d4f79b2d215cd69d2c9afb17c83f7cbe3bc4862b3e1f94485c4e000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04014e0101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002019e42ece448b7afd3a2d069a891559458d1c4666471a000bf08d55aea9e5a52804d35048f814d3c9c91fd2d4264014aa6a2a0db00e90c1370b5020abb0e3ab741f94485c4f000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04014f0101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020efb6ef3df6c2ed7a79af393f133ddf83fdca0f303534f5a2c5c2be63e78b9c91522eb4d5122c66a0361bc65c64984fd3ff4aa8c2ca110eb21e0d855086e663fe2094485c50000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401500101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020801d05baeb47244ad678486a5804023e6a8302c13cb990d07d360db02acf04565f64098dee95479f014f9360d413d33c70c948923b189997b65f2b19a610e2392094485c51000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401510101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "000000203ee3a4e811c091ed982ebe117f9f960c0d29d697d8ed39c3b9e892bf70afca040d6bac48fdc5612e6a9cead9ce44bfbf554202001c233725bb9b9fbfd5b430d02094485c52000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401520101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020151b1756313d52efaa33bbbf5e013e61cbaee2200218d50558d3d6caa0c134e8de3a05820dabdc5ca501912a4640906f2198bb57f861be251a029f5982a7343c2094485c53000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401530101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "000000200e4c027b78103e4d7971c29ad0307dddbc14915f7f598d994fa47976ac2fa3f384c2b92e06bb9b58a4e7b04ca44ee544520044deca1829948348b225681048772094485c54000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401540101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020c95daea532659cce0496acb55667999422d8ec897be94af348c6adffe29bd2245e722a00b1bc737dda2e95b87dc175f57049c2b6246e72d0d6ef252eb2cce0442094485c55000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401550101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020995795830a41eb30efdc77db361f2092ca7cd222a148bfdeb823685df8395ac08284787496520322540b18aeb78ca8703f56b7e1dbd9396fd65ce53049da6c272194485c56000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401560101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002030646eaaf9046a65a3b67b2bfeb2807f705110ed87a67c2769dc598b471128948a797a9383f9babe23211276dd4800d1faa0bc2022a2b53c7473585c474d5f1a2194485c57000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401570101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "000000200de4b037c047be1b61ccf195d096029ef6144dc1e74393c9e55d69d19bfdda1340db8f52cada76a84298d7b773484b8b7d7d0a053a18e1473855fcc879db25a32194485c58000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401580101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020656f984b4c383918e106c9bc3138a29fe00be7a6524b62d60bef87d47775619b5e1c16c9adfd79af6376ab0447e8a40572053b8e4e85bcbfffae5f8fa1b6678f2194485c59000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401590101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020b92c503dcb34abed28efcd1a7db5d944d6293cc8bf22a7065c1d1a06741802d772b7b1c28ca485a1ab77af9d496262d3240e720053d4137d7b897c144586fd5b2194485c5a000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04015a0101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020536a377271d6f0843351bc8e14240be8ad03553a77f0aff4e5d32d7f76f3ae146607eb28b814aa80b972103414968acf4a7aee777b902b186e632de1be44ae7c2194485c5b000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04015b0101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002071f30960a35b079d0b462090c4eb97fe21a5d29996cc16188861fbf52af96ac203ce45f1530d6512068fe40be43e9947bea93dcf20e3b58d57fe4efcd04b50b22294485c5c000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04015c0101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020f4822749c9cf3165f2dfd4dc4018908d8d3a17046882db6c19c8fdbc25149dd1ebc1eed7218a663962cb905a7a54b9137faa95a5af817bd1a566f4cba99f3ee52294485c5d000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04015d0101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "000000203eb887bb4f16f7194703f2cf4992ee9c80b33dda6282525731233215338ee2f1935ac11a2b054239c3b42b25413b6fa2111b829024704e629667abe5f67b6cce2294485c5e000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04015e0101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "000000208003731ee2fa4db8acc9f9a2e436ddfbfdc478ab79297f706c373b8202e2aa4658431246a2fd79c733db727a03585bbb93ab83e24c4353ac94376c02764bdb2d2294485c5f000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04015f0101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002085ef1e4040640e90f32048629697188c48f17d028f511d7e5f569830348de1ca44eb73bcd2f14e778a53b7039f1e7deda8741cded0755e2ca9a2baab283a931b2294485c60000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401600101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "0000002086b95a5f98dfc9c584af9fe4d41b3e290a89b0751faf1172555e3400fdb08165e401b34e64b43819794ff586d0e8c09b84e1b78107713e97680e9fc0177236642294485c61000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401610101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020c638ea96808859efb035f3bc04c769a6e91095c0eea5c8b946f0f52b9b5fc915bc74416168b2d7f2f51a5643c8b4f6d51fb53a08a5cf3726d430f3f7359ea1082394485c62000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401620101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "000000200e6ff0a560cbaaed3ff887eadf7d9c5a382379d21e94f9f40ba6cfed31eeb860b2a17d595fed723dd3ba50080a443f1ef51b720c798c405d2b63dd9023cf503d2394485c63000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401630101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "000000204be76ff6ebef359465181334f047bb3ea6f31a6d336d632541ebce55f12f774a1371081c73fc174e0142b8c02f6c20898183602a1a29e194f27ad242704dd2c42394485c64000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401640101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "000000204ad82d3fb65f2acff5188150de9bff43b93d0840ff61ed1783234c89bc953685a42615727be6082edfb68f905eb24d43fadb1d8660356aa41de018028f5c8bbd2394485c65000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401650101ffffffff0200f2052a010000002321025a004424c7a8fd1c16b637de5c1c578c74ff6bd84cb8fd0ca988f3a38582177dac0000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf9000000000120000000000000000000000000000000000000000000000000000000000000000000",
-    "00000020a95e653d74369746d0cd4d1621d39d7a2f3d3d33dd48d49123f107db7b6275d57f59a2b53ddfd8550f475741231f4ddf5b9851d6f1b9850853f3ecd827e2dc622394485c66000000015100020200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401660101ffffffff02b000062a010000002321037a347beb29fe060e6615746d992d19ffddb79cf16271c6d62898f1a3ce6083abac0000000000000000266a24aa21a9ed382d8ee84912819e6b649a5a54d7e68a6e37c4acdf4ec12b748826102522965c000000000120000000000000000000000000000000000000000000000000000000000000000000020000000001406dbfcd6f199cbde669d09fc693c9bfa16e4dd1328a2af3d5e56a9ed778c809000000004847304402207903f363462ae33fd93d8b8b4614d304e5c4eb3962df40b34485b2d6b79efdb70220263627a5c078c00afeeaeef51aff551114c0f53d703703a178bf580eb6b9b7b601feffffff0250bb9a3b0000000017a9142540c8553467c857872beab516a8e49b45f0dc678700286bee0000000017a914b7b1b4f0bbd20ed1a3fece3a020788acc3fa51478765000000",
-    "000000204d18791c9c8759359417190f39a9bf95780c4f3d6e7f54912dc5fb4e45ac65a06bdbc4996ca7e4e150c02ec82c1c83c1b29a3bcb85d4db0e217050e4604d63042394485c67000000015100040200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401670101ffffffff0230d0062a01000000232103d589857eec54577e93187c860bbc21906cd2e3991e30b335e335a4b307e8f3e7ac0000000000000000266a24aa21a9ede8a4c76ed6fde1bc29c8c2aedaf6e1af1cae3da72ef388e02371e21ee429522f0000000001200000000000000000000000000000000000000000000000000000000000000000000200000001016602a58784d330b83ee75a3d1d2570559bc4c55026e9a752f214a6255b9091ac0000000017160014298ea0a8cf41be1c95314139000897d610d0f3a7feffffff0250daa4350000000017a9140275d54d5cb288e535b74d31651871fc24d79b7787781ef5050000000017a914f7d87fc9bcfa051231b8d4f8ef3593fffaeb22bd87660000000247304402202bbbd7274eaae8da997df4d277ec6a860db5d81c78853bf722c6f39f9c416832022036e3edfe98deaf529f3ee614886b9d151df550446e1aa28005eb393d3800539d0121035e775dc614b3aece22e0ae171c06b1b8890a18d2aa1fd139a961d745c597add6000200000001016602a58784d330b83ee75a3d1d2570559bc4c55026e9a752f214a6255b9091ac010000001716001490d8469f4e9599284deeccf15f39aa5dee6f30befeffffff0208bd9a3b0000000017a914a36bf947ef6c17e05ee4dcf9471cb4347638b48687005ed0b20000000017a914c84692d657a501cc55ad8abd049c5fca58c046fb8766000000024730440220459a9375d9e5f32a5ceba02b5daa97f22a269772ef21cb83a11ce4a86e878ca202207afdebafef7fa19f8a589f3959a7d82e923fe35d2e957e2230311a0b196c3c30012102c7c26a51eac8807a484e1f7d1f5de05f8fff34ed7fabd693108ec8e80eec0e9a0002000000000130dc3ca7036a1b897e3363e9e60afb5c7f0d0cb0541e108456c0c13221ac567f000000004847304402204a8d1138a2e541a72284b9117d6ba2415badcf99599727655e29e08dc2a45f82022076285b20f39b342a3b50bc1086dc961b6b87409aff5c2ffe58f4304bc89f0f3501feffffff0250196bee0000000017a9142495b94e85e0da12acb560c6ffe614bccdd832338700ca9a3b0000000017a9141c9a1ac350b456023783da15517d74b558dcf96e872f000000"
+    "010000000000000000000000000000000000000000000000000000000000000000000000c3393f62b02c95bb8e3a7cee6d34687082cc6ed5e429681de5a1b14212eb3864dae5494d00000000015100010100000000010000000000000000000000000000000000000000000000000000000000000000ffffffff212000c7ac6641f4d9f883879df37385a9998553114d01c2c8e47608581773d7db37ffffffff0101000000000000000000000000000000000000000000000000000000000000000001000000000000000000016a00000000",
+    "000000202f0f28e1b187fae66482e1e77438f5603f4403d088d87b6bbde8f836da913012bbd98a024d2d70aad2ef8b3e1a78ef1ff6599b290b201ef8a2126b9f9fb0e77c9d02915c01000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff03510101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "000000202da1ec9ce665e93156f36852603cfd784949565b44993a55f70f9bcb4803f8b9d7db3d92282cc077872146cdfc056f7170e51adc63d84de22cd6a2037f43dedc9e02915c02000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff03520101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "000000208204334cc672af3631e50007a19a638df5ba01666b1ce3d0a8725917e1ef923cc41b602b6ebf608a2197a5e93c0a1c7c5aca7c0bc6d48adb19bfff959c46e6bd9e02915c03000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff03530101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "000000209e01b460e9badcbbb8f25a1d358129f6041da2d95143b919c64235542a9d61d69b0fc435198ff7a3ae06b444d144fb396e977d8d7f16960338f2a9339d1120729f02915c04000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff03540101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "00000020c3a79791f5adf3b27c3ed419cedf3af70ff5f9574e1900f702695c5c2183f6725a0d449547208254dda242149c38fe966626318c464bad47cd6ecb144fb34d3d9f02915c05000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff03550101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "000000209bf71be8ee00d0d0174fd235311218aa01e7c98695e8c5d251ecc1c8508c5837761ac152d9b87fdfb3a0d737ee00bfb4de1600ffbf938ebe28856cbf3c2904d29f02915c06000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff03560101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0000002020885e749ad8d7d321018c574fdd8753156f7ff8c149ceb435ff1796c8a6c38e45f3e118464f6f7096ece24ad8fa50b28d218f6406355de6d44ebe6affea7fe79f02915c07000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff03570101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "00000020a335985a3d5ce8683b52c69fd7f46a0b5b5e20ba8a2a54efbdc911f9d008c19b89dd0de88714b636d3a999b053b3962107e772f5abf780b26bba864433193627a002915c08000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff03580101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "000000200e882a5be6ff1c9024e7242729c29be3e008224cfa333bef5d4b22a8331dd31a0890700c6d4febe47b09ea2d56f9d9fdd1c05eec55981050bbed2771229d7934a002915c09000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff03590101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0000002048601f806b6cc75bc30cca0fed2e8a8d0613be1453ad2b858e465b69d2870acfd78c23b5f05532d97abfe5b05f95e0532d29fd61465163abef8b7fc70edf3d27a002915c0a000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff035a0101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "00000020c25bd976932306bd47cf5aa9edd6f19f7aed47592b7c49dd5524ed964cbee2f01439b896595511873c8a331e96286bfdcb608e7c160eedd6ab31b0ebe509dc22a002915c0b000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff035b0101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0000002004491f077795737190d54ed5ad2341a492ebf04df8aeb74e56ae56d0a56813dd1f87aa7052bf0f5a2699f786e892b06e8eb2f89236730073e750fdcf6deee71ba002915c0c000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff035c0101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "00000020d3f29618fc9806ee5d8473dbbaaf8398008f87ae2445d437bd9fe40a4cbec9f2befce0671847dfa1b5bc049a4c0159beccaba01569b75580f4b4b28d263a44bca002915c0d000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff035d0101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "00000020b6a354afa16d4ae90ada4f70f50ecfcc0c06b8dfa37a584695b249455cf46387605905e89ac4002b7dbcb09e511301997ff51aa06b59a9846ce870f8f427c38ba102915c0e000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff035e0101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "000000205ed2ce4d910512f559fb965517ade47e7149ac6a3d44a7700094059ae2caf812eabf15ca3148be9abf84a185654db27ade6db493783a1ea7b5c437bde0ae9852a102915c0f000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff035f0101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "000000201a3290bec4e96f217171e7616268eacb68fba4f6d60959104577ed78a790b6ed84d1f8679adc8e8b916cb947eea44e3e0bf4cdcf8c6e059874804a5a207a263da102915c10000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff03600101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "00000020b97dfce3da99cfc316f19d74383b69b1713ed40db1989e12f259ea8453c8544d379cae64af5edcabe11efc3054f9c5e99130250e7de9812a4814ed9ce7e6014ea102915c11000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401110101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "00000020b35833a22c2301e077d50a2507f34abc3f83e050dd4cc9a4e0bc18ccf5be4e620df4d653d36ba76167776dd55903adb8b2430dc19d1652c039fed68f7da3da0aa102915c12000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401120101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "000000208538dfabd8ff15f615f5ecbaa58dc6ffdaec77943868cab48e2b8acc36aaef11359aae7a7589350bbb72b16365e17d0d7dcbf848c70e8230dc70b932e7de42aea102915c13000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401130101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0000002004e1003785b07cc81bd7353695d196e8fa34d78efae2fbb19533cdca4320ee1a3fa237b85e51b16dd81874f3394c995451e098ff5e3e211c5052a9e16e198ee7a202915c14000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401140101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "00000020557cae9628f3b1a955433cc67769148e20c8b9777bf52d883e4ae5530fcabdee52ab5572ce576f3451ca4b60c9c10a094834c60a2823d2de03a6cad4c44b885fa202915c15000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401150101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "000000204d5efed284a7a67c1d6f320354a0650835e685aacb941e26791815c9df97bc740f443d7d7d268cb607cd37dbb30b35672262ad66cfaf5fc21dc1c8b240e33f07a202915c16000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401160101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "000000200cfc15087e80529c594e86a501de87d00f28a74dc23faf6295ecd22f5ae5c7d2a6d03776971ca1afcaa66fa0de41a911e8ba9a72cee3835e00e1f3860e16266ea202915c17000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401170101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "00000020f5ed5ef845d13820d2464c18d1d93f0e51ab094e04657135ac1f98fcbc43b76be7f110956454dcbb4a42b7a83b8263bf297235f60c00aa53bea10ed2c96c73bfa202915c18000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401180101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0000002061ee6e5acab9424762eb7edf32b0ec2ea0705f531c4f03373f92cd598919e41fa6e392492d579d4c24c7915fbc498958703903256480ffe5e0975e47e8a1b8f4a202915c19000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401190101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "000000209a22339b1c5b2dc250047f26879e316d9025fd81171cb847db773967d2105c5e94465261899c167cba7dc3019f312b4f80cba8eb9932641e9c53a4e78544007fa302915c1a000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04011a0101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "000000209acbe67815dad2027ea4e14b19824aeb7265fd83db1e57ac6e4820e460821ee07c384faf78aa1526a10e5809c83274179953e63abf05008e2bb8560ee677f9c4a302915c1b000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04011b0101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "00000020af2bc3985ba146499749188ba5d26312acaae084cb579e5232b108ff71275dd2ed5ad4fe2514fbf2917a23d41fbfe774e2a9d7152a188e7692e295da033a7727a302915c1c000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04011c0101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0000002068e626f30b75d16de01958838b484047c3fb8caae59aacb6590f6779b84ed7aed00b883ddf847162f951ee4442f0d0ede85a4a8e7c13037e8773eb4de5c1e6f3a302915c1d000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04011d0101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0000002058425813e850db6ab721a04a269613ee9b5780aac1ec8f20a2be1e00ff6db4f3ca7c2cde5fdf68acc73d50a4cbfad45b71daf5f02e054b16a057402082c6892da302915c1e000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04011e0101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "00000020673646cffcc76bf8f1d0dbc7b43c29b2f33e87b61632c405f24f556274fd3e7c2cc8105e2b5dc9a575bdd878e843499f7664146d1019b19b7258ed6f8b127d3fa302915c1f000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04011f0101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "00000020b353f378277b8c1e48a0621e9c5d234dac56d85acbb60f80dbc4bea0459456640107ac3c8e6c1d9fedd4844ab01ee00ac7cec321d9d8b5c7c140e0bbedd9839da402915c20000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401200101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0000002029abdbdf968d4f7a725a031992a0d9614db55699faaa347382a72b9180117bea9418727081f4ab7f17a2519483d8e615aa15da91e82bcde9a081c57a8ced961da402915c21000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401210101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0000002020a61c612c5cb50b5b9ad50d0c5bf723b49f29d361b680581435d002e5820d8f97a58f49c361c39a33315ee38efe4ddb646a21b6e522db2bb18b114231b9ab27a402915c22000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401220101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "00000020e6b34e1c1fbe333a7f5f82a168b9b38384cf41e9c673b02ff89e653e3a6ccdc96fcbc565d8310408ab2dbd22eb6f6d8a012e542c1222841569c6d70402089ab6a402915c23000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401230101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0000002042077bd67abcb1e6af6b32a9d1e60cd5c3449262402736c9e411168673c9899fa5a90a78001a244b0ef74b48b1cbae8c968f8c1fe519f2e79fc0862ffd3946c6a402915c24000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401240101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "000000202082b5936f7e263bcb66bf6f979ceed58dcbcfb07934296d309e0df9b6f70a36740fe7b763bf54ca7a63db4d86b69a7c0ec88d1d84449cd7d170463f1f378ecfa402915c25000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401250101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0000002033233b2deeb5cd94e1e7f1eaf7f5de63b820b246ff0b87e972064c687623cdc3337a690872596f95b9a802d8e95ac458a1d6d4f08619843e4e5b06f41042a3b4a502915c26000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401260101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0000002056cba074717277087a5e619090958480ed93bc6ce0a6c0eb484f73b7c1d68e2b9a0bd90abc128dcfc9d5ab572d7105cfbc62c832c66a1ffd6d52c0b5cb6e10a9a502915c27000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401270101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "000000209ed68bc59e304ea206636d73edbf684ba03e2a3559c083d76f1a6a6d52328d934901475b63d2044eeb355755025e3998f783f8ef1e69fe955574109e281748bba502915c28000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401280101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0000002079eef5d922ab32e29188cee5812caf123b7312cc29ceeda08bf3be03faa05e260d9a6a9189337f8f04594ecab3108b342b80cf65dd19758b0f9d7b1b4826e198a502915c29000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401290101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0000002057d9ced1a0c178b74f3a738ab05aef15fe220c1c8387ee7c22400596f14538091b100a082657519f001e3fd7d841e327a7d35b2fe07cdd9578d705d2cd6efce2a502915c2a000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04012a0101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "000000204ecd5fedec7199028896e8c11c7ff74ecbf0092788d41fc36d8b7021f6b4559a0d1d2ac9edd2891e290b985f66bb5afd171d8f9a67284197c4bc4b9c49663e9ca502915c2b000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04012b0101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "000000204a8a29a39d14b95cc622b74b0c4982eea79d5f933ba3e891ded0c57aa8df1ac64dd958fb82ba5181e6e65a6175520f631df3118635b392dca8e5ceaceb6c1bb7a602915c2c000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04012c0101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0000002019aad581d7547a50e476cec6daef4f233e4c7c516af061af39ff526ba833f41881bdfe7fcd5b5ba4fbddb0c6098633826cb8054e740a71f78e25a2895f644922a602915c2d000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04012d0101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "00000020410e9211e913dd29a15d27e7c9a048fb5542530643c4bb51317165f8af1e6ec2f88c5bc59488afc37fea44716bfce0facb028fd51da1fec2e3c0eed97f438b73a602915c2e000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04012e0101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "00000020e652a8511070cf371a378399721432c410bc5747dcd382c6100e8906395d29d46225086fcfa06e90726d5e2fd09510ffcc18f5aafac81aa87ebbe4e4de846c38a602915c2f000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04012f0101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "000000209591495f63b0a7d589aba645a31dad9e06e204a286a0501077dd01b488dd941804d57974f4e92cf239391ea2b5df2342f7ebfe1770953b86d7ff12cdadb022ada602915c30000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401300101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "00000020a53b5f436f04f49430e824a58fc0cba5471b363f71b2db3ff739f9c0f282f461ab213c24d22ecc24f2ba32f2d2ee65507c1a767c4894f90b02cda274e1c3f92ea602915c31000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401310101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0000002098d051b1c85ac1e7b09a7aeca52349c90fa0350165381ccee49653ce57dafeb7af4b988a0d56987e3d3919c7048d960512c98d092b59c5b1a46324601b0f6cb5a702915c32000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401320101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "00000020c93a60a62d96f816416fc50281a65bb19fd77e0e7d938640cdc8ba88c97ccab822a8ea468800c0429fe59a2abd265fc5f4d14f694eab3dad9318f9691cefc73ea702915c33000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401330101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "000000206ccf3364f43afdc2fcd4364227e9a31eda0d8f536c2532b68c1e005d3993ca4f42007ac74ce6e1b5eda1810292114e91b7c64888317dec32654138db7f2031c0a702915c34000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401340101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "00000020ffac52e3cbf8c584aab046cb981e93dc3d21477816f828d84f9047ff78396a31c8a63e1aae4948b4a2c7fab715d0a357b21751c6b876d43bfe749d8e15d32254a702915c35000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401350101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "00000020744cac41a4816d17f1cd5142e3890c22211db87a142fe18603f8b8a5428b579816cdb1fb2b5ef79bf30eb48d60b599e668f9f64fe2082a965e1cdf7bf7549f46a702915c36000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401360101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "000000208fd48bfe7c58fe148fa003a96ddfa17817e823797878e796fb67b1651fc7b8e026c9a0fb1449649714bba349932a0f62d3a5e28d2b9c585ee2c9be1a847e5e01a702915c37000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401370101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "000000200233a559c1c4b437c6950028e28408db80f00e3ab810bcac86f024dce494e94898538afbd970deb45714bc6209e41aa3188094fef1719961b230aca17b223919a802915c38000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401380101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0000002003bb4a953fdf6ed0f0018eb0d78a040359af895c7bba7febd3d56c638837a0bf1f06a3a0fc5290742dbf231626f8bb04e79d57ae97fadf9f85ee0a4c6013254ba802915c39000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401390101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "00000020f3991bef93be65aca3076688da86e2611bb82c8a19925cd7d4c291a6ef4e478d680d89caeb42810bd01144d420dcfb1e10eab9c79e7e62691b86044dcb5fbaaca802915c3a000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04013a0101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "00000020616cc92bb11d26469f24f08c6bdb45a321a3f1a7e91ec3fafbc6642709a32e94530562182d9519688604a94909dead0b24363e6f3ff2016d878647e214b6e4daa802915c3b000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04013b0101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0000002073a0029d38a696d6360edbbc2195c0bd82c08cf0ddf576945c042f50fc7f4c1b326000a7779a21777df7b782ae72e3ef374955fede538eb891579707b0473362a802915c3c000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04013c0101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "000000200b231755e8aab5f80aee431ebbfbf20418a9f27f681ef859b7b682d3141b5bbfdacf3ac67971729abcba74745282356f0c6a8c577be22b1f7b3000926cc9ed78a802915c3d000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04013d0101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "000000201862a13752e1bc14c274188f959f39d2e9d9627331c531de71240da316d7897c98a5c027599770b28191c45993f942a85345154e66a3acfd7842e13ad02a812ba902915c3e000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04013e0101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "00000020433af23a58a9fef69e9e574404e5cd95c41a96fda02a30e7bf900d2225364e7f5b0d76d8e9ce8b01558b9d7b4179462dcc0f5faf556023366c7ad2f3e2005acea902915c3f000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04013f0101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0000002042a73527ff3a57a9d3172df1b898fa00b2f293d9faaca9b45996f1638d6d1b4025fe5509ce08a87d025fb70aaa73f58d261576e2958ed46f584a30e1b1ff0746a902915c40000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401400101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0000002087ec8da14dff459682819b4b1a9f842ca6912b803dcbe55a56ec95197836be700666bb97900bb7e14aba8a2ba760ceb7436864a23d82825feb4a81ffc98be597a902915c41000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401410101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "00000020961cee505188163c3dfcc6920275cf7225718a0bac22325eeee3cee0e0a2e57792b3a0b7bc108156d5953f0ad18e1f7b6fb38950f8a62aa603640ca7839395b6a902915c42000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401420101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "00000020ef59432e9bb1652ffc611ed8d932ccb23e551c4144b81055521e8d4f1b236b05545c185bfc1a98ee0bc3dbfe56a2e703265a8f280671f6e51ca9023cd4749aa1a902915c43000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401430101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "000000204bda7ce6d35ec869a2011ed284aae2328dba1b62780f919884117d8fd4860f253c3d09c3698cf581a6279749a03f42c201e5a0dea34520f5c67b9f716161fa53aa02915c44000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401440101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "00000020fe0b14c8da908a984829247e71e7cb3f3cb3ca7070fa0d47a9337777020bad67605a9b63d3effba463d55840f91c998668b80ead90468fdb7a9607897f66001aaa02915c45000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401450101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "00000020e35b4b7d25fa37415ea3fdab0d6806368567013187bc95a3f994a99b1f281b6c8319f2e5370af4d0c852879ff1667f9562d8f7644f9812609eea94c9c8448772aa02915c46000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401460101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "000000208aadf8c16346343e1414b4a30b330487ef62199a30f9b500a701fd887826b090e308cd24a23b84de57f941676b93a96b1f229baa6fb7ad7220bec488476add21aa02915c47000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401470101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "000000207d769f107729e118467be3154c02a4f05d00b1d21ce21057895ab7fe0e4cf0a73988a2cd7f83e9d3b5b07878f0cd1bdecf9c31536006499f6ee025ae616222caaa02915c48000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401480101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "000000209ca259ceb09be93316a90d5c9a4a09103a4abddf94ba9d073e1e503f90a461848e340eb1538316adab296685a87bc7c32d0e941edc165503abf6790b86bbc7ceaa02915c49000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401490101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "000000205388999d8cb247c12fdefed29b9f6a85a985dfd83ad4aeb8ee98bfbb8edccc530a6150a31b849fc4fc571b596a70090261fb60049c1d9372b9b8ba6f2ad4dc82ab02915c4a000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04014a0101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "00000020f53baf0d1812c6dea4b8e14acb2d6977a70c207efd48181fd6732adf261397f1621e238a5c2fe59e192d4ba1e1394b94ed44550714d5b57099b0d6b825622491ab02915c4b000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04014b0101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "000000202cb270047b47c45be237db41d825ffeb3f4766297d0184033eb45824972dae5edd8c2f41d3a81b15bce841706b66b45f336899f0130b94fc7637492ae285fd60ab02915c4c000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04014c0101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "00000020a4ef606938a9a92f8f2a170f34616f2ee4979c13c42a815520d1aa36871f83d37d607bfab22800335b0b6d971be1ec03a01254f5a4cc75a80ba141c2c0524906ab02915c4d000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04014d0101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "00000020ca42b10948f1e218b27e356f76011dfefcbc8f5dd1a2d0419686dab1ceb0e577b7b7c2f767c21ab16be853fa6779146c4c78eabac5f8c39d29b3e43751726446ab02915c4e000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04014e0101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "00000020cc04f63390616e2215a0a0945c755f33f4d605e789976243bb35844e22479d290158cc9adff2643fa9338259e1b4362f9290735416fca75555b727203e718bfbab02915c4f000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04014f0101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "000000207d4215ab4c13e5b4414e49973f121ff68da44b17292350a5bff786c4d3d2b584916f1ff722251a939aa55051ca9d158408995e29274207a330776a101c2fa0b3ac02915c50000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401500101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "00000020c28211e18b41d4b8aec31df60a3135cfdcc99b11114f2eb21314e3a48938a02a71aad39e514182e10b218d23696a617b047dd1b243f5e1680b6520c8cf864beeac02915c51000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401510101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "000000209f640bdbb580a2557d7c7782973c0d5ff0a8a023695bc6824cffc76d83b88c3b8c2ffc8a0e0837ecf2a0c33501cbe8cd510b108154885cd8e76d584725fefa03ac02915c52000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401520101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "000000201e580880a75f714bc90276b98b21b97e2fcad8c0ff61fe5e378a9ff45e4e3b461d24b941da116fb12b759936b6b3238fa8fdd66e40d02cf302eb854d0847b7e7ac02915c53000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401530101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "000000203d94aead98f94567c41c5da5bfbe3620d40b8ea5425ae2b5683bc16a2e6782d39190525fa28832ff1d0569c0719cd2c04680f7ac2010c8c3268aad2ad3488e29ac02915c54000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401540101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0000002071df1cc3f5d3fff8e1a282a5b9455061597d8aac95d56e093755aa8f5f1b1db12ea8616398263e41ab1049959696413c27e3080f5e388c19da31ad76ce89e806ac02915c55000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401550101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "000000201a61d73ca34037d4f08920bfcc6bafb57149c547c553a0a85ca3166db2ef243461288d38731fc54dabd21700003aab86e87e849a82f614345f8da7dca8edd130ad02915c56000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401560101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "000000209c49486d51402018342befe3330b536ea1eac14b0f00ea131722bfd09370cefb59c5aed0422bc42c50e4138d33a6bcd659317bb3661aa9ce6657a6333ba18a8fad02915c57000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401570101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "00000020d56e332f67acfc1128fa93f7ffbbe554cbdeef8cceb89a119156180a5e8b81e244665c973eddd5f81bf6cb6144d7e84381c6dfb783beb11130cb1cf79db90e82ad02915c58000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401580101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "000000208e903d31e5e278902d535e4d2cc418ee9ea63fbf36f127fdb642d6469c6aa100faf085b53859f32dfc94841f537526fca2479fe1fb943e6ab91f5c7a78f51368ad02915c59000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401590101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "00000020ebcb3c5c9160cbecdc0734f55d4713b0fac6f7003b297988e4dad8a57eef4b92d203d5c2b6b3335fc9604c6ce95f6bfac6977467a150f3f495b4b300540e6df6ad02915c5a000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04015a0101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0000002042c9c1a24d03b3db35ddc5573f5e23283637fcdf73b8c21be02d99d9a3ff8240924631207fc34526bbcda94cf8235882dd3a6bab5ea56743f9fbeaa38a2e5254ad02915c5b000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04015b0101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0000002038094efd387b97cbdf9b3d8bf21cd0dda954c23cb056e38f4ecbd96855fbbcfc277ddca3e52190b7883959cfcd201b01163c3e627624f0fbd04490a970b0df63ae02915c5c000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04015c0101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "000000204879e2df8301543265bf765fc51a894272b3e2d7e50454b4100dc00a953eab4082543e26381b87a430c7a71c0f38f192189e65f6db79267e3e0d094029ff6270ae02915c5d000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04015d0101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0000002019a0344a4ef124f293d457b37bf4ce2d6ae7fdcaa46e375042913e254aa3ea2ffcb78ec6186bd861a02afdf2f4322e29c3d7b192c4777ee6745c7a2e36c4d073ae02915c5e000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04015e0101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "00000020986f9867d5a27cb34a0764bc2714d6fcccbcfaa125a926a82e49bd78fd0e0e7cfd3bd03f08c915434545283592a3dd0061cc7596a5c82f1bf88ddb675c955c16ae02915c5f000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff04015f0101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "0000002075a4ecb68d3f34664bb7b238394e06d750078641a51ab11c55bfa9e073b1179dfc17f4166c17371ebf3dee07a1f3b9e0fe382446729eef1c59e8cda0091b4b50ae02915c60000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401600101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "00000020b5100cbaebfdf50984ba010451e9245cd020e1793b38cb4f0faf82f6e7c6cacdfc29ba9d90e2f7332aca7a5554b8fa845e057408d30c6e68c90e54c9e2f30a9dae02915c61000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401610101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "000000202672892ed7f338cf4b044bb1b632c623ffe2e222eb300f3bfad9583b3592caa0bf8afbbc47216c15ac18157df4361225b155adc6e786d194eeff74a398911e9eaf02915c62000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401620101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "000000207cdebf929df5e502e54df09bad1c4f3748d2eb73ac218ffef313ff867bd225fac9bc88211e589c3cb7e96448ef269cffa56e93dbd41fe785daa84d9ce1f1acb0af02915c63000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401630101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "00000020f0ffd9ccf295979531ba943326a85d76582197ecca9f4bddd8bad5f6b53db221a944fae8912c4b71f0a626ae993222543b39ba0437bac884105961a607e61de9af02915c64000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401640101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "00000020d923740c8fc935794c02e27fa8aea90973587b9ee73b2832563c4c8e8d255531510045cfdad4bcf41bc5ce5a6fd90bfd969cf98aba8590e9d037e888348ebe87af02915c65000000015100010200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401650101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a05f20000232102d108f32b4d80982dd6dcb624444316036b2113b9370fed95dcb1829064f3978fac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed94f15ed3a62165e4a0b99699cc28b48e19cb5bc1b1f47155db62d63f1e047d45000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000",
+    "000000205166142c3f7669f960459763e26d53e81c8af79841207e0a22adfda4192dd3ec6294db3749a270d1896251e3a104e85c7575c4d218a8fb1b555ac345d340782daf02915c66000000015100020200000001010000000000000000000000000000000000000000000000000000000000000000ffffffff0401660101ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000012a06099800232102cdd50a6eefb5fed99acbdf9029e6d362f599f03e69b134083500cdeba7ff4e36ac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000266a24aa21a9ed9b1d0d73201f13ebd5461521c6ecd7bee90953e5041e9ebc697682543b04997d000000000000012000000000000000000000000000000000000000000000000000000000000000000000000000020000000001bbd98a024d2d70aad2ef8b3e1a78ef1ff6599b290b201ef8a2126b9f9fb0e77c000000004847304402202412b64ad73ddb8a3cccf96a9a539b2db4b93c443bb816b28628d89275380c3b022046f1f0b09452845813b5c587e9ac309b7915b5423276b18cdc792874c342b19b01feffffff0301ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe00100000000ee6b28000017a91462c226e5e017a9a8086959dc921f070714f26d438701ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000003b9ab2680017a914f1611c75a7a9f25eb9c0b565c4f06711fec7534d8701ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe0010000000000001798000065000000",
+    "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"
   ],
-  "mocktime": 1548260369,
+  "mocktime": 1553007261,
   "stats": [
     {
       "avgfee": 0,
       "avgfeerate": 0,
       "avgtxsize": 0,
-      "blockhash": "d575627bdb07f12391d448dd333d3d2f7a9dd321164dcdd0469736743d655ea9",
+      "blockhash": "ecd32d19a4fdad220a7e204198f78a1ce8536de263974560f969763f2c146651",
       "feerate_percentiles": [
         0,
         0,
@@ -125,7 +125,7 @@
       "maxfeerate": 0,
       "maxtxsize": 0,
       "medianfee": 0,
-      "mediantime": 1548260386,
+      "mediantime": 1553007278,
       "mediantxsize": 0,
       "minfee": 0,
       "minfeerate": 0,
@@ -135,20 +135,20 @@
       "swtotal_size": 0,
       "swtotal_weight": 0,
       "swtxs": 0,
-      "time": 1548260387,
+      "time": 1553007279,
       "total_out": 0,
       "total_size": 0,
       "total_weight": 0,
       "totalfee": 0,
       "txs": 1,
       "utxo_increase": 2,
-      "utxo_size_inc": 173
+      "utxo_size_inc": 0
     },
     {
-      "avgfee": 3760,
+      "avgfee": 6040,
       "avgfeerate": 20,
-      "avgtxsize": 188,
-      "blockhash": "a065ac454efbc52d91547f6e3d4f0c7895bfa9390f1917943559879c1c79184d",
+      "avgtxsize": 302,
+      "blockhash": "dfe7ce1836032a5c0e751e98ee2709299711e57c29c60f10276cf5eb9fc08929",
       "feerate_percentiles": [
         20,
         20,
@@ -158,34 +158,34 @@
       ],
       "height": 102,
       "ins": 1,
-      "maxfee": 3760,
+      "maxfee": 6040,
       "maxfeerate": 20,
-      "maxtxsize": 188,
-      "medianfee": 3760,
-      "mediantime": 1548260386,
-      "mediantxsize": 188,
-      "minfee": 3760,
+      "maxtxsize": 302,
+      "medianfee": 6040,
+      "mediantime": 1553007278,
+      "mediantxsize": 302,
+      "minfee": 6040,
       "minfeerate": 20,
-      "mintxsize": 188,
-      "outs": 4,
+      "mintxsize": 302,
+      "outs": 5,
       "subsidy": 5000000000,
       "swtotal_size": 0,
       "swtotal_weight": 0,
       "swtxs": 0,
-      "time": 1548260387,
-      "total_out": 4999996240,
-      "total_size": 188,
-      "total_weight": 752,
-      "totalfee": 3760,
+      "time": 1553007279,
+      "total_out": 5000000000,
+      "total_size": 302,
+      "total_weight": 1208,
+      "totalfee": 6040,
       "txs": 2,
-      "utxo_increase": 3,
-      "utxo_size_inc": 234
+      "utxo_increase": 4,
+      "utxo_size_inc": -120
     },
     {
-      "avgfee": 18960,
-      "avgfeerate": 109,
-      "avgtxsize": 227,
-      "blockhash": "3a131d3eaa51d02e12f2488cdf9df77074e046515822d5c5a247c7cbb18ed44d",
+      "avgfee": 32093,
+      "avgfeerate": 111,
+      "avgtxsize": 346,
+      "blockhash": "210cb143bfbc8a0f41e497a75a40c220b45b5134dc8e37ef47cf01ab3c6f5cfa",
       "feerate_percentiles": [
         20,
         20,
@@ -195,28 +195,28 @@
       ],
       "height": 103,
       "ins": 3,
-      "maxfee": 49800,
+      "maxfee": 84600,
       "maxfeerate": 300,
-      "maxtxsize": 247,
-      "medianfee": 3760,
-      "mediantime": 1548260387,
-      "mediantxsize": 247,
-      "minfee": 3320,
+      "maxtxsize": 369,
+      "medianfee": 6040,
+      "mediantime": 1553007279,
+      "mediantxsize": 369,
+      "minfee": 5640,
       "minfeerate": 20,
-      "mintxsize": 188,
-      "outs": 8,
+      "mintxsize": 302,
+      "outs": 11,
       "subsidy": 5000000000,
-      "swtotal_size": 494,
-      "swtotal_weight": 1328,
+      "swtotal_size": 738,
+      "swtotal_weight": 2256,
       "swtxs": 2,
-      "time": 1548260387,
-      "total_out": 9999939360,
-      "total_size": 682,
-      "total_weight": 2080,
-      "totalfee": 56880,
+      "time": 1553007279,
+      "total_out": 9999993960,
+      "total_size": 1040,
+      "total_weight": 3464,
+      "totalfee": 96280,
       "txs": 4,
-      "utxo_increase": 5,
-      "utxo_size_inc": 380
+      "utxo_increase": 8,
+      "utxo_size_inc": -336
     }
   ]
 }
\ No newline at end of file
diff --git a/test/functional/feature_assetsdir.py b/test/functional/feature_assetsdir.py
new file mode 100755
index 0000000000000..4510914889906
--- /dev/null
+++ b/test/functional/feature_assetsdir.py
@@ -0,0 +1,67 @@
+#!/usr/bin/env python3
+# Copyright (c) 2014-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.
+
+#
+# Test use of assetdir to locally label assets.
+# Test listissuances returns a list of all issuances or specific issuances based on asset hex or asset label.
+#
+
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import assert_equal, assert_greater_than
+
+class AssetdirTests(BitcoinTestFramework):
+    """
+    Test use of assetdir to specify asset labels.
+    Test listissuances returns a list of all issuances or specific issuances based on asset hex or asset label.
+    """
+
+    def set_test_params(self):
+        self.setup_clean_chain = True
+        self.num_nodes = 1
+        [["-initialfreecoins=2100000000000000", "-anyonecanspendaremine=1", "-con_connect_coinbase=1", "-con_blocksubsidy=0"]]
+
+    def setup_network(self, split=False):
+        self.setup_nodes()
+
+    def run_test(self):
+        self.nodes[0].generate(101)
+
+        #Issue two assets that we will later label using the assetdir parameter
+        issuance1 = self.nodes[0].issueasset(100, 1, False)
+        asset1hex = issuance1["asset"]
+
+        issuance2 = self.nodes[0].issueasset(100, 1, False)
+        asset2hex = issuance2["asset"]
+
+        #Stop and restart the nodes, providing the assetdir parameter to locally label the assets
+        self.stop_nodes()
+        self.start_nodes([["-assetdir=" + asset1hex + ":asset1", "-assetdir=" + asset2hex + ":asset2"]])
+
+        #Check that listissuances return all issuances
+        issuances = self.nodes[0].listissuances()
+        assert_equal(len(issuances), 2)
+
+        #Check all asset labels have been set: 'asset1', 'asset2'
+        #We can not be sure they will always be returned in the same order so will loop each one
+        label = ""
+        for issue in issuances:
+            label += issue["assetlabel"]
+
+        assert_greater_than(label.find("asset1"), -1)
+        assert_greater_than(label.find("asset2"), -1)
+
+        #Check we can get a list of isuances for a given label
+        issuances = self.nodes[0].listissuances("asset1")
+        assert_equal(len(issuances), 1)
+        assert_equal(issuances[0]["assetlabel"], "asset1")
+
+        #Check we can get a list of issuances for a given hex
+        issuances = self.nodes[0].listissuances(asset2hex)
+        assert_equal(len(issuances), 1)
+        assert_equal(issuances[0]["assetlabel"], "asset2")
+
+if __name__ == '__main__':
+    AssetdirTests().main()
+
diff --git a/test/functional/feature_bip68_sequence.py b/test/functional/feature_bip68_sequence.py
index b1f3ea294ac25..e70c38a017c38 100755
--- a/test/functional/feature_bip68_sequence.py
+++ b/test/functional/feature_bip68_sequence.py
@@ -78,7 +78,7 @@ def test_disable_flag(self):
         sequence_value = SEQUENCE_LOCKTIME_DISABLE_FLAG | 1
         tx1.vin = [CTxIn(COutPoint(int(utxo["txid"], 16), utxo["vout"]), nSequence=sequence_value)]
         tx1.vout = [CTxOut(value, CScript([b'a']))]
-
+        tx1.vout.append(CTxOut(int(utxo["amount"]*COIN) - value)) # fee
         tx1_signed = self.nodes[0].signrawtransactionwithwallet(ToHex(tx1))["hex"]
         tx1_id = self.nodes[0].sendrawtransaction(tx1_signed)
         tx1_id = int(tx1_id, 16)
@@ -90,6 +90,7 @@ def test_disable_flag(self):
         sequence_value = sequence_value & 0x7fffffff
         tx2.vin = [CTxIn(COutPoint(tx1_id, 0), nSequence=sequence_value)]
         tx2.vout = [CTxOut(int(value - self.relayfee * COIN), CScript([b'a' * 35]))]
+        tx2.vout.append(CTxOut(int(self.relayfee*COIN)))
         tx2.rehash()
 
         assert_raises_rpc_error(-26, NOT_FINAL_ERROR, self.nodes[0].sendrawtransaction, ToHex(tx2))
@@ -183,8 +184,9 @@ def test_sequence_lock_confirmed_inputs(self):
                 tx.vin.append(CTxIn(COutPoint(int(utxos[j]["txid"], 16), utxos[j]["vout"]), nSequence=sequence_value))
                 value += utxos[j]["amount"]*COIN
             # Overestimate the size of the tx - signatures should be less than 120 bytes, and leave 50 for the output
-            tx_size = len(ToHex(tx))//2 + 120*num_inputs + 50
+            tx_size = len(ToHex(tx))//2 + 120*num_inputs + 150 # ELEMENTS: overestimate more for output witnesses
             tx.vout.append(CTxOut(int(value-self.relayfee*tx_size*COIN/1000), CScript([b'a'])))
+            tx.vout.append(CTxOut(int(self.relayfee*tx_size*COIN/1000))) # fee
             rawtx = self.nodes[0].signrawtransactionwithwallet(ToHex(tx))["hex"]
 
             if (using_sequence_locks and not should_pass):
@@ -213,7 +215,8 @@ def test_sequence_lock_unconfirmed_inputs(self):
         tx2 = CTransaction()
         tx2.nVersion = 2
         tx2.vin = [CTxIn(COutPoint(tx1.sha256, 0), nSequence=0)]
-        tx2.vout = [CTxOut(int(tx1.vout[0].nValue - self.relayfee*COIN), CScript([b'a']))]
+        tx2.vout = [CTxOut(int(tx1.vout[0].nValue.getAmount() - self.relayfee*COIN), CScript([b'a']))]
+        tx2.vout.append(CTxOut(int(self.relayfee*COIN))) # fee
         tx2_raw = self.nodes[0].signrawtransactionwithwallet(ToHex(tx2))["hex"]
         tx2 = FromHex(tx2, tx2_raw)
         tx2.rehash()
@@ -231,7 +234,8 @@ def test_nonzero_locks(orig_tx, node, relayfee, use_height_lock):
             tx = CTransaction()
             tx.nVersion = 2
             tx.vin = [CTxIn(COutPoint(orig_tx.sha256, 0), nSequence=sequence_value)]
-            tx.vout = [CTxOut(int(orig_tx.vout[0].nValue - relayfee * COIN), CScript([b'a' * 35]))]
+            tx.vout = [CTxOut(int(orig_tx.vout[0].nValue.getAmount() - relayfee * COIN), CScript([b'a' * 35]))]
+            tx.vout.append(CTxOut(int(relayfee * COIN))) # fee
             tx.rehash()
 
             if (orig_tx.hash in node.getrawmempool()):
@@ -286,7 +290,7 @@ def test_nonzero_locks(orig_tx, node, relayfee, use_height_lock):
 
         utxos = self.nodes[0].listunspent()
         tx5.vin.append(CTxIn(COutPoint(int(utxos[0]["txid"], 16), utxos[0]["vout"]), nSequence=1))
-        tx5.vout[0].nValue += int(utxos[0]["amount"]*COIN)
+        tx5.vout[0].nValue.setToAmount(tx5.vout[0].nValue.getAmount() + int(utxos[0]["amount"]*COIN))
         raw_tx5 = self.nodes[0].signrawtransactionwithwallet(ToHex(tx5))["hex"]
 
         assert_raises_rpc_error(-26, NOT_FINAL_ERROR, self.nodes[0].sendrawtransaction, raw_tx5)
@@ -344,7 +348,8 @@ def test_bip68_not_consensus(self):
         tx2 = CTransaction()
         tx2.nVersion = 1
         tx2.vin = [CTxIn(COutPoint(tx1.sha256, 0), nSequence=0)]
-        tx2.vout = [CTxOut(int(tx1.vout[0].nValue - self.relayfee*COIN), CScript([b'a']))]
+        tx2.vout = [CTxOut(int(tx1.vout[0].nValue.getAmount() - self.relayfee*COIN), CScript([b'a']))]
+        tx2.vout.append(CTxOut(int(self.relayfee*COIN))) # fee
 
         # sign tx2
         tx2_raw = self.nodes[0].signrawtransactionwithwallet(ToHex(tx2))["hex"]
@@ -359,7 +364,8 @@ def test_bip68_not_consensus(self):
         tx3 = CTransaction()
         tx3.nVersion = 2
         tx3.vin = [CTxIn(COutPoint(tx2.sha256, 0), nSequence=sequence_value)]
-        tx3.vout = [CTxOut(int(tx2.vout[0].nValue - self.relayfee * COIN), CScript([b'a' * 35]))]
+        tx3.vout = [CTxOut(int(tx2.vout[0].nValue.getAmount() - self.relayfee * COIN), CScript([b'a' * 35]))]
+        tx3.vout.append(CTxOut(int(self.relayfee*COIN))) # fee
         tx3.rehash()
 
         assert_raises_rpc_error(-26, NOT_FINAL_ERROR, self.nodes[0].sendrawtransaction, ToHex(tx3))
diff --git a/test/functional/feature_block.py b/test/functional/feature_block.py
index 5cf5bc2d8dd80..57bf1fe742dec 100755
--- a/test/functional/feature_block.py
+++ b/test/functional/feature_block.py
@@ -270,12 +270,12 @@ def run_test(self):
         self.move_tip(15)
         b23 = self.next_block(23, spend=out[6])
         tx = CTransaction()
-        # ELEMENTS: mysterious off-by-one
         #script_length = MAX_BLOCK_BASE_SIZE - len(b23.serialize()) - 69
-        script_length = MAX_BLOCK_BASE_SIZE - len(b23.serialize()) - 70
+        script_length = MAX_BLOCK_BASE_SIZE - len(b23.serialize()) - 149
         script_output = CScript([b'\x00' * script_length])
         tx.vout.append(CTxOut(0, script_output))
         tx.vin.append(CTxIn(COutPoint(b23.vtx[1].sha256, 0)))
+        tx.vout.append(CTxOut(b23.vtx[1].vout[0].nValue.getAmount() - 0)) # fee
         b23 = self.update_block(23, [tx])
         # Make sure the math above worked out to produce a max-sized block
         assert_equal(len(b23.serialize()), MAX_BLOCK_BASE_SIZE)
@@ -285,11 +285,11 @@ def run_test(self):
         self.log.info("Reject a block of size MAX_BLOCK_BASE_SIZE + 1")
         self.move_tip(15)
         b24 = self.next_block(24, spend=out[6])
-        # ELEMENTS: mysterious off-by-one
         #script_length = MAX_BLOCK_BASE_SIZE - len(b24.serialize()) - 69
-        script_length = MAX_BLOCK_BASE_SIZE - len(b24.serialize()) - 70
+        script_length = MAX_BLOCK_BASE_SIZE - len(b24.serialize()) - 149
         script_output = CScript([b'\x00' * (script_length + 1)])
         tx.vout = [CTxOut(0, script_output)]
+        tx.vout.append(CTxOut(b23.vtx[1].vout[0].nValue.getAmount() - 0)) # fee
         b24 = self.update_block(24, [tx])
         assert_equal(len(b24.serialize()), MAX_BLOCK_BASE_SIZE + 1)
         self.sync_blocks([b24], success=False, reject_reason='bad-blk-length', reconnect=True)
@@ -423,10 +423,11 @@ def run_test(self):
         self.move_tip(35)
         b39 = self.next_block(39)
         b39_outputs = 0
-        b39_sigops_per_output = 6
+        # ELEMENTS: increase the number of sigops per output to not hit max block size first
+        b39_sigops_per_output = 11
 
         # Build the redeem script, hash it, use hash to create the p2sh script
-        redeem_script = CScript([self.coinbase_pubkey] + [OP_2DUP, OP_CHECKSIGVERIFY] * 5 + [OP_CHECKSIG])
+        redeem_script = CScript([self.coinbase_pubkey] + [OP_2DUP, OP_CHECKSIGVERIFY] * (b39_sigops_per_output-1) + [OP_CHECKSIG])
         redeem_script_hash = hash160(redeem_script)
         p2sh_script = CScript([OP_HASH160, redeem_script_hash, OP_EQUAL])
 
@@ -434,7 +435,8 @@ def run_test(self):
         # This must be signed because it is spending a coinbase
         spend = out[11]
         tx = self.create_tx(spend, 0, 1, p2sh_script)
-        tx.vout.append(CTxOut(spend.vout[0].nValue - 1, CScript([OP_TRUE])))
+        tx.vout.append(CTxOut(spend.vout[0].nValue.getAmount() - 1, CScript([OP_TRUE])))
+        self.update_fee(tx, spend, 0)
         self.sign_tx(tx, spend)
         tx.rehash()
         b39 = self.update_block(39, [tx])
@@ -446,7 +448,8 @@ def run_test(self):
         total_size = len(b39.serialize())
         while(total_size < MAX_BLOCK_BASE_SIZE):
             tx_new = self.create_tx(tx_last, 1, 1, p2sh_script)
-            tx_new.vout.append(CTxOut(tx_last.vout[1].nValue - 1, CScript([OP_TRUE])))
+            tx_new.vout.append(CTxOut(tx_last.vout[1].nValue.getAmount() - 1, CScript([OP_TRUE])))
+            self.update_fee(tx_new, tx_last, 1)
             tx_new.rehash()
             total_size += len(tx_new.serialize())
             if total_size >= MAX_BLOCK_BASE_SIZE:
@@ -481,6 +484,7 @@ def run_test(self):
             tx.vin.append(CTxIn(lastOutpoint, b''))
             # second input is corresponding P2SH output from b39
             tx.vin.append(CTxIn(COutPoint(b39.vtx[i].sha256, 0), b''))
+            tx.vout.append(CTxOut(b39.vtx[i].vout[0].nValue.getAmount())) # fee
             # Note: must pass the redeem_script (not p2sh_script) to the signature hash function
             (sighash, err) = SignatureHash(redeem_script, tx, 1, SIGHASH_ALL)
             sig = self.coinbase_key.sign(sighash) + bytes(bytearray([SIGHASH_ALL]))
@@ -743,7 +747,7 @@ def run_test(self):
         b59 = self.next_block(59)
         tx = self.create_and_sign_transaction(out[17], 51 * COIN)
         b59 = self.update_block(59, [tx])
-        self.sync_blocks([b59], success=False, reject_reason='bad-txns-in-belowout', reconnect=True)
+        self.sync_blocks([b59], success=False, reject_reason='block-validation-failed', reconnect=True)
 
         # reset to good chain
         self.move_tip(57)
@@ -826,12 +830,12 @@ def run_test(self):
         tx = CTransaction()
 
         # use canonical serialization to calculate size
-        # ELEMENTS: mysterious off-by-one
         #script_length = MAX_BLOCK_BASE_SIZE - len(b64a.normal_serialize()) - 69
-        script_length = MAX_BLOCK_BASE_SIZE - len(b64a.normal_serialize()) - 70
+        script_length = MAX_BLOCK_BASE_SIZE - len(b64a.normal_serialize()) - 149
         script_output = CScript([b'\x00' * script_length])
         tx.vout.append(CTxOut(0, script_output))
         tx.vin.append(CTxIn(COutPoint(b64a.vtx[1].sha256, 0)))
+        tx.vout.append(CTxOut(b64a.vtx[1].vout[0].nValue.getAmount() - 0)) # fee
         b64a = self.update_block("64a", [tx])
         assert_equal(len(b64a.serialize()), MAX_BLOCK_BASE_SIZE + 8)
         self.sync_blocks([b64a], success=False, reject_reason='non-canonical ReadCompactSize(): iostream error')
@@ -860,8 +864,9 @@ def run_test(self):
         self.log.info("Accept a block with a transaction spending an output created in the same block")
         self.move_tip(64)
         b65 = self.next_block(65)
-        tx1 = self.create_and_sign_transaction(out[19], out[19].vout[0].nValue)
-        tx2 = self.create_and_sign_transaction(tx1, 0)
+        tx1 = self.create_and_sign_transaction(out[19], out[19].vout[0].nValue.getAmount())
+        # ELEMENTS: doesn't support 0 value for non-OP_RETURN
+        tx2 = self.create_and_sign_transaction(tx1, 1)
         b65 = self.update_block(65, [tx1, tx2])
         self.sync_blocks([b65], True)
         self.save_spendable_output()
@@ -873,7 +878,7 @@ def run_test(self):
         self.log.info("Reject a block with a transaction spending an output created later in the same block")
         self.move_tip(65)
         b66 = self.next_block(66)
-        tx1 = self.create_and_sign_transaction(out[20], out[20].vout[0].nValue)
+        tx1 = self.create_and_sign_transaction(out[20], out[20].vout[0].nValue.getAmount())
         tx2 = self.create_and_sign_transaction(tx1, 1)
         b66 = self.update_block(66, [tx2, tx1])
         self.sync_blocks([b66], success=False, reject_reason='bad-txns-inputs-missingorspent', reconnect=True)
@@ -887,7 +892,7 @@ def run_test(self):
         self.log.info("Reject a block with a transaction double spending a transaction creted in the same block")
         self.move_tip(65)
         b67 = self.next_block(67)
-        tx1 = self.create_and_sign_transaction(out[20], out[20].vout[0].nValue)
+        tx1 = self.create_and_sign_transaction(out[20], out[20].vout[0].nValue.getAmount())
         tx2 = self.create_and_sign_transaction(tx1, 1)
         tx3 = self.create_and_sign_transaction(tx1, 2)
         b67 = self.update_block(67, [tx1, tx2, tx3])
@@ -908,14 +913,14 @@ def run_test(self):
         self.log.info("Reject a block trying to claim too much subsidy in the coinbase transaction")
         self.move_tip(65)
         b68 = self.next_block(68, additional_coinbase_value=10)
-        tx = self.create_and_sign_transaction(out[20], out[20].vout[0].nValue - 9)
+        tx = self.create_and_sign_transaction(out[20], out[20].vout[0].nValue.getAmount() - 9)
         b68 = self.update_block(68, [tx])
         self.sync_blocks([b68], success=False, reject_reason='bad-cb-amount', reconnect=True)
 
         self.log.info("Accept a block claiming the correct subsidy in the coinbase transaction")
         self.move_tip(65)
         b69 = self.next_block(69, additional_coinbase_value=10)
-        tx = self.create_and_sign_transaction(out[20], out[20].vout[0].nValue - 10)
+        tx = self.create_and_sign_transaction(out[20], out[20].vout[0].nValue.getAmount() - 10)
         self.update_block(69, [tx])
         self.sync_blocks([b69], True)
         self.save_spendable_output()
@@ -1113,9 +1118,9 @@ def run_test(self):
         b83 = self.next_block(83)
         op_codes = [OP_IF, OP_INVALIDOPCODE, OP_ELSE, OP_TRUE, OP_ENDIF]
         script = CScript(op_codes)
-        tx1 = self.create_and_sign_transaction(out[28], out[28].vout[0].nValue, script)
-
-        tx2 = self.create_and_sign_transaction(tx1, 0, CScript([OP_TRUE]))
+        tx1 = self.create_and_sign_transaction(out[28], out[28].vout[0].nValue.getAmount(), script)
+        # ELEMENTS: doesn't support 0 value for non-OP_RETURN
+        tx2 = self.create_and_sign_transaction(tx1, 1, CScript([OP_TRUE]))
         tx2.vin[0].scriptSig = CScript([OP_FALSE])
         tx2.rehash()
 
@@ -1130,20 +1135,27 @@ def run_test(self):
         #
         self.log.info("Test re-orging blocks with OP_RETURN in them")
         b84 = self.next_block(84)
-        tx1 = self.create_tx(out[29], 0, 0, CScript([OP_RETURN]))
-        tx1.vout.append(CTxOut(0, CScript([OP_TRUE])))
-        tx1.vout.append(CTxOut(0, CScript([OP_TRUE])))
-        tx1.vout.append(CTxOut(0, CScript([OP_TRUE])))
-        tx1.vout.append(CTxOut(0, CScript([OP_TRUE])))
+        # ELEMENTS: doesn't support 0 value for non-OP_RETURN
+        tx1 = self.create_tx(out[29], 0, 1, CScript([OP_RETURN]))
+        tx1.vout.append(CTxOut(1, CScript([OP_TRUE])))
+        tx1.vout.append(CTxOut(1, CScript([OP_TRUE])))
+        tx1.vout.append(CTxOut(1, CScript([OP_TRUE])))
+        tx1.vout.append(CTxOut(1, CScript([OP_TRUE])))
+        self.update_fee(tx1, out[29], 0)
         tx1.calc_sha256()
         self.sign_tx(tx1, out[29])
         tx1.rehash()
         tx2 = self.create_tx(tx1, 1, 0, CScript([OP_RETURN]))
         tx2.vout.append(CTxOut(0, CScript([OP_RETURN])))
+        self.update_fee(tx2, tx1, 1)
         tx3 = self.create_tx(tx1, 2, 0, CScript([OP_RETURN]))
-        tx3.vout.append(CTxOut(0, CScript([OP_TRUE])))
-        tx4 = self.create_tx(tx1, 3, 0, CScript([OP_TRUE]))
+        # ELEMENTS: doesn't support 0 value for non-OP_RETURN
+        tx3.vout.append(CTxOut(1, CScript([OP_TRUE])))
+        self.update_fee(tx3, tx1, 2)
+        # ELEMENTS: doesn't support 0 value for non-OP_RETURN
+        tx4 = self.create_tx(tx1, 3, 1, CScript([OP_TRUE]))
         tx4.vout.append(CTxOut(0, CScript([OP_RETURN])))
+        self.update_fee(tx4, tx1, 3)
         tx5 = self.create_tx(tx1, 4, 0, CScript([OP_RETURN]))
 
         b84 = self.update_block(84, [tx1, tx2, tx3, tx4, tx5])
@@ -1168,7 +1180,8 @@ def run_test(self):
 
         # trying to spend the OP_RETURN output is rejected
         b89a = self.next_block("89a", spend=out[32])
-        tx = self.create_tx(tx1, 0, 0, CScript([OP_TRUE]))
+        # ELEMENTS: doesn't support 0 value for non-OP_RETURN
+        tx = self.create_tx(tx1, 0, 1, CScript([OP_TRUE]))
         b89a = self.update_block("89a", [tx])
         self.sync_blocks([b89a], success=False, reject_reason='bad-txns-inputs-missingorspent', reconnect=True)
 
@@ -1181,12 +1194,13 @@ def run_test(self):
         for i in range(89, LARGE_REORG_SIZE + 89):
             b = self.next_block(i, spend)
             tx = CTransaction()
-            # ELEMENTS: mysterious off-by-one
             #script_length = MAX_BLOCK_BASE_SIZE - len(b.serialize()) - 69
-            script_length = MAX_BLOCK_BASE_SIZE - len(b.serialize()) - 70
-            script_output = CScript([b'\x00' * script_length])
+            script_length = MAX_BLOCK_BASE_SIZE - len(b.serialize()) - 149
+            # ELEMENTS: doesn't support 0 value for non-OP_RETURN
+            script_output = CScript([OP_RETURN, b'\x00' * (script_length-1)])
             tx.vout.append(CTxOut(0, script_output))
             tx.vin.append(CTxIn(COutPoint(b.vtx[1].sha256, 0)))
+            self.update_fee(tx, b.vtx[1], 0)
             b = self.update_block(i, [tx])
             assert_equal(len(b.serialize()), MAX_BLOCK_BASE_SIZE)
             blocks.append(b)
@@ -1223,7 +1237,21 @@ def add_transactions_to_block(self, block, tx_list):
 
     # this is a little handier to use than the version in blocktools.py
     def create_tx(self, spend_tx, n, value, script=CScript([OP_TRUE, OP_DROP] * 15 + [OP_TRUE])):
-        return create_tx_with_script(spend_tx, n, amount=value, script_pub_key=script)
+        fee = spend_tx.vout[n].nValue.getAmount() - value
+        return create_tx_with_script(spend_tx, n, amount=value, fee=fee, script_pub_key=script)
+
+    # update the fee output amount and also move it to the end
+    def update_fee(self, tx, prev_tx, prev_n):
+        total_out = 0
+        for i in reversed(range(len(tx.vout))):
+            if tx.vout[i].is_fee():
+                del tx.vout[i]
+            else:
+                total_out += tx.vout[i].nValue.getAmount()
+        fee = prev_tx.vout[prev_n].nValue.getAmount() - total_out
+        if fee > 0:
+            tx.vout.append(CTxOut(fee))
+        tx.calc_sha256()
 
     # sign a transaction, using the key we know about
     # this signs input 0 in tx, which is assumed to be spending output n in spend_tx
@@ -1251,12 +1279,12 @@ def next_block(self, number, spend=None, additional_coinbase_value=0, script=CSc
         # First create the coinbase
         height = self.block_heights[base_block_hash] + 1
         coinbase = create_coinbase(height, self.coinbase_pubkey)
-        coinbase.vout[0].nValue += additional_coinbase_value
+        coinbase.vout[0].nValue.setToAmount(coinbase.vout[0].nValue.getAmount() + additional_coinbase_value)
         coinbase.rehash()
         if spend is None:
             block = create_block(base_block_hash, coinbase, block_time)
         else:
-            coinbase.vout[0].nValue += spend.vout[0].nValue - 1  # all but one satoshi to fees
+            coinbase.vout[0].nValue.setToAmount(coinbase.vout[0].nValue.getAmount() + spend.vout[0].nValue.getAmount() - 1)  # all but one satoshi to fees
             coinbase.rehash()
             block = create_block(base_block_hash, coinbase, block_time)
             tx = self.create_tx(spend, 0, 1, script)  # spend 1 satoshi
diff --git a/test/functional/feature_block_subsidy.py b/test/functional/feature_block_subsidy.py
index 20dcfa0c7a496..852a923da22a1 100755
--- a/test/functional/feature_block_subsidy.py
+++ b/test/functional/feature_block_subsidy.py
@@ -8,7 +8,7 @@
 from decimal import Decimal
 
 from test_framework.blocktools import create_coinbase
-from test_framework.messages import CBlock, CProof
+from test_framework.messages import CBlock, CProof, CTxOutValue
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal
 
@@ -27,7 +27,7 @@ def set_test_params(self):
         self.num_nodes = 2
         self.setup_clean_chain = True
         # 10 satoshi block subsidy at start for one node, none for other
-        self.extra_args = [["-con_blocksubsidy=10"], ["-con_blocksubsidy=0"]]
+        self.extra_args = [["-con_blocksubsidy=10"], ["-con_blocksubsidy=0", "-txindex=1"]]
 
     def run_test(self):
 
@@ -74,24 +74,24 @@ def run_test(self):
         assert_template(self.nodes[0], block, "bad-cb-amount")
 
         # Set to proper value, resubmit
-        block.vtx[0].vout[0].nValue = 10
+        block.vtx[0].vout[0].nValue = CTxOutValue(10)
         block.vtx[0].sha256 = None
         assert_template(self.nodes[0], block, None)
 
         # No subsidy also allowed
-        block.vtx[0].vout[0].nValue = 0
+        block.vtx[0].vout[0].nValue = CTxOutValue(0)
         block.vtx[0].sha256 = None
-        assert_template(self.nodes[0], block, None)
+        #assert_template(self.nodes[0], block, None) # ELEMENTS: 0-value outputs not allowed
 
         # Change previous blockhash to other nodes' genesis block and reward to 1, test again
         block.hashPrevBlock = int(self.nodes[1].getblockhash(self.nodes[1].getblockcount()), 16)
-        block.vtx[0].vout[0].nValue = 1
+        block.vtx[0].vout[0].nValue = CTxOutValue(1)
         block.vtx[0].sha256 = None
         assert_template(self.nodes[1], block, "bad-cb-amount")
 
-        block.vtx[0].vout[0].nValue = 0
+        block.vtx[0].vout[0].nValue = CTxOutValue(0)
         block.vtx[0].sha256 = None
-        assert_template(self.nodes[1], block, None)
+        #assert_template(self.nodes[1], block, None) # ELEMENTS: 0-value outputs not allowed
 
 if __name__ == '__main__':
     BlockSubsidyTest().main()
diff --git a/test/functional/feature_block_v4.py b/test/functional/feature_block_v4.py
index 55bc4b00d3a52..d3db6a136de44 100755
--- a/test/functional/feature_block_v4.py
+++ b/test/functional/feature_block_v4.py
@@ -50,6 +50,7 @@ def run_test(self):
         # Generate 100 blocks so that first coinbase matures
         generated_blocks = self.nodes[0].generate(100)
         spendable_coinbase_txid = self.nodes[0].getblock(generated_blocks[0])['tx'][0]
+        coinbase_value = self.nodes[0].decoderawtransaction(self.nodes[0].gettransaction(spendable_coinbase_txid)["hex"])["vout"][0]["value"]
         tip = generated_blocks[-1]
 
         # Construct a v4 block
@@ -59,7 +60,7 @@ def run_test(self):
 
         # Create a CLTV transaction
         spendtx = create_transaction(self.nodes[0], spendable_coinbase_txid,
-                self.nodeaddress, amount=1.0)
+                self.nodeaddress, amount=1.0, fee=coinbase_value-1)
         spendtx = cltv_validate(self.nodes[0], spendtx, 1)
         spendtx.rehash()
 
diff --git a/test/functional/feature_blocksign.py b/test/functional/feature_blocksign.py
index e337fcd8893d8..260892dfd9904 100755
--- a/test/functional/feature_blocksign.py
+++ b/test/functional/feature_blocksign.py
@@ -95,8 +95,9 @@ def mine_block(self, make_transactions):
 
         # Make a few transactions to make non-empty blocks for compact transmission
         if make_transactions:
+            print(mineridx)
             for i in range(5):
-                miner.sendtoaddress(miner_next.getnewaddress(), int(miner.getbalance()/10), "", "", True)
+                miner.sendtoaddress(miner_next.getnewaddress(), int(miner.getbalance()['bitcoin']/10), "", "", True)
         # miner makes a block
         block = miner.getnewblockhex()
 
diff --git a/test/functional/feature_cltv.py b/test/functional/feature_cltv.py
index f84b08a19938e..632e48a4db436 100755
--- a/test/functional/feature_cltv.py
+++ b/test/functional/feature_cltv.py
@@ -74,8 +74,9 @@ def run_test(self):
 
         self.log.info("Test that an invalid-according-to-CLTV transaction can still appear in a block")
 
+        coinbase_value = self.nodes[0].decoderawtransaction(self.nodes[0].gettransaction(self.coinbase_txids[0])["hex"])["vout"][0]["value"]
         spendtx = create_transaction(self.nodes[0], self.coinbase_txids[0],
-                self.nodeaddress, amount=1.0)
+                self.nodeaddress, amount=1.0, fee=coinbase_value-1)
         cltv_invalidate(spendtx)
         spendtx.rehash()
 
@@ -105,8 +106,9 @@ def run_test(self):
         self.log.info("Test that invalid-according-to-cltv transactions cannot appear in a block")
         block.nVersion = 4
 
+        coinbase_value = self.nodes[0].decoderawtransaction(self.nodes[0].gettransaction(self.coinbase_txids[1])["hex"])["vout"][0]["value"]
         spendtx = create_transaction(self.nodes[0], self.coinbase_txids[1],
-                self.nodeaddress, amount=1.0)
+                self.nodeaddress, amount=1.0, fee=coinbase_value-1)
         cltv_invalidate(spendtx)
         spendtx.rehash()
 
diff --git a/test/functional/feature_confidential_transactions.py b/test/functional/feature_confidential_transactions.py
new file mode 100755
index 0000000000000..1c1d77a101b04
--- /dev/null
+++ b/test/functional/feature_confidential_transactions.py
@@ -0,0 +1,415 @@
+#!/usr/bin/env python3
+# Copyright (c) 2016 The Bitcoin Core developers
+# Distributed under the MIT/X11 software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import connect_nodes_bi, assert_equal
+from test_framework.authproxy import JSONRPCException
+from decimal import Decimal
+
+class CTTest (BitcoinTestFramework):
+
+    def set_test_params(self):
+        self.num_nodes = 3
+        self.setup_clean_chain = True
+        args = ["-blindedaddresses=1", "-initialfreecoins=2100000000000000", "-con_blocksubsidy=0", "-con_connect_coinbase=1"]
+        self.extra_args = [args] * self.num_nodes
+        self.extra_args[0].append("-anyonecanspendaremine=1") # first node gets the coins
+
+    def setup_network(self, split=False):
+        self.setup_nodes()
+        connect_nodes_bi(self.nodes, 0, 1)
+        connect_nodes_bi(self.nodes, 1, 2)
+        connect_nodes_bi(self.nodes, 0, 2)
+        self.is_network_split = False
+        self.sync_all()
+
+    def run_test(self):
+
+        print("General Confidential tests")
+        # Running balances
+        node0 = self.nodes[0].getbalance()["bitcoin"]
+        assert_equal(node0, 21000000) # just making sure initialfreecoins is working
+        node1 = 0
+        node2 = 0
+
+        self.nodes[0].generate(101)
+        txid = self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), node0, "", "", True)
+        self.nodes[0].generate(101)
+        self.sync_all()
+        assert_equal(self.nodes[0].getbalance()["bitcoin"], node0)
+        assert_equal(self.nodes[1].getbalance("*", 1, False, "bitcoin"), node1)
+        assert_equal(self.nodes[2].getbalance("*", 1, False, "bitcoin"), node2)
+
+        # Send 3 BTC from 0 to a new unconfidential address of 2 with
+        # the sendtoaddress call
+        address = self.nodes[2].getnewaddress()
+        unconfidential_address = self.nodes[2].validateaddress(address)["unconfidential"]
+        value0 = 3
+        self.nodes[0].sendtoaddress(unconfidential_address, value0)
+        self.nodes[0].generate(101)
+        self.sync_all()
+
+        node0 = node0 - value0
+        node2 = node2 + value0
+
+        assert_equal(self.nodes[0].getbalance()["bitcoin"], node0)
+        assert_equal(self.nodes[1].getbalance("*", 1, False, "bitcoin"), node1)
+        assert_equal(self.nodes[2].getbalance()["bitcoin"], node2)
+
+        # Send 5 BTC from 0 to a new address of 2 with the sendtoaddress call
+        address2 = self.nodes[2].getnewaddress()
+        unconfidential_address2 = self.nodes[2].validateaddress(address2)["unconfidential"]
+        value1 = 5
+        confidential_tx_id = self.nodes[0].sendtoaddress(address2, value1)
+        self.nodes[0].generate(101)
+        self.sync_all()
+
+        node0 = node0 - value1
+        node2 = node2 + value1
+
+        assert_equal(self.nodes[0].getbalance()["bitcoin"], node0)
+        assert_equal(self.nodes[1].getbalance("*", 1, False, "bitcoin"), node1)
+        assert_equal(self.nodes[2].getbalance()["bitcoin"], node2)
+
+        # Send 7 BTC from 0 to the unconfidential address of 2 and 11 BTC to the
+        # confidential address using the raw transaction interface
+        change_address = self.nodes[0].getnewaddress()
+        value2 = 7
+        value3 = 11
+        value23 = value2 + value3
+        unspent = self.nodes[0].listunspent(1, 9999999, [], True, {"asset": "bitcoin"})
+        unspent = [i for i in unspent if i['amount'] > value23]
+        assert_equal(len(unspent), 1)
+        fee = Decimal('0.0001')
+        tx = self.nodes[0].createrawtransaction([{"txid": unspent[0]["txid"],
+                                                  "vout": unspent[0]["vout"],
+                                                  "nValue": unspent[0]["amount"]}],
+                                                {unconfidential_address: value2, address2: value3,
+                                                change_address: unspent[0]["amount"] - value2 - value3 - fee, "fee":fee})
+        tx = self.nodes[0].blindrawtransaction(tx)
+        tx_signed = self.nodes[0].signrawtransactionwithwallet(tx)
+        raw_tx_id = self.nodes[0].sendrawtransaction(tx_signed['hex'])
+        self.nodes[0].generate(101)
+        self.sync_all()
+
+        node0 -= (value2 + value3)
+        node2 += value2 + value3
+
+        assert_equal(self.nodes[0].getbalance()["bitcoin"], node0)
+        assert_equal(self.nodes[1].getbalance("*", 1, False, "bitcoin"), node1)
+        assert_equal(self.nodes[2].getbalance()["bitcoin"], node2)
+
+        # Check 2's listreceivedbyaddress
+        received_by_address = self.nodes[2].listreceivedbyaddress(0, False, False, "", "bitcoin")
+        validate_by_address = [(address2, {"bitcoin": value1 + value3}), (address, {"bitcoin": value0 + value2})]
+        assert_equal(sorted([(ele['address'], ele['amount']) for ele in received_by_address], key=lambda t: t[0]),
+                sorted(validate_by_address, key = lambda t: t[0]))
+
+        # Give an auditor (node 1) a blinding key to allow her to look at
+        # transaction values
+        self.nodes[1].importaddress(address2)
+        received_by_address = self.nodes[1].listreceivedbyaddress(1, False, True)
+        #Node sees nothing unless it understands the values
+        assert_equal(len(received_by_address), 0)
+        assert_equal(len(self.nodes[1].listunspent(1, 9999999, [], True, {"asset": "bitcoin"})), 0)
+
+        # Import the blinding key
+        blindingkey = self.nodes[2].dumpblindingkey(address2)
+        self.nodes[1].importblindingkey(address2, blindingkey)
+        # Check the auditor's gettransaction and listreceivedbyaddress
+        # Needs rescan to update wallet txns
+        conf_tx = self.nodes[1].gettransaction(confidential_tx_id, True)
+        assert_equal(conf_tx['amount']["bitcoin"], value1)
+
+        # Make sure wallet can now deblind part of transaction
+        deblinded_tx = self.nodes[1].unblindrawtransaction(conf_tx['hex'])['hex']
+        for output in self.nodes[1].decoderawtransaction(deblinded_tx)["vout"]:
+            if "value" in output and output["scriptPubKey"]["type"] != "fee":
+                assert_equal(output["scriptPubKey"]["addresses"][0], self.nodes[1].validateaddress(address2)['unconfidential'])
+                found_unblinded = True
+        assert(found_unblinded)
+
+        assert_equal(self.nodes[1].gettransaction(raw_tx_id, True)['amount']["bitcoin"], value3)
+        list_unspent = self.nodes[1].listunspent(1, 9999999, [], True, {"asset": "bitcoin"})
+        assert_equal(list_unspent[0]['amount']+list_unspent[1]['amount'], value1+value3)
+        received_by_address = self.nodes[1].listreceivedbyaddress(1, False, True)
+        assert_equal(len(received_by_address), 1)
+        assert_equal((received_by_address[0]['address'], received_by_address[0]['amount']['bitcoin']),
+                     (unconfidential_address2, value1 + value3))
+
+        # Spending a single confidential output and sending it to a
+        # unconfidential output is not possible with CT. Test the
+        # correct behavior of blindrawtransaction.
+        unspent = self.nodes[0].listunspent(1, 9999999, [], True, {"asset": "bitcoin"})
+        unspent = [i for i in unspent if i['amount'] > value23]
+        assert_equal(len(unspent), 1)
+        tx = self.nodes[0].createrawtransaction([{"txid": unspent[0]["txid"],
+                                                  "vout": unspent[0]["vout"],
+                                                  "nValue": unspent[0]["amount"]}],
+                                                  {unconfidential_address: unspent[0]["amount"] - fee, "fee":fee})
+
+        # Test that blindrawtransaction adds an OP_RETURN output to balance blinders
+        temptx = self.nodes[0].blindrawtransaction(tx)
+        decodedtx = self.nodes[0].decoderawtransaction(temptx)
+        assert_equal(decodedtx["vout"][-1]["scriptPubKey"]["asm"], "OP_RETURN")
+        assert_equal(len(decodedtx["vout"]), 3)
+
+        # Create same transaction but with a change/dummy output.
+        # It should pass the blinding step.
+        value4 = 17
+        change_address = self.nodes[0].getrawchangeaddress()
+        tx = self.nodes[0].createrawtransaction([{"txid": unspent[0]["txid"],
+                                                  "vout": unspent[0]["vout"],
+                                                  "nValue": unspent[0]["amount"]}],
+                                                  {unconfidential_address: value4,
+                                                   change_address: unspent[0]["amount"] - value4 - fee, "fee":fee})
+        tx = self.nodes[0].blindrawtransaction(tx)
+        tx_signed = self.nodes[0].signrawtransactionwithwallet(tx)
+        txid = self.nodes[0].sendrawtransaction(tx_signed['hex'])
+        decodedtx = self.nodes[0].decoderawtransaction(tx_signed["hex"])
+        self.nodes[0].generate(101)
+        self.sync_all()
+
+        unblindfound = False
+        for i in range(len(decodedtx["vout"])):
+            txout = self.nodes[0].gettxout(txid, i)
+            if txout is not None and "asset" in txout:
+                unblindfound = True
+
+        if unblindfound == False:
+            raise Exception("No unconfidential output detected when one should exist")
+
+        node0 -= value4
+        node2 += value4
+        assert_equal(self.nodes[0].getbalance()["bitcoin"], node0)
+        assert_equal(self.nodes[1].getbalance("*", 1, False, "bitcoin"), node1)
+        assert_equal(self.nodes[2].getbalance()["bitcoin"], node2)
+
+        # Testing wallet's ability to deblind its own outputs
+        addr = self.nodes[0].getnewaddress()
+        addr2 = self.nodes[0].getnewaddress()
+        # We add two to-blind outputs, fundraw adds an already-blinded change output
+        # If we only add one, the newly blinded will be 0-blinded because input = -output
+        raw = self.nodes[0].createrawtransaction([], {addr:Decimal('1.1'), addr2:1})
+        funded = self.nodes[0].fundrawtransaction(raw)
+        # fund again to make sure no blinded outputs were created (would fail)
+        funded = self.nodes[0].fundrawtransaction(funded["hex"])
+        blinded = self.nodes[0].blindrawtransaction(funded["hex"])
+        # blind again to make sure we know output blinders
+        blinded2 = self.nodes[0].blindrawtransaction(blinded)
+        # then sign and send
+        signed = self.nodes[0].signrawtransactionwithwallet(blinded2)
+        self.nodes[0].sendrawtransaction(signed["hex"])
+
+        # Check createblindedaddress functionality
+        blinded_addr = self.nodes[0].getnewaddress()
+        validated_addr = self.nodes[0].validateaddress(blinded_addr)
+        blinding_pubkey = self.nodes[0].validateaddress(blinded_addr)["confidential_key"]
+        blinding_key = self.nodes[0].dumpblindingkey(blinded_addr)
+        assert_equal(blinded_addr, self.nodes[1].createblindedaddress(validated_addr["unconfidential"], blinding_pubkey))
+
+        # If a blinding key is over-ridden by a newly imported one, funds may be unaccounted for
+        new_addr = self.nodes[0].getnewaddress()
+        new_validated = self.nodes[0].validateaddress(new_addr)
+        self.nodes[2].sendtoaddress(new_addr, 1)
+        self.sync_all()
+        diff_blind = self.nodes[1].createblindedaddress(new_validated["unconfidential"], blinding_pubkey)
+        assert_equal(len(self.nodes[0].listunspent(0, 0, [new_validated["unconfidential"]])), 1)
+        self.nodes[0].importblindingkey(diff_blind, blinding_key)
+        # CT values for this wallet transaction  have been cached via importblindingkey
+        # therefore result will be same even though we change blinding keys
+        assert_equal(len(self.nodes[0].listunspent(0, 0, [new_validated["unconfidential"]])), 1)
+
+        # Confidential Assets Tests
+
+        print("Assets tests...")
+
+        # Bitcoin is the first issuance
+        assert_equal(self.nodes[0].listissuances()[0]["assetlabel"], "bitcoin")
+        assert_equal(len(self.nodes[0].listissuances()), 1)
+
+        # Unblinded issuance of asset
+        issued = self.nodes[0].issueasset(1, 1, False)
+        self.nodes[0].reissueasset(issued["asset"], 1)
+
+        # Compare resulting fields with getrawtransaction
+        raw_details = self.nodes[0].getrawtransaction(issued["txid"], 1)
+        assert_equal(issued["entropy"], raw_details["vin"][issued["vin"]]["issuance"]["assetEntropy"])
+        assert_equal(issued["asset"], raw_details["vin"][issued["vin"]]["issuance"]["asset"])
+        assert_equal(issued["token"], raw_details["vin"][issued["vin"]]["issuance"]["token"])
+
+        self.nodes[0].generate(1)
+        self.sync_all()
+
+        issued2 = self.nodes[0].issueasset(2, 1)
+        test_asset = issued2["asset"]
+        assert_equal(self.nodes[0].getwalletinfo()['balance'][test_asset], Decimal(2))
+        assert(test_asset not in self.nodes[1].getwalletinfo()['balance'])
+
+        # Assets balance checking, note that accounts are completely ignored because
+        # balance queries with accounts are horrifically broken upstream
+        assert_equal(self.nodes[0].getbalance("*", 0, False, "bitcoin"), self.nodes[0].getbalance("*", 0, False, "bitcoin"))
+        assert_equal(self.nodes[0].getwalletinfo()['balance']['bitcoin'], self.nodes[0].getbalance("*", 0, False, "bitcoin"))
+
+        # Send some bitcoin and other assets over as well to fund wallet
+        addr = self.nodes[2].getnewaddress()
+        self.nodes[0].sendtoaddress(addr, 5)
+        self.nodes[0].sendmany("", {addr: 1, self.nodes[2].getnewaddress(): 13}, 0, "", [], False, 1, "UNSET", {addr: test_asset})
+
+        self.sync_all()
+
+        # Should have exactly 1 in change(trusted, though not confirmed) after sending one off
+        assert_equal(self.nodes[0].getbalance("*", 0, False, test_asset), 1)
+        assert_equal(self.nodes[2].getunconfirmedbalance()[test_asset], Decimal(1))
+
+        b_utxos = self.nodes[2].listunspent(0, 0, [], True, {"asset": "bitcoin"})
+        t_utxos = self.nodes[2].listunspent(0, 0, [], True, {"asset": test_asset})
+
+        assert_equal(len(self.nodes[2].listunspent(0, 0, [])), len(b_utxos)+len(t_utxos))
+
+        # Now craft a blinded transaction via raw api
+        rawaddrs = []
+        for i in range(2):
+            rawaddrs.append(self.nodes[1].getnewaddress())
+        raw_assets = self.nodes[2].createrawtransaction([{"txid":b_utxos[0]['txid'], "vout":b_utxos[0]['vout'], "nValue":b_utxos[0]['amount']}, {"txid":b_utxos[1]['txid'], "vout":b_utxos[1]['vout'], "nValue":b_utxos[1]['amount'], "asset":b_utxos[1]['asset']}, {"txid":t_utxos[0]['txid'], "vout":t_utxos[0]['vout'], "nValue":t_utxos[0]['amount'], "asset":t_utxos[0]['asset']}], {rawaddrs[1]:Decimal(t_utxos[0]['amount']), rawaddrs[0]:Decimal(b_utxos[0]['amount']+b_utxos[1]['amount']-Decimal("0.01")), "fee":Decimal("0.01")}, 0, False, {rawaddrs[0]:b_utxos[0]['asset'], rawaddrs[1]:t_utxos[0]['asset'], "fee":b_utxos[0]['asset']})
+
+        # Sign unblinded, then blinded
+        signed_assets = self.nodes[2].signrawtransactionwithwallet(raw_assets)
+        blind_assets = self.nodes[2].blindrawtransaction(raw_assets)
+        signed_assets = self.nodes[2].signrawtransactionwithwallet(blind_assets)
+
+        # And finally send
+        self.nodes[2].sendrawtransaction(signed_assets['hex'])
+        self.nodes[2].generate(101)
+        self.sync_all()
+
+        issuancedata = self.nodes[2].issueasset(0, Decimal('0.00000006')) #0 of asset, 6 reissuance token
+
+        # Node 2 will send node 1 a reissuance token, both will generate assets
+        self.nodes[2].sendtoaddress(self.nodes[1].getnewaddress(), Decimal('0.00000001'), "", "", False, False, 1, "UNSET", issuancedata["token"])
+        # node 1 needs to know about a (re)issuance to reissue itself
+        self.nodes[1].importaddress(self.nodes[2].gettransaction(issuancedata["txid"])["details"][0]["address"])
+        # also send some bitcoin
+        self.nodes[2].generate(1)
+        self.sync_all()
+
+        self.nodes[1].reissueasset(issuancedata["asset"], Decimal('0.05'))
+        self.nodes[2].reissueasset(issuancedata["asset"], Decimal('0.025'))
+        self.nodes[1].generate(1)
+        self.sync_all()
+
+        # Check for value accounting when asset issuance is null but token not, ie unblinded
+        issued = self.nodes[0].issueasset(0, 1, False)
+        walletinfo = self.nodes[0].getwalletinfo()
+        assert(issued["asset"] not in walletinfo["balance"])
+        assert_equal(walletinfo["balance"][issued["token"]], Decimal(1))
+        assert(issued["asset"] not in walletinfo["unconfirmed_balance"])
+        assert(issued["token"] not in walletinfo["unconfirmed_balance"])
+
+        # Check for value when receiving different assets by same address.
+        self.nodes[0].sendtoaddress(unconfidential_address2, Decimal('0.00000001'), "", "", False, False, 1, "UNSET", test_asset)
+        self.nodes[0].sendtoaddress(unconfidential_address2, Decimal('0.00000002'), "", "", False, False, 1, "UNSET", test_asset)
+        self.nodes[0].generate(1)
+        self.sync_all()
+        received_by_address = self.nodes[1].listreceivedbyaddress(0, False, True)
+        multi_asset_amount = [x for x in received_by_address if x['address'] == unconfidential_address2][0]['amount']
+        assert_equal(multi_asset_amount['bitcoin'], value1 + value3)
+        assert_equal(multi_asset_amount[test_asset], Decimal('0.00000003'))
+
+        # Check blinded multisig functionality
+        # Get two pubkeys
+        blinded_addr = self.nodes[0].getnewaddress()
+        pubkey = self.nodes[0].getaddressinfo(blinded_addr)["pubkey"]
+        blinded_addr2 = self.nodes[1].getnewaddress()
+        pubkey2 = self.nodes[1].getaddressinfo(blinded_addr2)["pubkey"]
+        pubkeys = [pubkey, pubkey2]
+        # Add multisig address
+        unconfidential_addr = self.nodes[0].addmultisigaddress(2, pubkeys)["address"]
+        self.nodes[1].addmultisigaddress(2, pubkeys)
+        self.nodes[0].importaddress(unconfidential_addr)
+        self.nodes[1].importaddress(unconfidential_addr)
+        # Use blinding key from node 0's original getnewaddress call
+        blinding_pubkey = self.nodes[0].getaddressinfo(blinded_addr)["confidential_key"]
+        blinding_key = self.nodes[0].dumpblindingkey(blinded_addr)
+        # Create blinded address from p2sh address and import corresponding privkey
+        blinded_multisig_addr = self.nodes[0].createblindedaddress(unconfidential_addr, blinding_pubkey)
+        self.nodes[0].importblindingkey(blinded_multisig_addr, blinding_key)
+        self.nodes[1].importblindingkey(blinded_multisig_addr, blinding_key)
+        # Send coins to blinded multisig address and check that they were received
+        self.nodes[2].sendtoaddress(blinded_multisig_addr, 1)
+        self.sync_all()
+        assert_equal(len(self.nodes[0].listunspent(0, 0, [unconfidential_addr])), 1)
+        assert_equal(len(self.nodes[1].listunspent(0, 0, [unconfidential_addr])), 1)
+
+        self.nodes[0].generate(1)
+        self.sync_all()
+
+        # Basic checks of rawblindrawtransaction functionality
+        blinded_addr = self.nodes[0].getnewaddress()
+        addr = self.nodes[0].validateaddress(blinded_addr)["unconfidential"]
+        self.nodes[0].sendtoaddress(blinded_addr, 1)
+        self.nodes[0].sendtoaddress(blinded_addr, 3)
+        unspent = self.nodes[0].listunspent(0, 0)
+        assert_equal(len(unspent), 4)
+        rawtx = self.nodes[0].createrawtransaction([{"txid":unspent[0]["txid"], "vout":unspent[0]["vout"]}, {"txid":unspent[1]["txid"], "vout":unspent[1]["vout"]}], {addr:unspent[0]["amount"]+unspent[1]["amount"]-Decimal("0.2"), "fee":Decimal("0.2")})
+        # Blinding will fail with 2 blinded inputs and 0 blinded outputs
+        # since it has no notion of a wallet to fill in a 0-value OP_RETURN output
+        try:
+            self.nodes[0].rawblindrawtransaction(rawtx, [unspent[0]["amountblinder"], unspent[1]["amountblinder"]], [unspent[0]["amount"], unspent[1]["amount"]], [unspent[0]["asset"], unspent[1]["asset"]], [unspent[0]["assetblinder"], unspent[1]["assetblinder"]])
+            raise AssertionError("Shouldn't be able to blind 2 input 0 output transaction via rawblindraw")
+        except JSONRPCException:
+            pass
+
+        # Blinded destination added, can blind, sign and send
+        rawtx = self.nodes[0].createrawtransaction([{"txid":unspent[0]["txid"], "vout":unspent[0]["vout"]}, {"txid":unspent[1]["txid"], "vout":unspent[1]["vout"]}], {blinded_addr:unspent[0]["amount"]+unspent[1]["amount"]-Decimal("0.002"), "fee":Decimal("0.002")})
+        signtx = self.nodes[0].signrawtransactionwithwallet(rawtx)
+
+        try:
+            self.nodes[0].sendrawtransaction(signtx["hex"])
+            raise AssertionError("Shouldn't be able to send unblinded tx with emplaced pubkey in output without additional argument")
+        except JSONRPCException:
+            pass
+
+        blindtx = self.nodes[0].rawblindrawtransaction(rawtx, [unspent[0]["amountblinder"], unspent[1]["amountblinder"]], [unspent[0]["amount"], unspent[1]["amount"]], [unspent[0]["asset"], unspent[1]["asset"]], [unspent[0]["assetblinder"], unspent[1]["assetblinder"]])
+        signtx = self.nodes[0].signrawtransactionwithwallet(blindtx)
+        txid = self.nodes[0].sendrawtransaction(signtx["hex"])
+        for output in self.nodes[0].decoderawtransaction(blindtx)["vout"]:
+            if "asset" in output and output["scriptPubKey"]["type"] != "fee":
+                raise AssertionError("An unblinded output exists")
+
+        # Test fundrawtransaction with multiple assets
+        issue = self.nodes[0].issueasset(1, 0)
+        assetaddr = self.nodes[0].getnewaddress()
+        rawtx = self.nodes[0].createrawtransaction([], {assetaddr:1, self.nodes[0].getnewaddress():2}, 0, False, {assetaddr:issue["asset"]})
+        funded = self.nodes[0].fundrawtransaction(rawtx)
+        blinded = self.nodes[0].blindrawtransaction(funded["hex"])
+        signed = self.nodes[0].signrawtransactionwithwallet(blinded)
+        txid = self.nodes[0].sendrawtransaction(signed["hex"])
+
+        # Test fundrawtransaction with multiple inputs, creating > vout.size change
+        rawtx = self.nodes[0].createrawtransaction([{"txid":txid, "vout":0}, {"txid":txid, "vout":1}], {self.nodes[0].getnewaddress():5})
+        funded = self.nodes[0].fundrawtransaction(rawtx)
+        blinded = self.nodes[0].blindrawtransaction(funded["hex"])
+        signed = self.nodes[0].signrawtransactionwithwallet(blinded)
+        txid = self.nodes[0].sendrawtransaction(signed["hex"])
+
+        # Test corner case where wallet appends a OP_RETURN output, yet doesn't blind it
+        # due to the fact that the output value is 0-value and input pedersen commitments
+        # self-balance. This is rare corner case, but ok.
+        unblinded = self.nodes[0].validateaddress(self.nodes[0].getnewaddress())["unconfidential"]
+        self.nodes[0].sendtoaddress(unblinded, self.nodes[0].getbalance()["bitcoin"], "", "", True)
+        # Make tx with blinded destination and change outputs only
+        self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), self.nodes[0].getbalance()["bitcoin"]/2)
+        # Send back again, this transaction should have 3 outputs, all unblinded
+        txid = self.nodes[0].sendtoaddress(unblinded, self.nodes[0].getbalance()["bitcoin"], "", "", True)
+        outputs = self.nodes[0].getrawtransaction(txid, 1)["vout"]
+        assert_equal(len(outputs), 3)
+        assert("value" in outputs[0] and "value" in outputs[1] and "value" in outputs[2])
+        assert_equal(outputs[2]["scriptPubKey"]["type"], 'nulldata')
+
+        # TODO: signrawtransactionwith{wallet, key} with confidential segwit input given as previous transaction arg
+
+if __name__ == '__main__':
+    CTTest ().main ()
diff --git a/test/functional/feature_csv_activation.py b/test/functional/feature_csv_activation.py
index df79c4312c455..42e453ad9d719 100755
--- a/test/functional/feature_csv_activation.py
+++ b/test/functional/feature_csv_activation.py
@@ -94,14 +94,14 @@ def sign_transaction(node, unsignedtx):
     return tx
 
 def create_bip112special(node, input, txversion, address):
-    tx = create_transaction(node, input, address, amount=Decimal("49.98"))
+    tx = create_transaction(node, input, address, amount=Decimal("49.98"), fee=Decimal("0.02"))
     tx.nVersion = txversion
     signtx = sign_transaction(node, tx)
     signtx.vin[0].scriptSig = CScript([-1, OP_CHECKSEQUENCEVERIFY, OP_DROP] + list(CScript(signtx.vin[0].scriptSig)))
     return signtx
 
 def send_generic_input_tx(node, coinbases, address):
-    return node.sendrawtransaction(ToHex(sign_transaction(node, create_transaction(node, node.getblock(coinbases.pop())['tx'][0], address, amount=Decimal("49.99")))))
+    return node.sendrawtransaction(ToHex(sign_transaction(node, create_transaction(node, node.getblock(coinbases.pop())['tx'][0], address, amount=Decimal("49.99"), fee=Decimal("0.01")))))
 
 def create_bip68txs(node, bip68inputs, txversion, address, locktime_delta=0):
     """Returns a list of bip68 transactions with different bits set."""
@@ -109,7 +109,7 @@ def create_bip68txs(node, bip68inputs, txversion, address, locktime_delta=0):
     assert(len(bip68inputs) >= 16)
     for i, (sdf, srhb, stf, srlb) in enumerate(product(*[[True, False]] * 4)):
         locktime = relative_locktime(sdf, srhb, stf, srlb)
-        tx = create_transaction(node, bip68inputs[i], address, amount=Decimal("49.98"))
+        tx = create_transaction(node, bip68inputs[i], address, amount=Decimal("49.98"), fee=Decimal("0.02"))
         tx.nVersion = txversion
         tx.vin[0].nSequence = locktime + locktime_delta
         tx = sign_transaction(node, tx)
@@ -124,7 +124,7 @@ def create_bip112txs(node, bip112inputs, varyOP_CSV, txversion, address, locktim
     assert(len(bip112inputs) >= 16)
     for i, (sdf, srhb, stf, srlb) in enumerate(product(*[[True, False]] * 4)):
         locktime = relative_locktime(sdf, srhb, stf, srlb)
-        tx = create_transaction(node, bip112inputs[i], address, amount=Decimal("49.98"))
+        tx = create_transaction(node, bip112inputs[i], address, amount=Decimal("49.98"), fee=Decimal("0.02"))
         if (varyOP_CSV):  # if varying OP_CSV, nSequence is fixed
             tx.vin[0].nSequence = BASE_RELATIVE_LOCKTIME + locktime_delta
         else:  # vary nSequence instead, OP_CSV is fixed
@@ -271,10 +271,10 @@ def run_test(self):
 
         # Test both version 1 and version 2 transactions for all tests
         # BIP113 test transaction will be modified before each use to put in appropriate block time
-        bip113tx_v1 = create_transaction(self.nodes[0], bip113input, self.nodeaddress, amount=Decimal("49.98"))
+        bip113tx_v1 = create_transaction(self.nodes[0], bip113input, self.nodeaddress, amount=Decimal("49.98"), fee=Decimal("0.02"))
         bip113tx_v1.vin[0].nSequence = 0xFFFFFFFE
         bip113tx_v1.nVersion = 1
-        bip113tx_v2 = create_transaction(self.nodes[0], bip113input, self.nodeaddress, amount=Decimal("49.98"))
+        bip113tx_v2 = create_transaction(self.nodes[0], bip113input, self.nodeaddress, amount=Decimal("49.98"), fee=Decimal("0.02"))
         bip113tx_v2.vin[0].nSequence = 0xFFFFFFFE
         bip113tx_v2.nVersion = 2
 
diff --git a/test/functional/feature_default_asset_name.py b/test/functional/feature_default_asset_name.py
new file mode 100755
index 0000000000000..7e772f3c1f86d
--- /dev/null
+++ b/test/functional/feature_default_asset_name.py
@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+# Copyright (c) 2014-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.
+
+#
+# Test chain initialisation when specifying default asset name.
+#
+
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import assert_equal, connect_nodes_bi
+
+class NamedDefaultAssetTest(BitcoinTestFramework):
+    """
+    Test creation of default asset is named according to defaultpeggedasset parameter
+
+    """
+
+    def set_test_params(self):
+        self.setup_clean_chain = True
+        self.num_nodes = 2
+
+        #Set default asset name
+        self.extra_args = [["-defaultpeggedassetname=testasset", "-initialfreecoins=2100000000000000", "-anyonecanspendaremine=1", "-con_connect_coinbase=1", "-con_blocksubsidy=0"]]*2
+
+    def setup_network(self, split=False):
+        self.setup_nodes()
+        connect_nodes_bi(self.nodes, 0, 1)
+        self.is_network_split = False
+        self.sync_all()
+
+    def run_test(self):
+        #Claim all anyone-can-spend coins and test that calling sendtoaddress without providing the assetlabel parameter results in the specified default pegged asset being sent.
+        self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), 21000000, "", "", True)
+        self.nodes[0].generate(101)
+        self.sync_all()
+
+        #Check the default asset is named correctly
+        walletinfo1 = self.nodes[0].getwalletinfo()
+        assert_equal(walletinfo1["balance"]["testasset"], 21000000)
+
+        #Send some of the default asset to the second node
+        self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 1, "", "", False)
+        self.nodes[0].generate(101)
+        self.sync_all()
+
+        #Check balances are correct and asset is named correctly
+        walletinfo1 = self.nodes[0].getwalletinfo()
+        assert_equal(walletinfo1["balance"]["testasset"], 20999999)
+
+        walletinfo2 = self.nodes[1].getwalletinfo()
+        assert_equal(walletinfo2["balance"]["testasset"], 1)
+
+        #Check we send the default 'testasset' when calling 'sendmany' without needing to provide the relevant asset label
+        outputs = {self.nodes[1].getnewaddress(): 1.0, self.nodes[1].getnewaddress(): 3.0}
+        self.nodes[0].sendmany("", outputs)
+        self.nodes[0].generate(101)
+        self.sync_all()
+
+        #Check balances are correct and asset is named correctly
+        walletinfo1 = self.nodes[0].getwalletinfo()
+        assert_equal(walletinfo1["balance"]["testasset"], 20999995)
+
+        walletinfo2 = self.nodes[1].getwalletinfo()
+        assert_equal(walletinfo2["balance"]["testasset"], 5)
+
+if __name__ == '__main__':
+    NamedDefaultAssetTest().main()
diff --git a/test/functional/feature_dersig.py b/test/functional/feature_dersig.py
index 16272877e7a9e..db05ea23b78c8 100755
--- a/test/functional/feature_dersig.py
+++ b/test/functional/feature_dersig.py
@@ -61,8 +61,9 @@ def run_test(self):
 
         self.log.info("Test that a transaction with non-DER signature can still appear in a block")
 
+        coinbase_value = self.nodes[0].decoderawtransaction(self.nodes[0].gettransaction(self.coinbase_txids[0])["hex"])["vout"][0]["value"]
         spendtx = create_transaction(self.nodes[0], self.coinbase_txids[0],
-                self.nodeaddress, amount=1.0)
+                self.nodeaddress, amount=1.0, fee=coinbase_value-1)
         unDERify(spendtx)
         spendtx.rehash()
 
@@ -94,8 +95,9 @@ def run_test(self):
         self.log.info("Test that transactions with non-DER signatures cannot appear in a block")
         block.nVersion = 3
 
+        coinbase_value = self.nodes[0].decoderawtransaction(self.nodes[0].gettransaction(self.coinbase_txids[1])["hex"])["vout"][0]["value"]
         spendtx = create_transaction(self.nodes[0], self.coinbase_txids[1],
-                self.nodeaddress, amount=1.0)
+                self.nodeaddress, amount=1.0, fee=coinbase_value-1)
         unDERify(spendtx)
         spendtx.rehash()
 
@@ -124,7 +126,8 @@ def run_test(self):
             assert b'Non-canonical DER signature' in self.nodes[0].p2p.last_message["reject"].reason
 
         self.log.info("Test that a version 3 block with a DERSIG-compliant transaction is accepted")
-        block.vtx[1] = create_transaction(self.nodes[0], self.coinbase_txids[1], self.nodeaddress, amount=1.0)
+        coinbase_value = self.nodes[0].decoderawtransaction(self.nodes[0].gettransaction(self.coinbase_txids[1])["hex"])["vout"][0]["value"]
+        block.vtx[1] = create_transaction(self.nodes[0], self.coinbase_txids[1], self.nodeaddress, amount=1.0, fee=coinbase_value-1)
         block.hashMerkleRoot = block.calc_merkle_root()
         block.rehash()
         block.solve()
diff --git a/test/functional/feature_fedpeg.py b/test/functional/feature_fedpeg.py
index 0c46686651349..e8ea452c3a42e 100755
--- a/test/functional/feature_fedpeg.py
+++ b/test/functional/feature_fedpeg.py
@@ -11,6 +11,7 @@
     rpc_port,
     p2p_port,
 )
+from decimal import Decimal
 
 def get_new_unconfidential_address(node):
     addr = node.getnewaddress()
@@ -64,9 +65,8 @@ def setup_network(self, split=False):
         connect_nodes_bi(self.nodes, 0, 1)
         self.parentgenesisblockhash = self.nodes[0].getblockhash(0)
         print('parentgenesisblockhash', self.parentgenesisblockhash)
-        #TODO(rebase) CA
-        #if not self.options.parent_bitcoin:
-        #    parent_pegged_asset = self.nodes[0].getsidechaininfo()['pegged_asset']
+        if not self.options.parent_bitcoin:
+            parent_pegged_asset = self.nodes[0].getsidechaininfo()['pegged_asset']
 
         # Setup sidechain nodes
         self.fedpeg_script = "512103dff4923d778550cc13ce0d887d737553b4b58f4e8e886507fc39f5e447b2186451ae"
@@ -89,14 +89,10 @@ def setup_network(self, split=False):
             ]
             if not self.options.parent_bitcoin:
                 extra_args.extend([
-                    #TODO(rebase) should the defaults be put back to elements-specific ones?
-                    #'-parentpubkeyprefix=235',
-                    #'-parentscriptprefix=75',
                     '-parentpubkeyprefix=111',
                     '-parentscriptprefix=196',
                     '-con_parent_chain_signblockscript=51',
-                    #TODO(rebase) CA
-                    #'-con_parent_pegged_asset=%s' % parent_pegged_asset,
+                    '-con_parent_pegged_asset=%s' % parent_pegged_asset,
                 ])
 
             # Use rpcuser auth only for first parent.
@@ -222,14 +218,13 @@ def run_test(self):
         decoded = sidechain.decoderawtransaction(tx1["hex"])
         assert decoded["vin"][0]["is_pegin"] == True
         assert len(decoded["vin"][0]["pegin_witness"]) > 0
-        #TODO(rebase) CT assert fee here too
         # Check that there's sufficient fee for the peg-in
-        #vsize = decoded["vsize"]
-        #fee_output = decoded["vout"][1]
-        #fallbackfee_pervbyte = Decimal("0.00001")/Decimal("1000")
-        #print("fee_output", fee_output)
-        #assert fee_output["scriptPubKey"]["type"] == "fee"
-        #assert fee_output["value"] >= fallbackfee_pervbyte*vsize
+        vsize = decoded["vsize"]
+        fee_output = decoded["vout"][1]
+        fallbackfee_pervbyte = Decimal("0.00001")/Decimal("1000")
+        print("fee_output", fee_output)
+        assert fee_output["scriptPubKey"]["type"] == "fee"
+        assert fee_output["value"] >= fallbackfee_pervbyte*vsize
 
         # Quick reorg checks of pegs
         sidechain.invalidateblock(blockhash[0])
@@ -331,7 +326,7 @@ def run_test(self):
                 break
         assert pegout_tested
 
-        print ("Now test failure to validate peg-ins based on intermittent bitcoind rpc failure")
+        print("Now test failure to validate peg-ins based on intermittent bitcoind rpc failure")
         self.stop_node(1)
         txid = parent.sendtoaddress(addr, 1)
         parent.generate(12)
@@ -357,57 +352,47 @@ def run_test(self):
         print("Completed!\n")
         print("Now send funds out in two stages, partial, and full")
         some_btc_addr = get_new_unconfidential_address(parent)
-        #TODO(rebase) CA bitcoin balances
-        #bal_1 = sidechain.getwalletinfo()["balance"]["bitcoin"]
-        bal_1 = sidechain.getwalletinfo()["balance"]
+        bal_1 = sidechain.getwalletinfo()["balance"]['bitcoin']
         try:
             sidechain.sendtomainchain(some_btc_addr, bal_1 + 1)
             raise Exception("Sending out too much; should have failed")
         except JSONRPCException as e:
             assert("Insufficient funds" in e.error["message"])
 
-        #assert(sidechain.getwalletinfo()["balance"]["bitcoin"] == bal_1)
-        assert(sidechain.getwalletinfo()["balance"] == bal_1)
+        assert(sidechain.getwalletinfo()["balance"]["bitcoin"] == bal_1)
         try:
             sidechain.sendtomainchain(some_btc_addr+"b", bal_1 - 1)
             raise Exception("Sending to invalid address; should have failed")
         except JSONRPCException as e:
             assert("Invalid Bitcoin address" in e.error["message"])
 
-        #assert(sidechain.getwalletinfo()["balance"]["bitcoin"] == bal_1)
-        assert(sidechain.getwalletinfo()["balance"] == bal_1)
+        assert(sidechain.getwalletinfo()["balance"]["bitcoin"] == bal_1)
         try:
             sidechain.sendtomainchain("1Nro9WkpaKm9axmcfPVp79dAJU1Gx7VmMZ", bal_1 - 1)
             raise Exception("Sending to mainchain address when should have been testnet; should have failed")
         except JSONRPCException as e:
             assert("Invalid Bitcoin address" in e.error["message"])
 
-        #assert(sidechain.getwalletinfo()["balance"]["bitcoin"] == bal_1)
-        assert(sidechain.getwalletinfo()["balance"] == bal_1)
+        assert(sidechain.getwalletinfo()["balance"]["bitcoin"] == bal_1)
 
         peg_out_txid = sidechain.sendtomainchain(some_btc_addr, 1)
 
         peg_out_details = sidechain.decoderawtransaction(sidechain.getrawtransaction(peg_out_txid))
-        # peg-out, change
-        #TODO(rebase) CA/CT fee output
-        #assert(len(peg_out_details["vout"]) == 3)
-        assert(len(peg_out_details["vout"]) == 2)
+        # peg-out, change, fee
+        assert(len(peg_out_details["vout"]) == 3)
         found_pegout_value = False
         for output in peg_out_details["vout"]:
             if "value" in output and output["value"] == 1:
                 found_pegout_value = True
         assert(found_pegout_value)
 
-        #bal_2 = sidechain.getwalletinfo()["balance"]["bitcoin"]
-        bal_2 = sidechain.getwalletinfo()["balance"]
+        bal_2 = sidechain.getwalletinfo()["balance"]["bitcoin"]
         # Make sure balance went down
         assert(bal_2 + 1 < bal_1)
 
         sidechain.sendtomainchain(some_btc_addr, bal_2, True)
 
-        #TODO(rebase) CA bitcoin balance
-        #assert("bitcoin" not in sidechain.getwalletinfo()["balance"])
-        assert(sidechain.getwalletinfo()["balance"] == 0)
+        assert(sidechain.getwalletinfo()["balance"]['bitcoin'] == 0)
 
         print('Success!')
 
diff --git a/test/functional/feature_fee_estimation.py b/test/functional/feature_fee_estimation.py
index aaab4279b5f04..77e553b53e5c9 100755
--- a/test/functional/feature_fee_estimation.py
+++ b/test/functional/feature_fee_estimation.py
@@ -61,6 +61,7 @@ def small_txpuzzle_randfee(from_node, conflist, unconflist, amount, min_fee, fee
             raise RuntimeError("Insufficient funds: need %d, have %d" % (amount + fee, total_in))
     tx.vout.append(CTxOut(int((total_in - amount - fee) * COIN), P2SH_1))
     tx.vout.append(CTxOut(int(amount * COIN), P2SH_2))
+    tx.vout.append(CTxOut(int(fee*COIN))) # fee
     # These transactions don't need to be signed, but we still have to insert
     # the ScriptSig that will satisfy the ScriptPubKey.
     for inp in tx.vin:
@@ -87,6 +88,7 @@ def split_inputs(from_node, txins, txouts, initial_split=False):
     rem_change = prevtxout["amount"] - half_change - Decimal("0.00001000")
     tx.vout.append(CTxOut(int(half_change * COIN), P2SH_1))
     tx.vout.append(CTxOut(int(rem_change * COIN), P2SH_2))
+    tx.vout.append(CTxOut(int(0.00001*COIN))) # fee
 
     # If this is the initial split we actually need to sign the transaction
     # Otherwise we just need to insert the proper ScriptSig
@@ -153,13 +155,15 @@ def transact_and_mine(self, numblocks, mining_node):
         # resorting to tx's that depend on the mempool when those run out
         for i in range(numblocks):
             random.shuffle(self.confutxo)
-            for j in range(random.randrange(100 - 50, 100 + 50)):
+            # ELEMENTS: make fewer txns since larger: ~236 bytes: 69k/4/234=~73
+            # Pick a number smaller than that, stingy miner is even stingier
+            for j in range(random.randrange(55 - 15, 55 + 15)):
                 from_index = random.randint(1, 2)
                 (txhex, fee) = small_txpuzzle_randfee(self.nodes[from_index], self.confutxo,
                                                       self.memutxo, Decimal("0.005"), min_fee, min_fee)
                 tx_kbytes = (len(txhex) // 2) / 1000.0
                 self.fees_per_kb.append(float(fee) / tx_kbytes)
-            sync_mempools(self.nodes[0:3], wait=.1)
+            sync_mempools(self.nodes[0:3], wait=10, timeout=240) # Slower to sync than btc
             mined = mining_node.getblock(mining_node.generate(1)[0], True)["tx"]
             sync_blocks(self.nodes[0:3], wait=.1)
             # update which txouts are confirmed
diff --git a/test/functional/feature_initial_reissuance_token.py b/test/functional/feature_initial_reissuance_token.py
new file mode 100755
index 0000000000000..7b1336217c852
--- /dev/null
+++ b/test/functional/feature_initial_reissuance_token.py
@@ -0,0 +1,84 @@
+#!/usr/bin/env python3
+# Copyright (c) 2014-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.
+
+#
+# Test chain initialisation when specifying number of reissuance tokens to issue.
+#
+
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import connect_nodes_bi, assert_equal
+
+class InitialReissuanceTokenTest(BitcoinTestFramework):
+    """
+    Test creation of initial reissuance token for default asset on chain set up
+
+    """
+
+    def set_test_params(self):
+        self.setup_clean_chain = True
+        self.num_nodes = 2
+
+        #Set number of initial reissuance tokens and also set initial free coins less than max so we can reissue more later
+        self.extra_args = [["-initialreissuancetokens=200000000", "-initialfreecoins=2000000000000000", "-anyonecanspendaremine=1", "-con_connect_coinbase=1", "-con_blocksubsidy=0", "-blindedaddresses=1"]]*2
+
+    def setup_network(self, split=False):
+        self.setup_nodes()
+        connect_nodes_bi(self.nodes, 0, 1)
+        self.is_network_split = False
+        self.sync_all()
+
+    def run_test(self):
+        self.nodes[0].generate(101)
+        self.sync_all()
+
+        walletinfo = self.nodes[0].getwalletinfo()
+        balance = walletinfo['balance']
+        token = ""
+
+        #Get the hex of the reissuance token
+        for i in balance:
+            token = i
+            if token != "bitcoin":
+                break
+
+        # Claim all anyone-can-spend reissuance tokens, which also blinds the token output
+        # which is required for re-issuance: https://github.com/ElementsProject/elements/issues/259
+        self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), 2, "", "", False, False, 6, "UNSET", token)
+        self.nodes[0].generate(101)
+        self.sync_all()
+
+        #Check balances
+        walletinfo1 = self.nodes[0].getwalletinfo()
+        assert_equal(walletinfo1["balance"]["bitcoin"], 20000000)
+        assert_equal(walletinfo1["balance"][token], 2)
+
+        #Reissue some of the default asset
+        self.nodes[0].reissueasset("bitcoin", 1234)
+        self.nodes[0].generate(101)
+        self.sync_all()
+
+        #Check the reissuance worked
+        walletinfo1 = self.nodes[0].getwalletinfo()
+        assert_equal(walletinfo1["balance"]["bitcoin"], 20001234)
+
+        #Send some 'bitcoin' to node 2 so they can fund a reissuance transaction
+        self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 1, "", "", False)
+
+        #Send a reissuance token to node 2 so they can reissue the default asset
+        self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 1, "", "", False, False, 6, "UNSET", token)
+        self.nodes[0].generate(101)
+        self.sync_all()
+
+        #Reissue some of the default asset
+        self.nodes[1].reissueasset("bitcoin", 1000)
+        self.nodes[1].generate(101)
+        self.sync_all()
+
+        #Check balance is the 1 'bitcoin' sent from node 1 plus the 1000 'bitcoin' reissued by node 2
+        walletinfo2 = self.nodes[1].getwalletinfo()
+        assert_equal(walletinfo2["balance"]["bitcoin"], 1001)
+
+if __name__ == '__main__':
+    InitialReissuanceTokenTest().main()
diff --git a/test/functional/feature_issuance.py b/test/functional/feature_issuance.py
new file mode 100755
index 0000000000000..7ffe8641f0239
--- /dev/null
+++ b/test/functional/feature_issuance.py
@@ -0,0 +1,441 @@
+#!/usr/bin/env python3
+# Copyright (c) 2016 The Bitcoin Core developers
+# Distributed under the MIT/X11 software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import assert_equal, assert_greater_than_or_equal, assert_raises_rpc_error, connect_nodes_bi
+from test_framework.authproxy import JSONRPCException
+from decimal import Decimal
+
+" Tests issued assets functionality including (re)issuance, and de-issuance "
+
+# Creates a raw issuance transaction based on the passed in list, checking important details after
+def process_raw_issuance(node, issuance_list):
+    if len(issuance_list) > 5:
+        raise Exception('Issuance list too long')
+    # Make enough outputs for any subsequent spend
+    next_destinations = {}
+    output_values = (node.getbalance()['bitcoin']-1)/5
+    for i in range(5):
+        next_destinations[node.getnewaddress()] = output_values
+
+    raw_tx = node.createrawtransaction([], next_destinations)
+    # We "over-fund" these transactions to 50 sat/vbyte since issuances aren't baked in yet
+    # Otherwise huge multi-issuances may fail min-relay
+    funded_tx = node.fundrawtransaction(raw_tx, {"feeRate":Decimal('0.00050000')})['hex']
+    issued_call_details = node.rawissueasset(funded_tx, issuance_list)
+    issued_tx = issued_call_details[-1]["hex"] # Get hex from end
+    # don't accept blinding fail, and blind all issuances or none at all
+    blind_tx = node.blindrawtransaction(issued_tx, False, [], issuance_list[0]["blind"])
+    signed_tx = node.signrawtransactionwithwallet(blind_tx)
+    tx_id = node.sendrawtransaction(signed_tx['hex'])
+    node.generate(1)
+    assert_equal(node.gettransaction(tx_id)["confirmations"], 1)
+    num_issuance = 0
+    decoded_tx = node.decoderawtransaction(signed_tx['hex'])
+    decoded_unblind_tx = node.decoderawtransaction(issued_tx)
+    for i, (issuance_req, tx_input, issuance_result) in enumerate(zip(issuance_list, decoded_tx["vin"], issued_call_details)):
+        if "issuance" not in tx_input:
+            break
+
+        num_issuance += 1
+        issuance_details = tx_input["issuance"]
+        if "blind" not in issuance_req or issuance_req["blind"] == True:
+
+            assert("assetamount" not in issuance_details)
+            assert("tokenamount" not in issuance_details)
+            assert_equal(issuance_details["assetBlindingNonce"], "00"*32)
+            if "asset_amount" in issuance_req:
+                assert("assetamountcommitment" in issuance_details)
+            if "token_amount" in issuance_req:
+                assert("tokenamountcommitment" in issuance_details)
+        else:
+            if "asset_amount" in issuance_req:
+                assert_equal(issuance_details["assetamount"], issuance_req["asset_amount"])
+            if "token_amount" in issuance_req:
+                assert_equal(issuance_details["tokenamount"], issuance_req["token_amount"])
+
+        # Cross-check RPC call result details with raw details
+        assert_equal(issuance_result["vin"], i)
+        assert_equal(issuance_result["entropy"], issuance_details["assetEntropy"])
+        if "asset" in issuance_details:
+            assert_equal(issuance_result["asset"], issuance_details["asset"])
+        if "token" in issuance_details:
+            assert_equal(issuance_result["token"], issuance_details["token"])
+
+        # Look for outputs assets where we expect them, or not, initial issuance first then token
+        for issuance_type in ["asset", "token"]:
+            blind_dest = issuance_type+"_address" not in issuance_req or node.validateaddress(issuance_req[issuance_type+"_address"])["confidential_key"] != ""
+            if blind_dest:
+                # We should not find any the issuances we made since the addresses confidential
+                for output in decoded_tx["vout"]:
+                    if "asset" in output and output["asset"] == issuance_details[issuance_type]:
+                        raise Exception("Found asset in plaintext that should be confidential!")
+
+            # Now scan unblinded version of issuance outputs
+            asset_found = False
+            for output in decoded_unblind_tx["vout"]:
+                if "asset" in output and output["asset"] == issuance_details[issuance_type]:
+                    if issuance_type+"_address" not in issuance_req:
+                        raise Exception("Found asset type not requested")
+                    if "value" in output and output["value"] == issuance_req[issuance_type+"_amount"]:
+                        asset_found = True
+
+            # Find the asset type if it was created
+            assert(asset_found if issuance_type+"_address" in issuance_req else True)
+
+    assert_equal(num_issuance, len(issuance_list))
+
+class IssuanceTest(BitcoinTestFramework):
+
+    def set_test_params(self):
+        self.num_nodes = 3
+        self.extra_args = [["-blindedaddresses=1"]] * self.num_nodes
+        self.setup_clean_chain = True
+
+    def setup_network(self, split=False):
+        self.setup_nodes()
+        connect_nodes_bi(self.nodes, 0, 1)
+        connect_nodes_bi(self.nodes, 1, 2)
+        self.is_network_split = False
+        self.sync_all()
+
+    def run_test(self):
+        self.nodes[0].generate(105)
+        # Make sure test starts with no initial issuance.
+        assert_equal(len(self.nodes[0].listissuances()), 0)
+
+        # Unblinded issuance of asset
+        issued = self.nodes[0].issueasset(1, 1, False)
+        balance = self.nodes[0].getwalletinfo()["balance"]
+        assert_equal(balance[issued["asset"]], 1)
+        assert_equal(balance[issued["token"]], 1)
+        # Quick unblinded reissuance check, making 2*COIN total
+        self.nodes[0].reissueasset(issued["asset"], 1)
+
+        self.nodes[0].generate(1)
+        self.sync_all()
+
+        issued2 = self.nodes[0].issueasset(2, 1)
+        test_asset = issued2["asset"]
+        assert_equal(self.nodes[0].getwalletinfo()['balance'][test_asset], Decimal(2))
+        node1balance = self.nodes[1].getwalletinfo()['balance']
+        if test_asset in node1balance:
+            assert_equal(node1balance[test_asset], Decimal(0))
+
+        # Send bitcoin to node 1 and then from 1 to 2 to force node 1 to
+        # spend confidential money.
+        self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 4)
+        self.nodes[0].generate(1)
+        self.sync_all()
+        self.nodes[1].sendtoaddress(self.nodes[2].getnewaddress(), 3, "", "", False, False, 1, "UNSET", "", False)
+        self.sync_all()
+        self.nodes[0].generate(1)
+        self.sync_all()
+
+        # Destroy assets
+        pre_destroy_btc_balance = self.nodes[2].getwalletinfo()['balance']['bitcoin']
+        self.nodes[2].destroyamount('bitcoin', 2) # Destroy 2 BTC
+        self.nodes[2].generate(1)
+        self.sync_all()
+        assert_greater_than_or_equal(pre_destroy_btc_balance - Decimal('2'), self.nodes[2].getbalance()['bitcoin'])
+
+        issuedamount = self.nodes[0].getwalletinfo()['balance'][issued["token"]]
+        assert_equal(issuedamount, Decimal('1.0'))
+        self.nodes[0].destroyamount(issued["token"], issuedamount) # Destroy all reissuance tokens of one type
+
+        self.nodes[0].generate(1)
+        self.sync_all()
+        assert(issued["token"] not in self.nodes[0].getwalletinfo()['balance'])
+
+        # Test various issuance and auditing paths
+
+        issuancedata = self.nodes[0].issueasset(Decimal('0.00000002'), Decimal('0.00000001')) #2 of asset, 1 reissuance token
+        self.nodes[1].generate(1)
+        self.sync_all()
+        assert_equal(self.nodes[0].getwalletinfo()["balance"][issuancedata["asset"]], Decimal('0.00000002'))
+        assert_equal(self.nodes[0].getwalletinfo()["balance"][issuancedata["token"]], Decimal('0.00000001'))
+        self.nodes[0].reissueasset(issuancedata["asset"], Decimal('0.00000001'))
+        self.sync_all()
+        assert_equal(self.nodes[0].getwalletinfo()["balance"][issuancedata["asset"]], Decimal('0.00000003'))
+        # Can't reissue an issuance token (yet)
+        try:
+            self.nodes[0].reissueasset(issuancedata["token"], Decimal('0.00000001'))
+            raise AssertionError("You shouldn't be able to reissue a token yet")
+        except JSONRPCException:
+            pass
+
+
+        issuancedata = self.nodes[2].issueasset(Decimal('0.00000005'), 0) #5 of asset, 0 reissuance token
+        # No reissuance tokens
+        try:
+            self.nodes[2].reissueasset(issuancedata["token"], 5)
+            raise AssertionError("You shouldn't be able to reissue without a token")
+        except JSONRPCException:
+            pass
+
+        issuancedata = self.nodes[2].issueasset(0, Decimal('0.00000006')) #0 of asset, 6 reissuance token
+
+        # Node 2 will send node 1 a reissuance token, both will generate assets
+        self.nodes[2].sendtoaddress(self.nodes[1].getnewaddress(), Decimal('0.00000001'), "", "", False, False, 1, "UNSET", issuancedata["token"])
+        # node 1 needs to know about a (re)issuance to reissue itself
+        self.nodes[1].importaddress(self.nodes[2].gettransaction(issuancedata["txid"])["details"][0]["address"])
+        # also send some bitcoin
+        self.nodes[2].generate(1)
+        self.sync_all()
+
+        assert_equal(self.nodes[2].getwalletinfo()["balance"][issuancedata["token"]], Decimal('0.00000005'))
+        assert_equal(self.nodes[1].getwalletinfo()["balance"][issuancedata["token"]], Decimal('0.00000001'))
+        redata1 = self.nodes[1].reissueasset(issuancedata["asset"], Decimal('0.05'))
+        redata2 = self.nodes[2].reissueasset(issuancedata["asset"], Decimal('0.025'))
+
+        self.sync_all()
+        # Watch-only issuances won't show up in wallet until confirmed
+        self.nodes[1].generate(1)
+        self.sync_all()
+
+        # Now have node 0 audit these issuances
+        blindingkey1 = self.nodes[1].dumpissuanceblindingkey(redata1["txid"], redata1["vin"])
+        blindingkey2 = self.nodes[2].dumpissuanceblindingkey(redata2["txid"], redata2["vin"])
+        blindingkey3 = self.nodes[2].dumpissuanceblindingkey(issuancedata["txid"], issuancedata["vin"])
+
+        # Need addr to get transactions in wallet. TODO: importissuances?
+        txdet1 = self.nodes[1].gettransaction(redata1["txid"])["details"]
+        txdet2 = self.nodes[2].gettransaction(redata2["txid"])["details"]
+        txdet3 = self.nodes[2].gettransaction(issuancedata["txid"])["details"]
+
+        # Receive addresses added last
+        addr1 = txdet1[len(txdet1)-1]["address"]
+        addr2 = txdet2[len(txdet2)-1]["address"]
+        addr3 = txdet3[len(txdet3)-1]["address"]
+
+        assert_equal(len(self.nodes[0].listissuances()), 5)
+        self.nodes[0].importaddress(addr1)
+        self.nodes[0].importaddress(addr2)
+        self.nodes[0].importaddress(addr3)
+
+        issuances = self.nodes[0].listissuances()
+        assert_equal(len(issuances), 8)
+
+        for issue in issuances:
+            if issue['txid'] == redata1["txid"] and issue['vin'] == redata1["vin"]:
+                assert_equal(issue['assetamount'], Decimal('-1'))
+            if issue['txid'] == redata2["txid"] and issue['vin'] == redata2["vin"]:
+                assert_equal(issue['assetamount'], Decimal('-1'))
+            if issue['txid'] == issuancedata["txid"] and issue['vin'] == issuancedata["vin"]:
+                assert_equal(issue['assetamount'], Decimal('-1'))
+                assert_equal(issue['tokenamount'], Decimal('-1'))
+
+        # Test that importing the issuance blinding keys then reveals the issuance amounts
+        self.nodes[0].importissuanceblindingkey(redata1["txid"], redata1["vin"], blindingkey1)
+        self.nodes[0].importissuanceblindingkey(redata2["txid"], redata2["vin"], blindingkey2)
+        self.nodes[0].importissuanceblindingkey(issuancedata["txid"], issuancedata["vin"], blindingkey3)
+
+        issuances = self.nodes[0].listissuances()
+
+        for issue in issuances:
+            if issue['txid'] == redata1["txid"] and issue['vin'] == redata1["vin"]:
+                assert_equal(issue['assetamount'], Decimal('0.05'))
+            if issue['txid'] == redata2["txid"] and issue['vin'] == redata2["vin"]:
+                assert_equal(issue['assetamount'], Decimal('0.025'))
+            if issue['txid'] == issuancedata["txid"] and issue['vin'] == issuancedata["vin"]:
+                assert_equal(issue['assetamount'], Decimal('0'))
+                assert_equal(issue['tokenamount'], Decimal('0.00000006'))
+
+        # Check for value accounting when asset issuance is null but token not, ie unblinded
+        issued = self.nodes[0].issueasset(0, 1, False)
+        assert(issued["asset"] not in self.nodes[0].getwalletinfo()["balance"])
+        assert_equal(self.nodes[0].getwalletinfo()["balance"][issued["token"]], 1)
+
+
+        print("Raw issuance tests")
+        # Addresses to send to to check proper blinding
+        blind_addr = self.nodes[0].getnewaddress()
+        nonblind_addr = self.nodes[0].validateaddress(blind_addr)['unconfidential']
+
+        # Fail making non-witness issuance sourcing a single unblinded output.
+        # See: https://github.com/ElementsProject/elements/issues/473
+        total_amount = self.nodes[0].getbalance()['bitcoin']
+        self.nodes[0].sendtoaddress(nonblind_addr, total_amount, "", "", True)
+        self.nodes[1].generate(1)
+        raw_tx = self.nodes[0].createrawtransaction([], {nonblind_addr: 1})
+        funded_tx = self.nodes[0].fundrawtransaction(raw_tx)['hex']
+        issued_tx = self.nodes[2].rawissueasset(funded_tx, [{"asset_amount":1, "asset_address":nonblind_addr, "blind":False}])[0]["hex"]
+        blind_tx = self.nodes[0].blindrawtransaction(issued_tx) # This is a no-op
+        signed_tx = self.nodes[0].signrawtransactionwithwallet(blind_tx)
+        assert_raises_rpc_error(-26, "", self.nodes[0].sendrawtransaction, signed_tx['hex'])
+
+        # Make single blinded output to ensure we work around above issue
+        total_amount = self.nodes[0].getbalance()['bitcoin']
+        self.nodes[0].sendtoaddress(blind_addr, total_amount, "", "", True)
+        self.nodes[1].generate(1)
+
+        # Start with single issuance input, unblinded (makes 5 outputs for later larger issuances)
+        process_raw_issuance(self.nodes[0], [{"asset_amount": 2, "asset_address": nonblind_addr, "blind": False}])
+        process_raw_issuance(self.nodes[0], [{"asset_amount": 2, "asset_address": nonblind_addr, "blind": True}])
+        process_raw_issuance(self.nodes[0], [{"token_amount": 5, "token_address": nonblind_addr, "blind": False}])
+        process_raw_issuance(self.nodes[0], [{"asset_amount": 7, "asset_address": nonblind_addr, "token_amount":2, "token_address":nonblind_addr, "blind":False}])
+        process_raw_issuance(self.nodes[0], [{"asset_amount": 7, "asset_address": nonblind_addr, "token_amount":2, "token_address":blind_addr, "blind":False}])
+        process_raw_issuance(self.nodes[0], [{"asset_amount": 7, "asset_address": blind_addr, "token_amount":2, "token_address":nonblind_addr, "blind":False}])
+        process_raw_issuance(self.nodes[0], [{"asset_amount": 7, "asset_address": blind_addr, "token_amount":2, "token_address":blind_addr, "blind":False}])
+        # Now do multiple with some issuance outputs blind, some unblinded
+        process_raw_issuance(self.nodes[0], [{"asset_amount": 7, "asset_address": nonblind_addr, "token_amount":2, "token_address":nonblind_addr, "blind":False}, {"asset_amount":2, "asset_address":nonblind_addr, "blind":False}])
+        process_raw_issuance(self.nodes[0], [{"asset_amount": 7, "asset_address": blind_addr, "token_amount":2, "token_address":nonblind_addr, "blind":False}, {"asset_amount":2, "asset_address":nonblind_addr, "blind":False}])
+        # Up to 5 issuances since we're making 5 outputs each time
+        process_raw_issuance(self.nodes[0], [{"asset_amount": 7, "asset_address": nonblind_addr, "token_amount":2, "token_address":blind_addr, "blind":False}, {"asset_amount":2, "asset_address":nonblind_addr, "blind":False}])
+        process_raw_issuance(self.nodes[0], [{"asset_amount": 1, "asset_address": nonblind_addr, "token_amount":2, "token_address":blind_addr, "blind":False}, {"asset_amount":3, "asset_address":nonblind_addr, "blind":False}, {"asset_amount":4, "asset_address":nonblind_addr, "token_amount":5, "token_address":blind_addr, "blind":False}, {"asset_amount":6, "asset_address":nonblind_addr, "token_amount":7, "token_address":blind_addr, "blind":False}, {"asset_amount":8, "asset_address":nonblind_addr, "token_amount":9, "token_address":blind_addr, "blind":False}])
+        # Default "blind" value is true, omitting explicit argument for last
+        process_raw_issuance(self.nodes[0], [{"asset_amount": 1, "asset_address": nonblind_addr, "token_amount":2, "token_address":blind_addr, "blind":True}, {"asset_amount":3, "asset_address":nonblind_addr, "blind":True}, {"asset_amount":4, "asset_address":nonblind_addr, "token_amount":5, "token_address":blind_addr, "blind":True}, {"asset_amount":6, "asset_address":nonblind_addr, "token_amount":7, "token_address":blind_addr, "blind":True}, {"asset_amount":8, "asset_address":nonblind_addr, "token_amount":9, "token_address":blind_addr}])
+
+        # Make sure contract hash is being interpreted as expected, resulting in different asset ids
+        raw_tx = self.nodes[0].createrawtransaction([], {nonblind_addr:self.nodes[0].getbalance()['bitcoin']-1})
+        funded_tx = self.nodes[0].fundrawtransaction(raw_tx)['hex']
+        id_set = set()
+
+        # First issue an asset with no argument
+        issued_tx = self.nodes[2].rawissueasset(funded_tx, [{"asset_amount":1, "asset_address":nonblind_addr}])[0]["hex"]
+        decode_tx = self.nodes[0].decoderawtransaction(issued_tx)
+        id_set.add(decode_tx["vin"][0]["issuance"]["asset"])
+
+        # Again with 00..00 argument, which match the no-argument case
+        issued_tx = self.nodes[2].rawissueasset(funded_tx, [{"asset_amount":1, "asset_address":nonblind_addr, "contract_hash":"00"*32}])[0]["hex"]
+        decode_tx = self.nodes[0].decoderawtransaction(issued_tx)
+        id_set.add(decode_tx["vin"][0]["issuance"]["asset"])
+        assert_equal(len(id_set), 1)
+
+        # Random contract string should again differ
+        issued_tx = self.nodes[2].rawissueasset(funded_tx, [{"asset_amount":1, "asset_address":nonblind_addr, "contract_hash":"deadbeef"*8}])[0]["hex"]
+        decode_tx = self.nodes[0].decoderawtransaction(issued_tx)
+        id_set.add(decode_tx["vin"][0]["issuance"]["asset"])
+        assert_equal(len(id_set), 2)
+        issued_tx = self.nodes[2].rawissueasset(funded_tx, [{"asset_amount":1, "asset_address":nonblind_addr, "contract_hash":"deadbeee"*8}])[0]["hex"]
+        decode_tx = self.nodes[0].decoderawtransaction(issued_tx)
+        id_set.add(decode_tx["vin"][0]["issuance"]["asset"])
+        assert_equal(len(id_set), 3)
+
+        # Finally, append an issuance on top of an already-"issued" raw tx
+        # Same contract, different utxo being spent results in new asset type
+        # We also create a reissuance token to test reissuance with contract hash
+        issued_tx = self.nodes[2].rawissueasset(issued_tx, [{"asset_amount":1, "asset_address":nonblind_addr, "token_address":nonblind_addr, "contract":"deadbeee"*8}])[0]["hex"]
+        decode_tx = self.nodes[0].decoderawtransaction(issued_tx)
+        id_set.add(decode_tx["vin"][1]["issuance"]["asset"])
+        assert_equal(len(id_set), 4)
+        # This issuance should not have changed
+        id_set.add(decode_tx["vin"][0]["issuance"]["asset"])
+        assert_equal(len(id_set), 4)
+
+        print("Raw reissuance tests")
+        issued_asset = self.nodes[0].issueasset(0, 1)
+        self.nodes[0].generate(1)
+        utxo_info = None
+        # Find info about the token output using wallet
+        for utxo in self.nodes[0].listunspent():
+            if utxo["asset"] == issued_asset["token"]:
+                utxo_info = utxo
+                break
+        assert(utxo_info is not None)
+
+        issued_address = self.nodes[0].getnewaddress()
+        # Create transaction spending the reissuance token
+        raw_tx = self.nodes[0].createrawtransaction([], {issued_address:Decimal('0.00000001')}, 0, False, {issued_address:issued_asset["token"]})
+        funded_tx = self.nodes[0].fundrawtransaction(raw_tx)['hex']
+        # Find the reissuance input
+        reissuance_index = -1
+        for i, tx_input in enumerate(self.nodes[0].decoderawtransaction(funded_tx)["vin"]):
+            if tx_input["txid"] == utxo_info["txid"] and tx_input["vout"] == utxo_info["vout"]:
+                reissuance_index = i
+                break
+        assert(reissuance_index != -1)
+        reissued_tx = self.nodes[0].rawreissueasset(funded_tx, [{"asset_amount":3, "asset_address":self.nodes[0].getnewaddress(), "input_index":reissuance_index, "asset_blinder":utxo_info["assetblinder"], "entropy":issued_asset["entropy"]}])
+        blind_tx = self.nodes[0].blindrawtransaction(reissued_tx["hex"])
+        signed_tx = self.nodes[0].signrawtransactionwithwallet(blind_tx)
+        tx_id = self.nodes[0].sendrawtransaction(signed_tx["hex"])
+        self.nodes[0].generate(1)
+        assert_equal(self.nodes[0].gettransaction(tx_id)["confirmations"], 1)
+
+        # Now send reissuance token to blinded multisig, then reissue
+        addrs = []
+        for i in range(3):
+            addrs.append(self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress())["pubkey"])
+
+
+        multisig_addr = self.nodes[0].addmultisigaddress(2,addrs)
+        blinded_addr = self.nodes[0].getnewaddress()
+        blinding_pubkey = self.nodes[0].validateaddress(blinded_addr)["confidential_key"]
+        blinding_privkey = self.nodes[0].dumpblindingkey(blinded_addr)
+        blinded_multisig = self.nodes[0].createblindedaddress(multisig_addr["address"], blinding_pubkey)
+        # Import blinding key to be able to decrypt values sent to it
+        self.nodes[0].importblindingkey(blinded_multisig, blinding_privkey)
+        # Sending to this address must achieve blinding to reissue from this address
+        self.nodes[0].sendtoaddress(blinded_multisig, self.nodes[0].getbalance()[issued_asset["token"]], "", "", False, False, 1, "UNSET", issued_asset["token"], False)
+        self.nodes[0].generate(1)
+
+        # Get that multisig output
+        utxo_info = None
+        # Find info about the token output using wallet
+        for utxo in self.nodes[0].listunspent():
+            if utxo["asset"] == issued_asset["token"]:
+                utxo_info = utxo
+                assert_equal(blinded_multisig, self.nodes[0].getaddressinfo(utxo_info["address"])["confidential"])
+                break
+        assert(utxo_info is not None)
+        assert(utxo_info["amountblinder"] is not "0000000000000000000000000000000000000000000000000000000000000000")
+
+        # Now make transaction spending that input
+        raw_tx = self.nodes[0].createrawtransaction([], {issued_address:1}, 0, False, {issued_address:issued_asset["token"]})
+        funded_tx = self.nodes[0].fundrawtransaction(raw_tx)["hex"]
+        # Find the reissuance input
+        reissuance_index = -1
+        for i, tx_input in enumerate(self.nodes[0].decoderawtransaction(funded_tx)["vin"]):
+            if tx_input["txid"] == utxo_info["txid"] and tx_input["vout"] == utxo_info["vout"]:
+                reissuance_index = i
+                break
+        assert(reissuance_index != -1)
+        reissued_tx = self.nodes[0].rawreissueasset(funded_tx, [{"asset_amount":3, "asset_address":self.nodes[0].getnewaddress(), "input_index":reissuance_index, "asset_blinder":utxo_info["assetblinder"], "entropy":issued_asset["entropy"]}])
+
+        blind_tx = self.nodes[0].blindrawtransaction(reissued_tx["hex"])
+        signed_tx = self.nodes[0].signrawtransactionwithwallet(blind_tx)
+        tx_id = self.nodes[0].sendrawtransaction(signed_tx["hex"])
+        self.nodes[0].generate(1)
+        assert_equal(self.nodes[0].gettransaction(tx_id)["confirmations"], 1)
+
+        # Now make transaction spending a token that had non-null contract_hash
+        contract_hash = "deadbeee"*8
+        raw_tx = self.nodes[0].createrawtransaction([], {self.nodes[0].getnewaddress():1})
+        funded_tx = self.nodes[0].fundrawtransaction(raw_tx)["hex"]
+        issued_tx = self.nodes[0].rawissueasset(funded_tx, [{"token_amount":1, "token_address":self.nodes[0].getnewaddress(), "contract_hash":contract_hash}])[0]
+        blinded_tx = self.nodes[0].blindrawtransaction(issued_tx["hex"])
+        signed_tx = self.nodes[0].signrawtransactionwithwallet(blinded_tx)
+        tx_id = self.nodes[0].sendrawtransaction(signed_tx["hex"])
+        self.nodes[0].generate(1)
+        assert_equal(self.nodes[0].gettransaction(tx_id)["confirmations"], 1)
+
+        utxo_info = None
+        # Find info about the token output using wallet
+        for utxo in self.nodes[0].listunspent():
+            if utxo["asset"] == issued_tx["token"]:
+                utxo_info = utxo
+                break
+        assert(utxo_info is not None)
+
+        # Now spend the token, and create reissuance
+        raw_tx = self.nodes[0].createrawtransaction([], {issued_address:1}, 0, False, {issued_address:issued_tx["token"]})
+        funded_tx = self.nodes[0].fundrawtransaction(raw_tx)["hex"]
+        # Find the reissuance input
+        reissuance_index = -1
+        for i, tx_input in enumerate(self.nodes[0].decoderawtransaction(funded_tx)["vin"]):
+            if tx_input["txid"] == utxo_info["txid"] and tx_input["vout"] == utxo_info["vout"]:
+                reissuance_index = i
+                break
+        assert(reissuance_index != -1)
+        reissued_tx = self.nodes[0].rawreissueasset(funded_tx, [{"asset_amount":3, "asset_address":self.nodes[0].getnewaddress(), "input_index":reissuance_index, "asset_blinder":utxo_info["assetblinder"], "entropy":issued_tx["entropy"]}])
+
+        blind_tx = self.nodes[0].blindrawtransaction(reissued_tx["hex"], False)
+        signed_tx = self.nodes[0].signrawtransactionwithwallet(blind_tx)
+        tx_id = self.nodes[0].sendrawtransaction(signed_tx["hex"])
+        self.nodes[0].generate(1)
+        assert_equal(self.nodes[0].gettransaction(tx_id)["confirmations"], 1)
+
+if __name__ == '__main__':
+    IssuanceTest ().main ()
diff --git a/test/functional/feature_mandatory_coinbase.py b/test/functional/feature_mandatory_coinbase.py
index 64f76b04cf0b3..3c2cce30abd22 100755
--- a/test/functional/feature_mandatory_coinbase.py
+++ b/test/functional/feature_mandatory_coinbase.py
@@ -7,7 +7,8 @@
 from binascii import b2a_hex
 
 from test_framework.blocktools import create_coinbase
-from test_framework.messages import CBlock, CProof
+from test_framework.messages import CBlock, CProof, CTxOutValue, CTxOut
+from test_framework.script import CScript, OP_RETURN
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal, assert_raises_rpc_error
 
@@ -72,11 +73,38 @@ def run_test(self):
 
         self.log.info("getblocktemplate: Test non-subsidy block on both nodes")
         # Without block reward anything goes, this allows commitment outputs like segwit
-        coinbase_tx.vout[0].nValue = 0
+        coinbase_tx.vout[0].nValue = CTxOutValue(0)
+        coinbase_tx.vout[0].scriptPubKey = CScript([OP_RETURN, b'\xff'])
         coinbase_tx.rehash()
         block.vtx = [coinbase_tx]
         assert_template(node0, block, None)
         assert_template(node1, block, None)
 
+        #
+        # Also test that coinbases can't have fees.
+        self.sync_all()
+        tmpl = node1.getblocktemplate()
+        coinbase_tx = create_coinbase(height=int(tmpl["height"]))
+        # sequence numbers must not be max for nLockTime to have effect
+        coinbase_tx.vin[0].nSequence = 2 ** 32 - 2
+        # Add fee output.
+        coinbase_tx.vout[0].nValue.setToAmount(coinbase_tx.vout[0].nValue.getAmount() - 1)
+        coinbase_tx.vout.append(CTxOut(1))
+        coinbase_tx.rehash()
+        block = CBlock()
+        block.nVersion = tmpl["version"]
+        block.hashPrevBlock = int(tmpl["previousblockhash"], 16)
+        block.nTime = tmpl["curtime"]
+        block.nBits = int(tmpl["bits"], 16)
+        block.nNonce = 0
+        block.proof = CProof(bytearray.fromhex('51'))
+        block.vtx = [coinbase_tx]
+        block.block_height = int(tmpl["height"])
+        block.hashMerkleRoot = block.calc_merkle_root()
+
+        # should not be accepted
+        assert_template(node0, block, "bad-cb-fee")
+        assert_template(node1, block, "bad-cb-fee")
+
 if __name__ == '__main__':
     MandatoryCoinbaseTest().main()
diff --git a/test/functional/feature_nulldummy.py b/test/functional/feature_nulldummy.py
index fe601e91fb02e..c46da5496b72c 100755
--- a/test/functional/feature_nulldummy.py
+++ b/test/functional/feature_nulldummy.py
@@ -66,16 +66,18 @@ def run_test(self):
         self.lastblocktime = int(time.time()) + 429
 
         self.log.info("Test 1: NULLDUMMY compliant base transactions should be accepted to mempool and mined before activation [430]")
-        test1txs = [create_transaction(self.nodes[0], coinbase_txid[0], self.ms_address, amount=49)]
+        coinbase_value = self.nodes[0].decoderawtransaction(self.nodes[0].gettransaction(coinbase_txid[0])["hex"])["vout"][0]["value"]
+        test1txs = [create_transaction(self.nodes[0], coinbase_txid[0], self.ms_address, amount=49, fee=coinbase_value-49)]
         txid1 = self.nodes[0].sendrawtransaction(bytes_to_hex_str(test1txs[0].serialize_with_witness()), True)
-        test1txs.append(create_transaction(self.nodes[0], txid1, self.ms_address, amount=48))
+        test1txs.append(create_transaction(self.nodes[0], txid1, self.ms_address, amount=48, fee=49-48))
         txid2 = self.nodes[0].sendrawtransaction(bytes_to_hex_str(test1txs[1].serialize_with_witness()), True)
-        test1txs.append(create_transaction(self.nodes[0], coinbase_txid[1], self.wit_ms_address, amount=49))
+        coinbase_value = self.nodes[0].decoderawtransaction(self.nodes[0].gettransaction(coinbase_txid[1])["hex"])["vout"][0]["value"]
+        test1txs.append(create_transaction(self.nodes[0], coinbase_txid[1], self.wit_ms_address, amount=49, fee=coinbase_value-49))
         txid3 = self.nodes[0].sendrawtransaction(bytes_to_hex_str(test1txs[2].serialize_with_witness()), True)
         self.block_submit(self.nodes[0], test1txs, False, True)
 
         self.log.info("Test 2: Non-NULLDUMMY base multisig transaction should not be accepted to mempool before activation")
-        test2tx = create_transaction(self.nodes[0], txid2, self.ms_address, amount=47)
+        test2tx = create_transaction(self.nodes[0], txid2, self.ms_address, amount=47, fee=48-47)
         trueDummy(test2tx)
         assert_raises_rpc_error(-26, NULLDUMMY_ERROR, self.nodes[0].sendrawtransaction, bytes_to_hex_str(test2tx.serialize_with_witness()), True)
 
@@ -83,14 +85,14 @@ def run_test(self):
         self.block_submit(self.nodes[0], [test2tx], False, True)
 
         self.log.info("Test 4: Non-NULLDUMMY base multisig transaction is invalid after activation")
-        test4tx = create_transaction(self.nodes[0], test2tx.hash, self.address, amount=46)
+        test4tx = create_transaction(self.nodes[0], test2tx.hash, self.address, amount=46, fee=47-46)
         test6txs=[CTransaction(test4tx)]
         trueDummy(test4tx)
         assert_raises_rpc_error(-26, NULLDUMMY_ERROR, self.nodes[0].sendrawtransaction, bytes_to_hex_str(test4tx.serialize_with_witness()), True)
         self.block_submit(self.nodes[0], [test4tx])
 
         self.log.info("Test 5: Non-NULLDUMMY P2WSH multisig transaction invalid after activation")
-        test5tx = create_transaction(self.nodes[0], txid3, self.wit_address, amount=48)
+        test5tx = create_transaction(self.nodes[0], txid3, self.wit_address, amount=48, fee=49-48)
         test6txs.append(CTransaction(test5tx))
         test5tx.wit.vtxinwit[0].scriptWitness.stack[0] = b'\x01'
         assert_raises_rpc_error(-26, NULLDUMMY_ERROR, self.nodes[0].sendrawtransaction, bytes_to_hex_str(test5tx.serialize_with_witness()), True)
diff --git a/test/functional/feature_pak.py b/test/functional/feature_pak.py
index 4a22efbe72f5c..6b19ab0aa69e5 100755
--- a/test/functional/feature_pak.py
+++ b/test/functional/feature_pak.py
@@ -264,7 +264,7 @@ def compare(actual, expected):
         pak1_pegout_txid = self.nodes[i_pak1].sendtomainchain("", 1)["txid"]
         assert_equal(self.nodes[i_pak1].getwalletpakinfo()["bip32_counter"], "1")
         # Also spend the change to make chained payment that will be rejected as well
-        pak1_child_txid = self.nodes[i_pak1].sendtoaddress(self.nodes[i_pak1].getnewaddress(), self.nodes[i_pak1].getbalance(), "", "", True)
+        pak1_child_txid = self.nodes[i_pak1].sendtoaddress(self.nodes[i_pak1].getnewaddress(), self.nodes[i_pak1].getbalance()['bitcoin'], "", "", True)
 
 
         # Wait for node("follow the leader" conf-undefined) to get transaction in
diff --git a/test/functional/feature_rbf.py b/test/functional/feature_rbf.py
index ff7c2b23bf8a6..cd7e3e6b9d4c9 100755
--- a/test/functional/feature_rbf.py
+++ b/test/functional/feature_rbf.py
@@ -6,10 +6,12 @@
 
 from decimal import Decimal
 
-from test_framework.messages import COIN, COutPoint, CTransaction, CTxIn, CTxOut
+from test_framework.messages import COIN, COutPoint, CTransaction, CTxIn, CTxOut, CTxOutValue
 from test_framework.script import CScript, OP_DROP
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import assert_equal, assert_raises_rpc_error, bytes_to_hex_str, satoshi_round
+from test_framework.util import assert_equal, assert_raises_rpc_error, bytes_to_hex_str, hex_str_to_bytes, satoshi_round
+
+from io import BytesIO
 
 MAX_REPLACEMENT_LIMIT = 100
 
@@ -25,23 +27,29 @@ def make_utxo(node, amount, confirmed=True, scriptPubKey=CScript([1])):
                 unconfirmed otherwise.
     """
     fee = 1*COIN
-    while node.getbalance() < satoshi_round((amount + fee)/COIN):
+    while node.getbalance()['bitcoin'] < satoshi_round((amount + fee)/COIN):
         node.generate(100)
 
     new_addr = node.getnewaddress()
-    txid = node.sendtoaddress(new_addr, satoshi_round((amount+fee)/COIN))
-    tx1 = node.getrawtransaction(txid, 1)
-    txid = int(txid, 16)
+    unblinded_addr = node.validateaddress(new_addr)["unconfidential"]
+    txidstr = node.sendtoaddress(new_addr, satoshi_round((amount+fee)/COIN))
+    tx1 = node.getrawtransaction(txidstr, 1)
+    txid = int(txidstr, 16)
     i = None
 
     for i, txout in enumerate(tx1['vout']):
-        if txout['scriptPubKey']['addresses'] == [new_addr]:
+        if txout['scriptPubKey']['type'] == "fee":
+            continue # skip fee outputs
+        if txout['scriptPubKey']['addresses'] == [unblinded_addr]:
             break
     assert i is not None
 
     tx2 = CTransaction()
     tx2.vin = [CTxIn(COutPoint(txid, i))]
-    tx2.vout = [CTxOut(amount, scriptPubKey)]
+    tx1raw = CTransaction()
+    tx1raw.deserialize(BytesIO(hex_str_to_bytes(node.getrawtransaction(txidstr))))
+    feeout = CTxOut(CTxOutValue(tx1raw.vout[i].nValue.getAmount() - amount))
+    tx2.vout = [CTxOut(amount, scriptPubKey), feeout]
     tx2.rehash()
 
     signed_tx = node.signrawtransactionwithwallet(txToHex(tx2))
@@ -132,9 +140,10 @@ def test_simple_doublespend(self):
         # transactions might not be accepted by our peers.
         self.sync_all()
 
+        feeout = CTxOut(int(0.1*COIN), CScript())
         tx1a = CTransaction()
         tx1a.vin = [CTxIn(tx0_outpoint, nSequence=0)]
-        tx1a.vout = [CTxOut(1 * COIN, CScript([b'a' * 35]))]
+        tx1a.vout = [CTxOut(1 * COIN, CScript([b'a' * 35])), feeout]
         tx1a_hex = txToHex(tx1a)
         tx1a_txid = self.nodes[0].sendrawtransaction(tx1a_hex, True)
 
@@ -143,7 +152,7 @@ def test_simple_doublespend(self):
         # Should fail because we haven't changed the fee
         tx1b = CTransaction()
         tx1b.vin = [CTxIn(tx0_outpoint, nSequence=0)]
-        tx1b.vout = [CTxOut(1 * COIN, CScript([b'b' * 35]))]
+        tx1b.vout = [CTxOut(1 * COIN, CScript([b'b' * 35])), feeout]
         tx1b_hex = txToHex(tx1b)
 
         # This will raise an exception due to insufficient fee
@@ -154,7 +163,7 @@ def test_simple_doublespend(self):
         # Extra 0.1 BTC fee
         tx1b = CTransaction()
         tx1b.vin = [CTxIn(tx0_outpoint, nSequence=0)]
-        tx1b.vout = [CTxOut(int(0.9 * COIN), CScript([b'b' * 35]))]
+        tx1b.vout = [CTxOut(int(0.9 * COIN), CScript([b'b' * 35])), feeout, feeout]
         tx1b_hex = txToHex(tx1b)
         # Replacement still disabled even with "enough fee"
         assert_raises_rpc_error(-26, "txn-mempool-conflict", self.nodes[1].sendrawtransaction, tx1b_hex, True)
@@ -186,7 +195,8 @@ def test_doublespend_chain(self):
             remaining_value -= 1*COIN
             tx = CTransaction()
             tx.vin = [CTxIn(prevout, nSequence=0)]
-            tx.vout = [CTxOut(remaining_value, CScript([1, OP_DROP] * 15 + [1]))]
+            feeout = CTxOut(1*COIN)
+            tx.vout = [CTxOut(remaining_value, CScript([1, OP_DROP] * 15 + [1])), feeout]
             tx_hex = txToHex(tx)
             txid = self.nodes[0].sendrawtransaction(tx_hex, True)
             chain_txids.append(txid)
@@ -196,7 +206,7 @@ def test_doublespend_chain(self):
         # child fees - 40 BTC - so this attempt is rejected.
         dbl_tx = CTransaction()
         dbl_tx.vin = [CTxIn(tx0_outpoint, nSequence=0)]
-        dbl_tx.vout = [CTxOut(initial_nValue - 30 * COIN, CScript([1] * 35))]
+        dbl_tx.vout = [CTxOut(initial_nValue - 30 * COIN, CScript([1] * 35)), CTxOut(30*COIN)]
         dbl_tx_hex = txToHex(dbl_tx)
 
         # This will raise an exception due to insufficient fee
@@ -205,7 +215,7 @@ def test_doublespend_chain(self):
         # Accepted with sufficient fee
         dbl_tx = CTransaction()
         dbl_tx.vin = [CTxIn(tx0_outpoint, nSequence=0)]
-        dbl_tx.vout = [CTxOut(1 * COIN, CScript([1] * 35))]
+        dbl_tx.vout = [CTxOut(1 * COIN, CScript([1] * 35)), CTxOut(49*COIN)]
         dbl_tx_hex = txToHex(dbl_tx)
         self.nodes[0].sendrawtransaction(dbl_tx_hex, True)
 
@@ -231,6 +241,7 @@ def branch(prevout, initial_value, max_txs, tree_width=5, fee=0.0001*COIN, _tota
 
             vout = [CTxOut(txout_value, CScript([i+1]))
                     for i in range(tree_width)]
+            vout.append(CTxOut(int(initial_value - tree_width*txout_value)))
             tx = CTransaction()
             tx.vin = [CTxIn(prevout, nSequence=0)]
             tx.vout = vout
@@ -244,6 +255,8 @@ def branch(prevout, initial_value, max_txs, tree_width=5, fee=0.0001*COIN, _tota
             txid = int(txid, 16)
 
             for i, txout in enumerate(tx.vout):
+                if txout.is_fee():
+                    continue
                 for x in branch(COutPoint(txid, i), txout_value,
                                   max_txs,
                                   tree_width=tree_width, fee=fee,
@@ -258,7 +271,7 @@ def branch(prevout, initial_value, max_txs, tree_width=5, fee=0.0001*COIN, _tota
         # Attempt double-spend, will fail because too little fee paid
         dbl_tx = CTransaction()
         dbl_tx.vin = [CTxIn(tx0_outpoint, nSequence=0)]
-        dbl_tx.vout = [CTxOut(initial_nValue - fee * n, CScript([1] * 35))]
+        dbl_tx.vout = [CTxOut(initial_nValue - fee * n, CScript([1] * 35)), CTxOut(fee*n)]
         dbl_tx_hex = txToHex(dbl_tx)
         # This will raise an exception due to insufficient fee
         assert_raises_rpc_error(-26, "insufficient fee", self.nodes[0].sendrawtransaction, dbl_tx_hex, True)
@@ -266,7 +279,7 @@ def branch(prevout, initial_value, max_txs, tree_width=5, fee=0.0001*COIN, _tota
         # 1 BTC fee is enough
         dbl_tx = CTransaction()
         dbl_tx.vin = [CTxIn(tx0_outpoint, nSequence=0)]
-        dbl_tx.vout = [CTxOut(initial_nValue - fee * n - 1 * COIN, CScript([1] * 35))]
+        dbl_tx.vout = [CTxOut(initial_nValue - fee * n - 1 * COIN, CScript([1] * 35)), CTxOut(fee*n+1*COIN)]
         dbl_tx_hex = txToHex(dbl_tx)
         self.nodes[0].sendrawtransaction(dbl_tx_hex, True)
 
@@ -286,7 +299,7 @@ def branch(prevout, initial_value, max_txs, tree_width=5, fee=0.0001*COIN, _tota
 
             dbl_tx = CTransaction()
             dbl_tx.vin = [CTxIn(tx0_outpoint, nSequence=0)]
-            dbl_tx.vout = [CTxOut(initial_nValue - 2 * fee * n, CScript([1] * 35))]
+            dbl_tx.vout = [CTxOut(initial_nValue - 2 * fee * n, CScript([1] * 35)), CTxOut(2*fee*n)]
             dbl_tx_hex = txToHex(dbl_tx)
             # This will raise an exception
             assert_raises_rpc_error(-26, "too many potential replacements", self.nodes[0].sendrawtransaction, dbl_tx_hex, True)
@@ -301,7 +314,7 @@ def test_replacement_feeperkb(self):
 
         tx1a = CTransaction()
         tx1a.vin = [CTxIn(tx0_outpoint, nSequence=0)]
-        tx1a.vout = [CTxOut(1 * COIN, CScript([b'a' * 35]))]
+        tx1a.vout = [CTxOut(1 * COIN, CScript([b'a' * 35])), CTxOut(int(0.1*COIN))]
         tx1a_hex = txToHex(tx1a)
         self.nodes[0].sendrawtransaction(tx1a_hex, True)
 
@@ -309,7 +322,7 @@ def test_replacement_feeperkb(self):
         # rejected.
         tx1b = CTransaction()
         tx1b.vin = [CTxIn(tx0_outpoint, nSequence=0)]
-        tx1b.vout = [CTxOut(int(0.001*COIN), CScript([b'a'*999000]))]
+        tx1b.vout = [CTxOut(int(0.001*COIN), CScript([b'a'*999000])), CTxOut(int(1.1*COIN-0.001*COIN))]
         tx1b_hex = txToHex(tx1b)
 
         # This will raise an exception due to insufficient fee
@@ -322,7 +335,7 @@ def test_spends_of_conflicting_outputs(self):
 
         tx1a = CTransaction()
         tx1a.vin = [CTxIn(utxo1, nSequence=0)]
-        tx1a.vout = [CTxOut(int(1.1 * COIN), CScript([b'a' * 35]))]
+        tx1a.vout = [CTxOut(int(1.1 * COIN), CScript([b'a' * 35])), CTxOut(int(0.1*COIN))]
         tx1a_hex = txToHex(tx1a)
         tx1a_txid = self.nodes[0].sendrawtransaction(tx1a_hex, True)
 
@@ -332,7 +345,7 @@ def test_spends_of_conflicting_outputs(self):
         tx2 = CTransaction()
         tx2.vin = [CTxIn(utxo1, nSequence=0), CTxIn(utxo2, nSequence=0)]
         tx2.vin.append(CTxIn(COutPoint(tx1a_txid, 0), nSequence=0))
-        tx2.vout = tx1a.vout
+        tx2.vout = tx1a.vout + [CTxOut(3*COIN + int(1.1*COIN))]
         tx2_hex = txToHex(tx2)
 
         # This will raise an exception
@@ -341,7 +354,7 @@ def test_spends_of_conflicting_outputs(self):
         # Spend tx1a's output to test the indirect case.
         tx1b = CTransaction()
         tx1b.vin = [CTxIn(COutPoint(tx1a_txid, 0), nSequence=0)]
-        tx1b.vout = [CTxOut(1 * COIN, CScript([b'a' * 35]))]
+        tx1b.vout = [CTxOut(1 * COIN, CScript([b'a' * 35])), CTxOut(int(0.1*COIN))]
         tx1b_hex = txToHex(tx1b)
         tx1b_txid = self.nodes[0].sendrawtransaction(tx1b_hex, True)
         tx1b_txid = int(tx1b_txid, 16)
@@ -349,7 +362,7 @@ def test_spends_of_conflicting_outputs(self):
         tx2 = CTransaction()
         tx2.vin = [CTxIn(utxo1, nSequence=0), CTxIn(utxo2, nSequence=0),
                    CTxIn(COutPoint(tx1b_txid, 0))]
-        tx2.vout = tx1a.vout
+        tx2.vout = tx1a.vout + [CTxOut(3*COIN + int(1.0*COIN))]
         tx2_hex = txToHex(tx2)
 
         # This will raise an exception
@@ -362,13 +375,13 @@ def test_new_unconfirmed_inputs(self):
 
         tx1 = CTransaction()
         tx1.vin = [CTxIn(confirmed_utxo)]
-        tx1.vout = [CTxOut(1 * COIN, CScript([b'a' * 35]))]
+        tx1.vout = [CTxOut(1 * COIN, CScript([b'a' * 35])), CTxOut(int(0.1*COIN))]
         tx1_hex = txToHex(tx1)
         self.nodes[0].sendrawtransaction(tx1_hex, True)
 
         tx2 = CTransaction()
         tx2.vin = [CTxIn(confirmed_utxo), CTxIn(unconfirmed_utxo)]
-        tx2.vout = tx1.vout
+        tx2.vout = tx1.vout + [CTxOut(int(0.1*COIN))]
         tx2_hex = txToHex(tx2)
 
         # This will raise an exception
@@ -391,7 +404,7 @@ def test_too_many_replacements(self):
 
         splitting_tx = CTransaction()
         splitting_tx.vin = [CTxIn(utxo, nSequence=0)]
-        splitting_tx.vout = outputs
+        splitting_tx.vout = outputs + [CTxOut(int(initial_nValue - (MAX_REPLACEMENT_LIMIT+1) * split_value))]
         splitting_tx_hex = txToHex(splitting_tx)
 
         txid = self.nodes[0].sendrawtransaction(splitting_tx_hex, True)
@@ -401,7 +414,7 @@ def test_too_many_replacements(self):
         for i in range(MAX_REPLACEMENT_LIMIT+1):
             tx_i = CTransaction()
             tx_i.vin = [CTxIn(COutPoint(txid, i), nSequence=0)]
-            tx_i.vout = [CTxOut(split_value - fee, CScript([b'a' * 35]))]
+            tx_i.vout = [CTxOut(split_value - fee, CScript([b'a' * 35])), CTxOut(fee)]
             tx_i_hex = txToHex(tx_i)
             self.nodes[0].sendrawtransaction(tx_i_hex, True)
 
@@ -414,7 +427,7 @@ def test_too_many_replacements(self):
             inputs.append(CTxIn(COutPoint(txid, i), nSequence=0))
         double_tx = CTransaction()
         double_tx.vin = inputs
-        double_tx.vout = [CTxOut(double_spend_value, CScript([b'a']))]
+        double_tx.vout = [CTxOut(double_spend_value, CScript([b'a'])), CTxOut(int(split_value*(MAX_REPLACEMENT_LIMIT+1)-double_spend_value))]
         double_tx_hex = txToHex(double_tx)
 
         # This will raise an exception
@@ -423,7 +436,7 @@ def test_too_many_replacements(self):
         # If we remove an input, it should pass
         double_tx = CTransaction()
         double_tx.vin = inputs[0:-1]
-        double_tx.vout = [CTxOut(double_spend_value, CScript([b'a']))]
+        double_tx.vout = [CTxOut(double_spend_value, CScript([b'a'])), CTxOut(int(split_value*(MAX_REPLACEMENT_LIMIT)-double_spend_value))]
         double_tx_hex = txToHex(double_tx)
         self.nodes[0].sendrawtransaction(double_tx_hex, True)
 
@@ -434,7 +447,7 @@ def test_opt_in(self):
         # Create a non-opting in transaction
         tx1a = CTransaction()
         tx1a.vin = [CTxIn(tx0_outpoint, nSequence=0xffffffff)]
-        tx1a.vout = [CTxOut(1 * COIN, CScript([b'a' * 35]))]
+        tx1a.vout = [CTxOut(1 * COIN, CScript([b'a' * 35])), CTxOut(int(0.1*COIN))]
         tx1a_hex = txToHex(tx1a)
         tx1a_txid = self.nodes[0].sendrawtransaction(tx1a_hex, True)
 
@@ -455,7 +468,7 @@ def test_opt_in(self):
         # Create a different non-opting in transaction
         tx2a = CTransaction()
         tx2a.vin = [CTxIn(tx1_outpoint, nSequence=0xfffffffe)]
-        tx2a.vout = [CTxOut(1 * COIN, CScript([b'a' * 35]))]
+        tx2a.vout = [CTxOut(1 * COIN, CScript([b'a' * 35])), CTxOut(int(0.1*COIN))]
         tx2a_hex = txToHex(tx2a)
         tx2a_txid = self.nodes[0].sendrawtransaction(tx2a_hex, True)
 
@@ -479,6 +492,7 @@ def test_opt_in(self):
         tx3a.vin = [CTxIn(COutPoint(tx1a_txid, 0), nSequence=0xffffffff),
                     CTxIn(COutPoint(tx2a_txid, 0), nSequence=0xfffffffd)]
         tx3a.vout = [CTxOut(int(0.9*COIN), CScript([b'c'])), CTxOut(int(0.9*COIN), CScript([b'd']))]
+        tx3a.vout.append(CTxOut(int(0.2*COIN)))
         tx3a_hex = txToHex(tx3a)
 
         tx3a_txid = self.nodes[0].sendrawtransaction(tx3a_hex, True)
@@ -488,12 +502,12 @@ def test_opt_in(self):
 
         tx3b = CTransaction()
         tx3b.vin = [CTxIn(COutPoint(tx1a_txid, 0), nSequence=0)]
-        tx3b.vout = [CTxOut(int(0.5 * COIN), CScript([b'e' * 35]))]
+        tx3b.vout = [CTxOut(int(0.5 * COIN), CScript([b'e' * 35])), CTxOut(int(0.5*COIN))]
         tx3b_hex = txToHex(tx3b)
 
         tx3c = CTransaction()
         tx3c.vin = [CTxIn(COutPoint(tx2a_txid, 0), nSequence=0)]
-        tx3c.vout = [CTxOut(int(0.5 * COIN), CScript([b'f' * 35]))]
+        tx3c.vout = [CTxOut(int(0.5 * COIN), CScript([b'f' * 35])), CTxOut(int(0.5*COIN))]
         tx3c_hex = txToHex(tx3c)
 
         self.nodes[0].sendrawtransaction(tx3b_hex, True)
@@ -510,14 +524,14 @@ def test_prioritised_transactions(self):
 
         tx1a = CTransaction()
         tx1a.vin = [CTxIn(tx0_outpoint, nSequence=0)]
-        tx1a.vout = [CTxOut(1 * COIN, CScript([b'a' * 35]))]
+        tx1a.vout = [CTxOut(1 * COIN, CScript([b'a' * 35])), CTxOut(int(0.1*COIN))]
         tx1a_hex = txToHex(tx1a)
         tx1a_txid = self.nodes[0].sendrawtransaction(tx1a_hex, True)
 
         # Higher fee, but the actual fee per KB is much lower.
         tx1b = CTransaction()
         tx1b.vin = [CTxIn(tx0_outpoint, nSequence=0)]
-        tx1b.vout = [CTxOut(int(0.001*COIN), CScript([b'a'*740000]))]
+        tx1b.vout = [CTxOut(int(0.001*COIN), CScript([b'a'*740000])), CTxOut(int(1.1*COIN-0.001*COIN))]
         tx1b_hex = txToHex(tx1b)
 
         # Verify tx1b cannot replace tx1a.
@@ -536,14 +550,14 @@ def test_prioritised_transactions(self):
 
         tx2a = CTransaction()
         tx2a.vin = [CTxIn(tx1_outpoint, nSequence=0)]
-        tx2a.vout = [CTxOut(1 * COIN, CScript([b'a' * 35]))]
+        tx2a.vout = [CTxOut(1 * COIN, CScript([b'a' * 35])), CTxOut(int(0.1*COIN))]
         tx2a_hex = txToHex(tx2a)
         self.nodes[0].sendrawtransaction(tx2a_hex, True)
 
         # Lower fee, but we'll prioritise it
         tx2b = CTransaction()
         tx2b.vin = [CTxIn(tx1_outpoint, nSequence=0)]
-        tx2b.vout = [CTxOut(int(1.01 * COIN), CScript([b'a' * 35]))]
+        tx2b.vout = [CTxOut(int(1.01 * COIN), CScript([b'a' * 35])), CTxOut(int(1.1*COIN-1.01*COIN))]
         tx2b.rehash()
         tx2b_hex = txToHex(tx2b)
 
@@ -562,6 +576,7 @@ def test_rpc(self):
         us0 = self.nodes[0].listunspent()[0]
         ins = [us0]
         outs = {self.nodes[0].getnewaddress() : Decimal(1.0000000)}
+        outs["fee"] = us0["amount"] - Decimal(1.0000000)
         rawtx0 = self.nodes[0].createrawtransaction(ins, outs, 0, True)
         rawtx1 = self.nodes[0].createrawtransaction(ins, outs, 0, False)
         json0  = self.nodes[0].decoderawtransaction(rawtx0)
diff --git a/test/functional/feature_segwit.py b/test/functional/feature_segwit.py
index 34a5f14937f6b..7fda5aef69a01 100755
--- a/test/functional/feature_segwit.py
+++ b/test/functional/feature_segwit.py
@@ -17,7 +17,7 @@
 )
 from test_framework.blocktools import witness_script, send_to_witness
 from test_framework.messages import COIN, COutPoint, CTransaction, CTxIn, CTxOut, FromHex, sha256, ToHex
-from test_framework.script import CScript, OP_HASH160, OP_CHECKSIG, OP_0, hash160, OP_EQUAL, OP_DUP, OP_EQUALVERIFY, OP_1, OP_2, OP_CHECKMULTISIG, OP_TRUE, OP_DROP
+from test_framework.script import CScript, OP_HASH160, OP_CHECKSIG, OP_0, hash160, OP_EQUAL, OP_DUP, OP_EQUALVERIFY, OP_1, OP_2, OP_CHECKMULTISIG, OP_TRUE, OP_DROP, OP_RETURN
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal, assert_raises_rpc_error, bytes_to_hex_str, connect_nodes, hex_str_to_bytes, sync_blocks, try_rpc
 
@@ -111,7 +111,7 @@ def run_test(self):
         assert(tmpl['transactions'][0]['sigops'] == 2)
         self.nodes[0].generate(1) #block 162
 
-        balance_presetup = self.nodes[0].getbalance()
+        balance_presetup = self.nodes[0].getbalance()['bitcoin']
         self.pubkey = []
         p2sh_ids = [] # p2sh_ids[NODE][VER] is an array of txids that spend to a witness version VER pkscript to an address for NODE embedded in p2sh
         wit_ids = [] # wit_ids[NODE][VER] is an array of txids that spend to a witness version VER pkscript to an address for NODE via bare witness
@@ -143,9 +143,9 @@ def run_test(self):
         sync_blocks(self.nodes)
 
         # Make sure all nodes recognize the transactions as theirs
-        assert_equal(self.nodes[0].getbalance(), balance_presetup - 60*50 + 20*Decimal("49.999") + 50)
-        assert_equal(self.nodes[1].getbalance(), 20*Decimal("49.999"))
-        assert_equal(self.nodes[2].getbalance(), 20*Decimal("49.999"))
+        assert_equal(self.nodes[0].getbalance()['bitcoin'], balance_presetup - 60*50 + 20*Decimal("49.999") + 50)
+        assert_equal(self.nodes[1].getbalance()['bitcoin'], 20*Decimal("49.999"))
+        assert_equal(self.nodes[2].getbalance()['bitcoin'], 20*Decimal("49.999"))
 
         self.nodes[0].generate(260) #block 423
         sync_blocks(self.nodes)
@@ -229,6 +229,7 @@ def run_test(self):
         tx = CTransaction()
         tx.vin.append(CTxIn(COutPoint(int(txid1, 16), 0), b''))
         tx.vout.append(CTxOut(int(49.99 * COIN), CScript([OP_TRUE, OP_DROP] * 15 + [OP_TRUE])))
+        tx.vout.append(CTxOut(int(49.996*COIN - 49.99*COIN)))
         tx2_hex = self.nodes[0].signrawtransactionwithwallet(ToHex(tx))['hex']
         txid2 = self.nodes[0].sendrawtransaction(tx2_hex)
         tx = FromHex(CTransaction(), tx2_hex)
@@ -238,6 +239,7 @@ def run_test(self):
         tx = CTransaction()
         tx.vin.append(CTxIn(COutPoint(int(txid2, 16), 0), b""))
         tx.vout.append(CTxOut(int(49.95 * COIN), CScript([OP_TRUE, OP_DROP] * 15 + [OP_TRUE])))  # Huge fee
+        tx.vout.append(CTxOut(int(49.99*COIN - 49.95*COIN)))
         tx.calc_sha256()
         txid3 = self.nodes[0].sendrawtransaction(ToHex(tx))
         assert(tx.wit.is_null())
@@ -564,10 +566,14 @@ def run_test(self):
         for use_p2wsh in [False, True]:
             if use_p2wsh:
                 scriptPubKey = "00203a59f3f56b713fdcf5d1a57357f02c44342cbf306ffe0c4741046837bf90561a"
-                transaction = "0100000000000100e1f505000000002200203a59f3f56b713fdcf5d1a57357f02c44342cbf306ffe0c4741046837bf90561a00000000"
+                # original btc tx:
+                # 01000000000100e1f505000000002200203a59f3f56b713fdcf5d1a57357f02c44342cbf306ffe0c4741046837bf90561a00000000
+                transaction = "0100000000000101ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe0010000000005f5e100002200203a59f3f56b713fdcf5d1a57357f02c44342cbf306ffe0c4741046837bf90561a00000000"
             else:
                 scriptPubKey = "a9142f8c469c2f0084c48e11f998ffbe7efa7549f26d87"
-                transaction = "0100000000000100e1f5050000000017a9142f8c469c2f0084c48e11f998ffbe7efa7549f26d8700000000"
+                # original btc tx:
+                # 01000000000100e1f5050000000017a9142f8c469c2f0084c48e11f998ffbe7efa7549f26d8700000000
+                transaction = "0100000000000101ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe0010000000005f5e1000017a9142f8c469c2f0084c48e11f998ffbe7efa7549f26d8700000000"
 
             self.nodes[1].importaddress(scriptPubKey, "", False)
             rawtxfund = self.nodes[1].fundrawtransaction(transaction)['hex']
@@ -587,8 +593,11 @@ def mine_and_test_listunspent(self, script_list, ismine):
         utxo = find_spendable_utxo(self.nodes[0], 50)
         tx = CTransaction()
         tx.vin.append(CTxIn(COutPoint(int('0x'+utxo['txid'],0), utxo['vout'])))
+        remaining = 50*COIN
         for i in script_list:
             tx.vout.append(CTxOut(10000000, i))
+            remaining -= 10000000
+        tx.vout.append(CTxOut(remaining))
         tx.rehash()
         signresults = self.nodes[0].signrawtransactionwithwallet(bytes_to_hex_str(tx.serialize_without_witness()))['hex']
         txid = self.nodes[0].sendrawtransaction(signresults, True)
@@ -633,14 +642,19 @@ def p2pkh_address_to_script(self,v):
 
     def create_and_mine_tx_from_txids(self, txids, success = True):
         tx = CTransaction()
+        total_in = 0
         for i in txids:
             txtmp = CTransaction()
             txraw = self.nodes[0].getrawtransaction(i)
             f = BytesIO(hex_str_to_bytes(txraw))
             txtmp.deserialize(f)
             for j in range(len(txtmp.vout)):
+                if txtmp.vout[j].is_fee():
+                    continue
+                total_in += txtmp.vout[j].nValue.getAmount()
                 tx.vin.append(CTxIn(COutPoint(int('0x'+i,0), j)))
-        tx.vout.append(CTxOut(0, CScript()))
+        tx.vout.append(CTxOut(0, CScript([OP_RETURN])))
+        tx.vout.append(CTxOut(total_in))
         tx.rehash()
         signresults = self.nodes[0].signrawtransactionwithwallet(bytes_to_hex_str(tx.serialize_without_witness()))['hex']
         self.nodes[0].sendrawtransaction(signresults, True)
diff --git a/test/functional/feature_txwitness.py b/test/functional/feature_txwitness.py
index 31a0b8d5f421c..12e04e3795ad1 100755
--- a/test/functional/feature_txwitness.py
+++ b/test/functional/feature_txwitness.py
@@ -29,7 +29,7 @@ def set_test_params(self):
     def assert_tx_format_also_signed(self, utxo, segwit):
         raw = self.nodes[0].createrawtransaction(
             [{"txid": utxo["txid"], "vout": utxo["vout"]}],
-            [{self.unknown_addr: "49.9"}]
+            [{self.unknown_addr: "49.9"}, {"fee": "0.1"}]
         )
 
         unsigned_decoded = self.nodes[0].decoderawtransaction(raw)
@@ -40,6 +40,8 @@ def assert_tx_format_also_signed(self, utxo, segwit):
         tx = CTransaction()
         tx.deserialize(BytesIO(hex_str_to_bytes(raw)))
         assert_equal(tx.vin[0].prevout.hash, int("0x"+utxo["txid"], 0))
+        assert_equal(len(tx.vin), len(unsigned_decoded["vin"]))
+        assert_equal(len(tx.vout), len(unsigned_decoded["vout"]))
         # assert re-encoding
         serialized = bytes_to_hex_str(tx.serialize())
         assert_equal(serialized, raw)
@@ -73,7 +75,7 @@ def assert_tx_format_also_signed(self, utxo, segwit):
         assert_equal(nodetx["hash"], wtxid)
 
         # witness hash stuff
-        assert_equal(nodetx["withash"], bytes_to_hex_str(ser_uint256(tx.calc_witness_hash())[::-1]))
+        assert_equal(nodetx["withash"], tx.calc_witness_hash())
         return (txid, wtxid)
 
     def test_transaction_serialization(self):
diff --git a/test/functional/interface_rest.py b/test/functional/interface_rest.py
index 7ebeea558a454..e9127755c7715 100755
--- a/test/functional/interface_rest.py
+++ b/test/functional/interface_rest.py
@@ -84,7 +84,7 @@ def run_test(self):
         self.nodes[1].generatetoaddress(100, not_related_address)
         self.sync_all()
 
-        assert_equal(self.nodes[0].getbalance(), 50)
+        assert_equal(self.nodes[0].getbalance()['bitcoin'], 50)
 
         txid = self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 0.1)
         self.sync_all()
@@ -92,7 +92,7 @@ def run_test(self):
         self.sync_all()
         bb_hash = self.nodes[0].getbestblockhash()
 
-        assert_equal(self.nodes[1].getbalance(), Decimal("0.1"))
+        assert_equal(self.nodes[1].getbalance()['bitcoin'], Decimal("0.1"))
 
         self.log.info("Load the transaction using the /tx URI")
 
diff --git a/test/functional/mempool_accept.py b/test/functional/mempool_accept.py
index 03844daff4386..25d038a61aab7 100755
--- a/test/functional/mempool_accept.py
+++ b/test/functional/mempool_accept.py
@@ -5,6 +5,7 @@
 """Test mempool acceptance of raw transactions."""
 
 from io import BytesIO
+from decimal import Decimal
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.messages import (
     BIP125_SEQUENCE_NUMBER,
@@ -12,6 +13,7 @@
     COutPoint,
     CTransaction,
     CTxOut,
+    CTxOutValue,
     MAX_BLOCK_BASE_SIZE,
 )
 from test_framework.script import (
@@ -66,7 +68,7 @@ def run_test(self):
         coin = node.listunspent()[0]  # Pick a random coin(base) to spend
         raw_tx_in_block = node.signrawtransactionwithwallet(node.createrawtransaction(
             inputs=[{'txid': coin['txid'], 'vout': coin['vout']}],
-            outputs=[{node.getnewaddress(): 0.3}, {node.getnewaddress(): 49}],
+            outputs=[{node.getnewaddress(): 0.3}, {node.getnewaddress(): 49}, {"fee": coin["amount"] - Decimal('49.3')}],
         ))['hex']
         txid_in_block = node.sendrawtransaction(hexstring=raw_tx_in_block, allowhighfees=True)
         node.generate(1)
@@ -79,7 +81,7 @@ def run_test(self):
         fee = 0.00000700
         raw_tx_0 = node.signrawtransactionwithwallet(node.createrawtransaction(
             inputs=[{"txid": txid_in_block, "vout": 0, "sequence": BIP125_SEQUENCE_NUMBER}],  # RBF is used later
-            outputs=[{node.getnewaddress(): 0.3 - fee}],
+            outputs=[{node.getnewaddress(): 0.3 - fee}, {"fee": fee}],
         ))['hex']
         tx = CTransaction()
         tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_0)))
@@ -99,7 +101,9 @@ def run_test(self):
 
         self.log.info('A transaction that replaces a mempool transaction')
         tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_0)))
-        tx.vout[0].nValue -= int(fee * COIN)  # Double the fee
+        tx.vout[0].nValue.setToAmount(tx.vout[0].nValue.getAmount() - int(fee * COIN))  # Double the fee
+        txid_0_out = tx.vout[0].nValue.getAmount()
+        tx.vout[1].nValue.setToAmount(tx.vout[1].nValue.getAmount() + int(fee * COIN))
         tx.vin[0].nSequence = BIP125_SEQUENCE_NUMBER + 1  # Now, opt out of RBF
         raw_tx_0 = node.signrawtransactionwithwallet(bytes_to_hex_str(tx.serialize()))['hex']
         tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_0)))
@@ -114,7 +118,8 @@ def run_test(self):
         node.sendrawtransaction(hexstring=bytes_to_hex_str(tx.serialize()), allowhighfees=True)
         # take original raw_tx_0
         tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_0)))
-        tx.vout[0].nValue -= int(4 * fee * COIN)  # Set more fee
+        tx.vout[0].nValue.setToAmount(tx.vout[0].nValue.getAmount() - int(4 * fee * COIN))  # Set more fee
+        tx.vout[1].nValue.setToAmount(tx.vout[1].nValue.getAmount() + int(4 * fee * COIN))
         # skip re-signing the tx
         self.check_mempool_result(
             result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': '18: txn-mempool-conflict'}],
@@ -134,6 +139,8 @@ def run_test(self):
         self.log.info('A transaction with missing inputs, that existed once in the past')
         tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_0)))
         tx.vin[0].prevout.n = 1  # Set vout to 1, to spend the other outpoint (49 coins) of the in-chain-tx we want to double spend
+        tx.vout[1].nValue.setToAmount(49*COIN - tx.vout[0].nValue.getAmount()) # fee
+        txid_1_out = tx.vout[0].nValue.getAmount()
         raw_tx_1 = node.signrawtransactionwithwallet(bytes_to_hex_str(tx.serialize()))['hex']
         txid_1 = node.sendrawtransaction(hexstring=raw_tx_1, allowhighfees=True)
         # Now spend both to "clearly hide" the outputs, ie. remove the coins from the utxo set by spending them
@@ -142,7 +149,7 @@ def run_test(self):
                 {'txid': txid_0, 'vout': 0},
                 {'txid': txid_1, 'vout': 0},
             ],
-            outputs=[{node.getnewaddress(): 0.1}]
+            outputs=[{node.getnewaddress(): 0.1}, {"fee": Decimal(txid_0_out + txid_1_out)/Decimal(COIN) - Decimal('0.1')}]
         ))['hex']
         txid_spend_both = node.sendrawtransaction(hexstring=raw_tx_spend_both, allowhighfees=True)
         node.generate(1)
@@ -160,7 +167,7 @@ def run_test(self):
         self.log.info('Create a signed "reference" tx for later use')
         raw_tx_reference = node.signrawtransactionwithwallet(node.createrawtransaction(
             inputs=[{'txid': txid_spend_both, 'vout': 0}],
-            outputs=[{node.getnewaddress(): 0.05}],
+            outputs=[{node.getnewaddress(): 0.05}, {"fee": Decimal('0.1') - Decimal('0.05')}],
         ))['hex']
         tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
         # Reference tx should be valid on itself
@@ -189,7 +196,7 @@ def run_test(self):
 
         self.log.info('A transaction with negative output value')
         tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
-        tx.vout[0].nValue *= -1
+        tx.vout[0].nValue.setToAmount(tx.vout[0].nValue.getAmount() * -1)
         self.check_mempool_result(
             result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': '16: bad-txns-vout-negative'}],
             rawtxs=[bytes_to_hex_str(tx.serialize())],
@@ -197,7 +204,7 @@ def run_test(self):
 
         self.log.info('A transaction with too large output value')
         tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
-        tx.vout[0].nValue = 21000000 * COIN + 1
+        tx.vout[0].nValue = CTxOutValue(21000000 * COIN + 1)
         self.check_mempool_result(
             result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': '16: bad-txns-vout-toolarge'}],
             rawtxs=[bytes_to_hex_str(tx.serialize())],
@@ -206,7 +213,7 @@ def run_test(self):
         self.log.info('A transaction with too large sum of output values')
         tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
         tx.vout = [tx.vout[0]] * 2
-        tx.vout[0].nValue = 21000000 * COIN
+        tx.vout[0].nValue = CTxOutValue(21000000 * COIN)
         self.check_mempool_result(
             result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': '16: bad-txns-txouttotal-toolarge'}],
             rawtxs=[bytes_to_hex_str(tx.serialize())],
@@ -258,7 +265,7 @@ def run_test(self):
         )
         tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx_reference)))
         tx.vout[0] = output_p2sh_burn
-        tx.vout[0].nValue -= 1  # Make output smaller, such that it is dust for our policy
+        tx.vout[0].nValue.setToAmount(tx.vout[0].nValue.getAmount() - 1)  # Make output smaller, such that it is dust for our policy
         self.check_mempool_result(
             result_expected=[{'txid': tx.rehash(), 'allowed': False, 'reject-reason': '64: dust'}],
             rawtxs=[bytes_to_hex_str(tx.serialize())],
diff --git a/test/functional/mempool_limit.py b/test/functional/mempool_limit.py
index c0918893cdc9a..ea30d7edfb314 100755
--- a/test/functional/mempool_limit.py
+++ b/test/functional/mempool_limit.py
@@ -32,7 +32,7 @@ def run_test(self):
         self.log.info('Create a mempool tx that will be evicted')
         us0 = utxos.pop()
         inputs = [{ "txid" : us0["txid"], "vout" : us0["vout"]}]
-        outputs = {self.nodes[0].getnewaddress() : 0.0001}
+        outputs = {self.nodes[0].getnewaddress() : 0.0001, "fee": us0["amount"] - Decimal('0.0001')}
         tx = self.nodes[0].createrawtransaction(inputs, outputs)
         self.nodes[0].settxfee(relayfee) # specifically fund this tx with low fee
         txF = self.nodes[0].fundrawtransaction(tx)
@@ -58,7 +58,7 @@ def run_test(self):
         self.log.info('Create a mempool tx that will not pass mempoolminfee')
         us0 = utxos.pop()
         inputs = [{ "txid" : us0["txid"], "vout" : us0["vout"]}]
-        outputs = {self.nodes[0].getnewaddress() : 0.0001}
+        outputs = {self.nodes[0].getnewaddress() : 0.0001, "fee": us0["amount"] - Decimal('0.0001')}
         tx = self.nodes[0].createrawtransaction(inputs, outputs)
         # specifically fund this tx with a fee < mempoolminfee, >= than minrelaytxfee
         txF = self.nodes[0].fundrawtransaction(tx, {'feeRate': relayfee})
diff --git a/test/functional/mempool_packages.py b/test/functional/mempool_packages.py
index 53cc371ace368..dc766d709d9fd 100755
--- a/test/functional/mempool_packages.py
+++ b/test/functional/mempool_packages.py
@@ -30,11 +30,12 @@ def chain_transaction(self, node, parent_txid, vout, value, fee, num_outputs):
         outputs = {}
         for i in range(num_outputs):
             outputs[node.getnewaddress()] = send_value
+        outputs["fee"] = fee
         rawtx = node.createrawtransaction(inputs, outputs)
         signedtx = node.signrawtransactionwithwallet(rawtx)
         txid = node.sendrawtransaction(signedtx['hex'])
         fulltx = node.getrawtransaction(txid, 1)
-        assert(len(fulltx['vout']) == num_outputs) # make sure we didn't generate a change output
+        assert(len(fulltx['vout']) == num_outputs + 1) # make sure we didn't generate a change output
         return (txid, send_value)
 
     def run_test(self):
@@ -274,6 +275,7 @@ def run_test(self):
         outputs = {}
         for i in range(2):
             outputs[self.nodes[0].getnewaddress()] = send_value
+        outputs["fee"] = fee
         rawtx = self.nodes[0].createrawtransaction(inputs, outputs)
         signedtx = self.nodes[0].signrawtransactionwithwallet(rawtx)
         txid = self.nodes[0].sendrawtransaction(signedtx['hex'])
@@ -298,6 +300,7 @@ def run_test(self):
         # Now generate tx8, with a big fee
         inputs = [ {'txid' : tx1_id, 'vout': 0}, {'txid' : txid, 'vout': 0} ]
         outputs = { self.nodes[0].getnewaddress() : send_value + value - 4*fee }
+        outputs["fee"] = 3*fee
         rawtx = self.nodes[0].createrawtransaction(inputs, outputs)
         signedtx = self.nodes[0].signrawtransactionwithwallet(rawtx)
         txid = self.nodes[0].sendrawtransaction(signedtx['hex'])
diff --git a/test/functional/mempool_persist.py b/test/functional/mempool_persist.py
index 281b127c5ab99..1739e8abd8d12 100755
--- a/test/functional/mempool_persist.py
+++ b/test/functional/mempool_persist.py
@@ -61,7 +61,7 @@ def run_test(self):
         self.log.debug("Send 5 transactions from node2 (to its own address)")
         for i in range(5):
             self.nodes[2].sendtoaddress(self.nodes[2].getnewaddress(), Decimal("10"))
-        node2_balance = self.nodes[2].getbalance()
+        node2_balance = self.nodes[2].getbalance()['bitcoin']
         self.sync_all()
 
         self.log.debug("Verify that node0 and node1 have 5 transactions in their mempools")
@@ -83,7 +83,7 @@ def run_test(self):
 
         # Verify accounting of mempool transactions after restart is correct
         self.nodes[2].syncwithvalidationinterfacequeue()  # Flush mempool to wallet
-        assert_equal(node2_balance, self.nodes[2].getbalance())
+        assert_equal(node2_balance, self.nodes[2].getbalance()['bitcoin'])
 
         self.log.debug("Stop-start node0 with -persistmempool=0. Verify that it doesn't load its mempool.dat file.")
         self.stop_nodes()
diff --git a/test/functional/mempool_reorg.py b/test/functional/mempool_reorg.py
index 123f0b4c28b75..f8d593e36671d 100755
--- a/test/functional/mempool_reorg.py
+++ b/test/functional/mempool_reorg.py
@@ -42,12 +42,12 @@ def run_test(self):
         # and make sure the mempool code behaves correctly.
         b = [ self.nodes[0].getblockhash(n) for n in range(101, 105) ]
         coinbase_txids = [ self.nodes[0].getblock(h)['tx'][0] for h in b ]
-        spend_101_raw = create_raw_transaction(self.nodes[0], coinbase_txids[1], node1_address, amount=49.99)
-        spend_102_raw = create_raw_transaction(self.nodes[0], coinbase_txids[2], node0_address, amount=49.99)
-        spend_103_raw = create_raw_transaction(self.nodes[0], coinbase_txids[3], node0_address, amount=49.99)
+        spend_101_raw = create_raw_transaction(self.nodes[0], coinbase_txids[1], node1_address, amount=49.99, fee=0.01)
+        spend_102_raw = create_raw_transaction(self.nodes[0], coinbase_txids[2], node0_address, amount=49.99, fee=0.01)
+        spend_103_raw = create_raw_transaction(self.nodes[0], coinbase_txids[3], node0_address, amount=49.99, fee=0.01)
 
         # Create a transaction which is time-locked to two blocks in the future
-        timelock_tx = self.nodes[0].createrawtransaction([{"txid": coinbase_txids[0], "vout": 0}], {node0_address: 49.99})
+        timelock_tx = self.nodes[0].createrawtransaction([{"txid": coinbase_txids[0], "vout": 0}], {node0_address: 49.99, "fee": 0.01})
         # Set the time lock
         timelock_tx = timelock_tx.replace("ffffffff", "11111191", 1)
         timelock_tx = timelock_tx[:-8] + hex(self.nodes[0].getblockcount() + 2)[2:] + "000000"
@@ -63,8 +63,8 @@ def run_test(self):
         assert_raises_rpc_error(-26, 'non-final', self.nodes[0].sendrawtransaction, timelock_tx)
 
         # Create 102_1 and 103_1:
-        spend_102_1_raw = create_raw_transaction(self.nodes[0], spend_102_id, node1_address, amount=49.98)
-        spend_103_1_raw = create_raw_transaction(self.nodes[0], spend_103_id, node1_address, amount=49.98)
+        spend_102_1_raw = create_raw_transaction(self.nodes[0], spend_102_id, node1_address, amount=49.98, fee=0.01)
+        spend_103_1_raw = create_raw_transaction(self.nodes[0], spend_103_id, node1_address, amount=49.98, fee=0.01)
 
         # Broadcast and mine 103_1:
         spend_103_1_id = self.nodes[0].sendrawtransaction(spend_103_1_raw)
diff --git a/test/functional/mempool_resurrect.py b/test/functional/mempool_resurrect.py
index d035ca907a5d7..a2c008e8d64c9 100755
--- a/test/functional/mempool_resurrect.py
+++ b/test/functional/mempool_resurrect.py
@@ -30,13 +30,13 @@ def run_test(self):
 
         b = [self.nodes[0].getblockhash(n) for n in range(1, 4)]
         coinbase_txids = [self.nodes[0].getblock(h)['tx'][0] for h in b]
-        spends1_raw = [create_raw_transaction(self.nodes[0], txid, node0_address, amount=49.99) for txid in coinbase_txids]
+        spends1_raw = [create_raw_transaction(self.nodes[0], txid, node0_address, amount=49.99, fee=0.01) for txid in coinbase_txids]
         spends1_id = [self.nodes[0].sendrawtransaction(tx) for tx in spends1_raw]
 
         blocks = []
         blocks.extend(self.nodes[0].generate(1))
 
-        spends2_raw = [create_raw_transaction(self.nodes[0], txid, node0_address, amount=49.98) for txid in spends1_id]
+        spends2_raw = [create_raw_transaction(self.nodes[0], txid, node0_address, amount=49.98, fee=0.01) for txid in spends1_id]
         spends2_id = [self.nodes[0].sendrawtransaction(tx) for tx in spends2_raw]
 
         blocks.extend(self.nodes[0].generate(1))
diff --git a/test/functional/mempool_spend_coinbase.py b/test/functional/mempool_spend_coinbase.py
index 854d506f0dd71..39a03c9c28ec0 100755
--- a/test/functional/mempool_spend_coinbase.py
+++ b/test/functional/mempool_spend_coinbase.py
@@ -34,7 +34,7 @@ def run_test(self):
         # is too immature to spend.
         b = [self.nodes[0].getblockhash(n) for n in range(101, 103)]
         coinbase_txids = [self.nodes[0].getblock(h)['tx'][0] for h in b]
-        spends_raw = [create_raw_transaction(self.nodes[0], txid, node0_address, amount=49.99) for txid in coinbase_txids]
+        spends_raw = [create_raw_transaction(self.nodes[0], txid, node0_address, amount=49.99, fee=0.01) for txid in coinbase_txids]
 
         spend_101_id = self.nodes[0].sendrawtransaction(spends_raw[0])
 
diff --git a/test/functional/p2p_compactblocks.py b/test/functional/p2p_compactblocks.py
index 48af46917148e..55f63e43245db 100755
--- a/test/functional/p2p_compactblocks.py
+++ b/test/functional/p2p_compactblocks.py
@@ -125,7 +125,7 @@ def make_utxos(self):
         assert(int(self.nodes[0].getbestblockhash(), 16) == block.sha256)
         self.nodes[0].generate(100)
 
-        total_value = block.vtx[0].vout[0].nValue
+        total_value = block.vtx[0].vout[0].nValue.getAmount()
         out_value = total_value // 10
         tx = CTransaction()
         tx.vin.append(CTxIn(COutPoint(block.vtx[0].sha256, 0), b''))
@@ -267,7 +267,7 @@ def test_compactblock_construction(self, node, test_node, version, use_witness_a
             # Want at least one segwit spend, so move all funds to
             # a witness address.
             address = node.addwitnessaddress(address)
-            value_to_send = node.getbalance()
+            value_to_send = node.getbalance()['bitcoin']
             node.sendtoaddress(address, satoshi_round(value_to_send-Decimal(0.1)))
             node.generate(1)
 
@@ -432,8 +432,9 @@ def build_block_with_transactions(self, node, utxo, num_transactions):
             tx = CTransaction()
             tx.vin.append(CTxIn(COutPoint(utxo[0], utxo[1]), b''))
             tx.vout.append(CTxOut(utxo[2] - 1000, CScript([OP_TRUE, OP_DROP] * 15 + [OP_TRUE])))
+            tx.vout.append(CTxOut(1000)) # fee
             tx.rehash()
-            utxo = [tx.sha256, 0, tx.vout[0].nValue]
+            utxo = [tx.sha256, 0, tx.vout[0].nValue.getAmount()]
             block.vtx.append(tx)
 
         block.hashMerkleRoot = block.calc_merkle_root()
@@ -463,7 +464,7 @@ def test_tip_after_message(node, peer, msg, tip):
         utxo = self.utxos.pop(0)
 
         block = self.build_block_with_transactions(node, utxo, 5)
-        self.utxos.append([block.vtx[-1].sha256, 0, block.vtx[-1].vout[0].nValue])
+        self.utxos.append([block.vtx[-1].sha256, 0, block.vtx[-1].vout[0].nValue.getAmount()])
         comp_block = HeaderAndShortIDs()
         comp_block.initialize_from_block(block, use_witness=with_witness)
 
@@ -477,7 +478,7 @@ def test_tip_after_message(node, peer, msg, tip):
 
         utxo = self.utxos.pop(0)
         block = self.build_block_with_transactions(node, utxo, 5)
-        self.utxos.append([block.vtx[-1].sha256, 0, block.vtx[-1].vout[0].nValue])
+        self.utxos.append([block.vtx[-1].sha256, 0, block.vtx[-1].vout[0].nValue.getAmount()])
 
         # Now try interspersing the prefilled transactions
         comp_block.initialize_from_block(block, prefill_list=[0, 1, 5], use_witness=with_witness)
@@ -488,7 +489,7 @@ def test_tip_after_message(node, peer, msg, tip):
         # Now try giving one transaction ahead of time.
         utxo = self.utxos.pop(0)
         block = self.build_block_with_transactions(node, utxo, 5)
-        self.utxos.append([block.vtx[-1].sha256, 0, block.vtx[-1].vout[0].nValue])
+        self.utxos.append([block.vtx[-1].sha256, 0, block.vtx[-1].vout[0].nValue.getAmount()])
         test_node.send_and_ping(msg_tx(block.vtx[1]))
         assert(block.vtx[1].hash in node.getrawmempool())
 
@@ -504,7 +505,7 @@ def test_tip_after_message(node, peer, msg, tip):
         # announced and verify reconstruction happens immediately.
         utxo = self.utxos.pop(0)
         block = self.build_block_with_transactions(node, utxo, 10)
-        self.utxos.append([block.vtx[-1].sha256, 0, block.vtx[-1].vout[0].nValue])
+        self.utxos.append([block.vtx[-1].sha256, 0, block.vtx[-1].vout[0].nValue.getAmount()])
         for tx in block.vtx[1:]:
             test_node.send_message(msg_tx(tx))
         test_node.sync_with_ping()
@@ -532,7 +533,7 @@ def test_incorrect_blocktxn_response(self, node, test_node, version):
         utxo = self.utxos.pop(0)
 
         block = self.build_block_with_transactions(node, utxo, 10)
-        self.utxos.append([block.vtx[-1].sha256, 0, block.vtx[-1].vout[0].nValue])
+        self.utxos.append([block.vtx[-1].sha256, 0, block.vtx[-1].vout[0].nValue.getAmount()])
         # Relay the first 5 transactions from the block in advance
         for tx in block.vtx[1:6]:
             test_node.send_message(msg_tx(tx))
@@ -773,7 +774,7 @@ def announce_cmpct_block(node, peer):
         delivery_peer.send_and_ping(msg_cmpctblock(cmpct_block.to_p2p()))
         assert_equal(int(node.getbestblockhash(), 16), block.sha256)
 
-        self.utxos.append([block.vtx[-1].sha256, 0, block.vtx[-1].vout[0].nValue])
+        self.utxos.append([block.vtx[-1].sha256, 0, block.vtx[-1].vout[0].nValue.getAmount()])
 
         # Now test that delivering an invalid compact block won't break relay
 
diff --git a/test/functional/p2p_invalid_block.py b/test/functional/p2p_invalid_block.py
index da651d66bc8db..ebfaa533d25c0 100755
--- a/test/functional/p2p_invalid_block.py
+++ b/test/functional/p2p_invalid_block.py
@@ -13,7 +13,7 @@
 import copy
 
 from test_framework.blocktools import create_block, create_coinbase, create_tx_with_script
-from test_framework.messages import COIN
+from test_framework.messages import COIN, CTxOutValue
 from test_framework.mininode import P2PDataStore
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import assert_equal
@@ -98,7 +98,7 @@ def run_test(self):
 
         block3 = create_block(tip, create_coinbase(height), block_time)
         block_time += 1
-        block3.vtx[0].vout[0].nValue = 100 * COIN  # Too high!
+        block3.vtx[0].vout[0].nValue = CTxOutValue(100 * COIN)  # Too high!
         block3.vtx[0].sha256 = None
         block3.vtx[0].calc_sha256()
         block3.hashMerkleRoot = block3.calc_merkle_root()
diff --git a/test/functional/p2p_invalid_tx.py b/test/functional/p2p_invalid_tx.py
index 2f19b4d93314b..589edf968a639 100755
--- a/test/functional/p2p_invalid_tx.py
+++ b/test/functional/p2p_invalid_tx.py
@@ -70,7 +70,7 @@ def run_test(self):
         # Transaction will be rejected with code 16 (REJECT_INVALID)
         # and we get disconnected immediately
         self.log.info('Test a transaction that is rejected')
-        tx1 = create_tx_with_script(block1.vtx[0], 0, script_sig=b'\x64' * 35, amount=50 * COIN - 12000)
+        tx1 = create_tx_with_script(block1.vtx[0], 0, script_sig=b'\x64' * 35, amount=50 * COIN - 12000, fee=12000)
         node.p2p.send_txs_and_test([tx1], node, success=False, expect_disconnect=True)
 
         # Make two p2p connections to provide the node with orphans
@@ -85,12 +85,14 @@ def run_test(self):
         tx_withhold = CTransaction()
         tx_withhold.vin.append(CTxIn(outpoint=COutPoint(block1.vtx[0].sha256, 0)))
         tx_withhold.vout.append(CTxOut(nValue=50 * COIN - 12000, scriptPubKey=SCRIPT_PUB_KEY_OP_TRUE))
+        tx_withhold.vout.append(CTxOut(12000)) # fee
         tx_withhold.calc_sha256()
 
         # Our first orphan tx with some outputs to create further orphan txs
         tx_orphan_1 = CTransaction()
         tx_orphan_1.vin.append(CTxIn(outpoint=COutPoint(tx_withhold.sha256, 0)))
         tx_orphan_1.vout = [CTxOut(nValue=10 * COIN, scriptPubKey=SCRIPT_PUB_KEY_OP_TRUE)] * 3
+        tx_orphan_1.vout.append(CTxOut(20 * COIN - 12000)) # fee
         tx_orphan_1.calc_sha256()
 
         # A valid transaction with low fee
@@ -102,6 +104,7 @@ def run_test(self):
         tx_orphan_2_valid = CTransaction()
         tx_orphan_2_valid.vin.append(CTxIn(outpoint=COutPoint(tx_orphan_1.sha256, 1)))
         tx_orphan_2_valid.vout.append(CTxOut(nValue=10 * COIN - 12000, scriptPubKey=SCRIPT_PUB_KEY_OP_TRUE))
+        tx_orphan_2_valid.vout.append(CTxOut(12000)) # fee
         tx_orphan_2_valid.calc_sha256()
 
         # An invalid transaction with negative fee
@@ -119,7 +122,7 @@ def run_test(self):
         assert_equal(2, len(node.getpeerinfo()))  # p2ps[1] is still connected
 
         self.log.info('Send the withhold tx ... ')
-        with node.assert_debug_log(expected_msgs=["bad-txns-in-belowout"]):
+        with node.assert_debug_log(expected_msgs=["bad-txns-in-ne-out"]):
             node.p2p.send_txs_and_test([tx_withhold], node, success=True)
 
         # Transactions that should end up in the mempool
diff --git a/test/functional/p2p_segwit.py b/test/functional/p2p_segwit.py
index c06c85995200e..191a9b5db5933 100755
--- a/test/functional/p2p_segwit.py
+++ b/test/functional/p2p_segwit.py
@@ -12,6 +12,7 @@
 from test_framework.blocktools import create_block, create_coinbase, add_witness_commitment, WITNESS_COMMITMENT_HEADER
 from test_framework.key import CECKey, CPubKey
 from test_framework.messages import (
+    COIN,
     BIP125_SEQUENCE_NUMBER,
     CBlockHeader,
     CInv,
@@ -20,6 +21,8 @@
     CTxIn,
     CTxInWitness,
     CTxOut,
+    CTxOutValue,
+    CTxOutWitness,
     CTxWitness,
     MAX_BLOCK_BASE_SIZE,
     MSG_WITNESS_FLAG,
@@ -103,7 +106,7 @@ def get_p2pkh_script(pubkeyhash):
 
 def sign_p2pk_witness_input(script, tx_to, in_idx, hashtype, value, key):
     """Add signature for a P2PK witness program."""
-    tx_hash = SegwitVersion1SignatureHash(script, tx_to, in_idx, hashtype, value)
+    tx_hash = SegwitVersion1SignatureHash(script, tx_to, in_idx, hashtype, CTxOutValue(value))
     signature = key.sign(tx_hash) + chr(hashtype).encode('latin-1')
     tx_to.wit.vtxinwit[in_idx].scriptWitness.stack = [signature, script]
     tx_to.rehash()
@@ -310,6 +313,7 @@ def test_non_witness_transaction(self):
         tx = CTransaction()
         tx.vin.append(CTxIn(COutPoint(txid, 0), b""))
         tx.vout.append(CTxOut(49 * 100000000, CScript([OP_TRUE, OP_DROP] * 15 + [OP_TRUE])))
+        tx.vout.append(CTxOut(50*COIN - 49*COIN)) # fee
         tx.calc_sha256()
 
         # Check that serializing it with or without witness is the same
@@ -330,6 +334,7 @@ def test_unnecessary_witness_before_segwit_activation(self):
         tx = CTransaction()
         tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
         tx.vout.append(CTxOut(self.utxo[0].nValue - 1000, CScript([OP_TRUE])))
+        tx.vout.append(CTxOut(1000)) # fee
         tx.wit.vtxinwit.append(CTxInWitness())
         tx.wit.vtxinwit[0].scriptWitness.stack = [CScript([CScriptNum(1)])]
 
@@ -353,7 +358,7 @@ def test_unnecessary_witness_before_segwit_activation(self):
 
         # Update our utxo list; we spent the first entry.
         self.utxo.pop(0)
-        self.utxo.append(UTXO(tx.sha256, 0, tx.vout[0].nValue))
+        self.utxo.append(UTXO(tx.sha256, 0, tx.vout[0].nValue.getAmount()))
 
     @subtest
     def test_block_relay(self):
@@ -482,6 +487,8 @@ def test_v0_outputs_arent_spendable(self):
         tx.vin = [CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b'')]
         tx.vout = [CTxOut(value, script_pubkey), CTxOut(value, p2sh_script_pubkey)]
         tx.vout.append(CTxOut(value, CScript([OP_TRUE])))
+        if self.utxo[0].nValue % 3 > 0:
+            tx.vout.append(CTxOut(self.utxo[0].nValue - 3*value))
         tx.rehash()
         txid = tx.sha256
 
@@ -612,12 +619,13 @@ def test_witness_tx_relay_before_segwit_activation(self):
         tx = CTransaction()
         tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
         tx.vout.append(CTxOut(self.utxo[0].nValue - 1000, CScript([OP_TRUE, OP_DROP] * 15 + [OP_TRUE])))
+        tx.vout.append(CTxOut(1000)) # fee
         tx.wit.vtxinwit.append(CTxInWitness())
         tx.wit.vtxinwit[0].scriptWitness.stack = [b'a']
         tx.rehash()
 
         tx_hash = tx.sha256
-        tx_value = tx.vout[0].nValue
+        tx_value = tx.vout[0].nValue.getAmount()
 
         # Verify that if a peer doesn't set nServices to include NODE_WITNESS,
         # the getdata is just for the non-witness portion.
@@ -663,6 +671,7 @@ def test_standardness_v0(self):
         p2sh_tx = CTransaction()
         p2sh_tx.vin = [CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b"")]
         p2sh_tx.vout = [CTxOut(self.utxo[0].nValue - 1000, p2sh_script_pubkey)]
+        p2sh_tx.vout.append(CTxOut(1000)) # fee
         p2sh_tx.rehash()
 
         # Mine it on test_node to create the confirmed output.
@@ -674,8 +683,9 @@ def test_standardness_v0(self):
         # Start by creating a transaction with two outputs.
         tx = CTransaction()
         tx.vin = [CTxIn(COutPoint(p2sh_tx.sha256, 0), CScript([witness_program]))]
-        tx.vout = [CTxOut(p2sh_tx.vout[0].nValue - 10000, script_pubkey)]
+        tx.vout = [CTxOut(p2sh_tx.vout[0].nValue.getAmount() - 10000, script_pubkey)]
         tx.vout.append(CTxOut(8000, script_pubkey))  # Might burn this later
+        tx.vout.append(CTxOut(2000)) # fee
         tx.vin[0].nSequence = BIP125_SEQUENCE_NUMBER  # Just to have the option to bump this tx from the mempool
         tx.rehash()
 
@@ -689,6 +699,7 @@ def test_standardness_v0(self):
         # tx was accepted, so we spend the second output.
         tx2.vin = [CTxIn(COutPoint(tx.sha256, 1), b"")]
         tx2.vout = [CTxOut(7000, script_pubkey)]
+        tx2.vout.append(CTxOut(1000)) # fee
         tx2.wit.vtxinwit.append(CTxInWitness())
         tx2.wit.vtxinwit[0].scriptWitness.stack = [witness_program]
         tx2.rehash()
@@ -701,7 +712,8 @@ def test_standardness_v0(self):
         # P2PKH output; just send tx's first output back to an anyone-can-spend.
         sync_mempools([self.nodes[0], self.nodes[1]])
         tx3.vin = [CTxIn(COutPoint(tx.sha256, 0), b"")]
-        tx3.vout = [CTxOut(tx.vout[0].nValue - 1000, CScript([OP_TRUE, OP_DROP] * 15 + [OP_TRUE]))]
+        tx3.vout = [CTxOut(tx.vout[0].nValue.getAmount() - 1000, CScript([OP_TRUE, OP_DROP] * 15 + [OP_TRUE]))]
+        tx3.vout.append(CTxOut(1000)) # fee
         tx3.wit.vtxinwit.append(CTxInWitness())
         tx3.wit.vtxinwit[0].scriptWitness.stack = [witness_program]
         tx3.rehash()
@@ -713,6 +725,7 @@ def test_standardness_v0(self):
             tx3_out = tx3.vout[0]
             tx3 = tx
             tx3.vout = [tx3_out]
+            tx3.vout.append(CTxOut(p2sh_tx.vout[0].nValue.getAmount() - tx3.vout[0].nValue.getAmount())) # fee
             tx3.rehash()
             assert_equal(self.nodes[0].testmempoolaccept([bytes_to_hex_str(tx3.serialize_with_witness())]), [{'txid': tx3.hash, 'allowed': True}])
         test_transaction_acceptance(self.nodes[0], self.test_node, tx3, with_witness=True, accepted=True)
@@ -720,7 +733,7 @@ def test_standardness_v0(self):
         self.nodes[0].generate(1)
         sync_blocks(self.nodes)
         self.utxo.pop(0)
-        self.utxo.append(UTXO(tx3.sha256, 0, tx3.vout[0].nValue))
+        self.utxo.append(UTXO(tx3.sha256, 0, tx3.vout[0].nValue.getAmount()))
         assert_equal(len(self.nodes[1].getrawmempool()), 0)
 
     @subtest
@@ -749,6 +762,7 @@ def test_p2sh_witness(self):
         tx = CTransaction()
         tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
         tx.vout.append(CTxOut(self.utxo[0].nValue - 1000, script_pubkey))
+        tx.vout.append(CTxOut(1000)) # fee
         tx.rehash()
 
         # Verify mempool acceptance and block validity
@@ -761,7 +775,8 @@ def test_p2sh_witness(self):
         # Now test attempts to spend the output.
         spend_tx = CTransaction()
         spend_tx.vin.append(CTxIn(COutPoint(tx.sha256, 0), script_sig))
-        spend_tx.vout.append(CTxOut(tx.vout[0].nValue - 1000, CScript([OP_TRUE])))
+        spend_tx.vout.append(CTxOut(tx.vout[0].nValue.getAmount() - 1000, CScript([OP_TRUE])))
+        spend_tx.vout.append(CTxOut(1000)) # fee
         spend_tx.rehash()
 
         # This transaction should not be accepted into the mempool pre- or
@@ -796,7 +811,7 @@ def test_p2sh_witness(self):
 
         # Update self.utxo
         self.utxo.pop(0)
-        self.utxo.append(UTXO(spend_tx.sha256, 0, spend_tx.vout[0].nValue))
+        self.utxo.append(UTXO(spend_tx.sha256, 0, spend_tx.vout[0].nValue.getAmount()))
 
     @subtest
     def test_witness_commitments(self):
@@ -835,12 +850,14 @@ def test_witness_commitments(self):
         witness_hash = sha256(witness_program)
         script_pubkey = CScript([OP_0, witness_hash])
         tx.vout.append(CTxOut(self.utxo[0].nValue - 1000, script_pubkey))
+        tx.vout.append(CTxOut(1000)) # fee
         tx.rehash()
 
         # tx2 will spend tx1, and send back to a regular anyone-can-spend address
         tx2 = CTransaction()
         tx2.vin.append(CTxIn(COutPoint(tx.sha256, 0), b""))
-        tx2.vout.append(CTxOut(tx.vout[0].nValue - 1000, witness_program))
+        tx2.vout.append(CTxOut(tx.vout[0].nValue.getAmount() - 1000, witness_program))
+        tx2.vout.append(CTxOut(1000)) # fee
         tx2.wit.vtxinwit.append(CTxInWitness())
         tx2.wit.vtxinwit[0].scriptWitness.stack = [witness_program]
         tx2.rehash()
@@ -863,8 +880,8 @@ def test_witness_commitments(self):
         # This should succeed (nValue shouldn't affect finding the
         # witness commitment).
         add_witness_commitment(block_3, nonce=0)
-        block_3.vtx[0].vout[0].nValue -= 1
-        block_3.vtx[0].vout[-1].nValue += 1
+        block_3.vtx[0].vout[0].nValue.setToAmount(block_3.vtx[0].vout[0].nValue.getAmount() - 1)
+        block_3.vtx[0].vout[-1].nValue.setToAmount(block_3.vtx[0].vout[-1].nValue.getAmount() + 1)
         block_3.vtx[0].rehash()
         block_3.hashMerkleRoot = block_3.calc_merkle_root()
         block_3.rehash()
@@ -877,7 +894,7 @@ def test_witness_commitments(self):
         block_4 = self.build_next_block()
         tx3 = CTransaction()
         tx3.vin.append(CTxIn(COutPoint(tx2.sha256, 0), b""))
-        tx3.vout.append(CTxOut(tx.vout[0].nValue - 1000, witness_program))
+        tx3.vout.append(CTxOut(tx.vout[0].nValue.getAmount() - 1000, witness_program))
         tx3.rehash()
         block_4.vtx.append(tx3)
         block_4.hashMerkleRoot = block_4.calc_merkle_root()
@@ -886,7 +903,7 @@ def test_witness_commitments(self):
 
         # Update available utxo's for use in later test.
         self.utxo.pop(0)
-        self.utxo.append(UTXO(tx3.sha256, 0, tx3.vout[0].nValue))
+        self.utxo.append(UTXO(tx3.sha256, 0, tx3.vout[0].nValue.getAmount()))
 
     @subtest
     def test_block_malleability(self):
@@ -957,14 +974,20 @@ def test_witness_block_size(self):
         child_value = int(value / NUM_OUTPUTS)
         for i in range(NUM_OUTPUTS):
             parent_tx.vout.append(CTxOut(child_value, script_pubkey))
-        parent_tx.vout[0].nValue -= 50000
-        assert(parent_tx.vout[0].nValue > 0)
+        parent_tx.vout[0].nValue.setToAmount(parent_tx.vout[0].nValue.getAmount() - 50000)
+        assert(parent_tx.vout[0].nValue.getAmount() > 0)
+        fee = value - (NUM_OUTPUTS*child_value) + 50000
+        if fee > 0:
+            parent_tx.vout.append(CTxOut(fee))
         parent_tx.rehash()
 
         child_tx = CTransaction()
+        total_in = 0
         for i in range(NUM_OUTPUTS):
             child_tx.vin.append(CTxIn(COutPoint(parent_tx.sha256, i), b""))
+            total_in += parent_tx.vout[i].nValue.getAmount()
         child_tx.vout = [CTxOut(value - 100000, CScript([OP_TRUE]))]
+        child_tx.vout.append(CTxOut(total_in - (value - 100000))) # fee
         for i in range(NUM_OUTPUTS):
             child_tx.wit.vtxinwit.append(CTxInWitness())
             child_tx.wit.vtxinwit[-1].scriptWitness.stack = [b'a' * 195] * (2 * NUM_DROPS) + [witness_program]
@@ -976,9 +999,8 @@ def test_witness_block_size(self):
         i = 0
         while additional_bytes > 0:
             # Add some more bytes to each input until we hit MAX_BLOCK_BASE_SIZE+1
-            # ELEMENTS: mysterious off by 1 difference
-            #extra_bytes = min(additional_bytes + 1, 55)
-            extra_bytes = min(additional_bytes + 2, 55)
+            # ELEMENTS: mysterious off by 3 difference
+            extra_bytes = min(additional_bytes + 4, 55)
             block.vtx[-1].wit.vtxinwit[int(i / (2 * NUM_DROPS))].scriptWitness.stack[i % (2 * NUM_DROPS)] = b'a' * (195 + extra_bytes)
             additional_bytes -= extra_bytes
             i += 1
@@ -1000,13 +1022,13 @@ def test_witness_block_size(self):
         block.vtx[0].vout.pop()
         add_witness_commitment(block)
         block.solve()
-        assert(get_virtual_size(block) == MAX_BLOCK_BASE_SIZE)
+        assert_equal(get_virtual_size(block), MAX_BLOCK_BASE_SIZE)
 
         test_witness_block(self.nodes[0], self.test_node, block, accepted=True)
 
         # Update available utxo's
         self.utxo.pop(0)
-        self.utxo.append(UTXO(block.vtx[-1].sha256, 0, block.vtx[-1].vout[0].nValue))
+        self.utxo.append(UTXO(block.vtx[-1].sha256, 0, block.vtx[-1].vout[0].nValue.getAmount()))
 
     @subtest
     def test_submit_block(self):
@@ -1059,6 +1081,7 @@ def test_extra_witness_data(self):
         tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
         tx.vout.append(CTxOut(self.utxo[0].nValue - 2000, script_pubkey))
         tx.vout.append(CTxOut(1000, CScript([OP_TRUE])))  # non-witness output
+        tx.vout.append(CTxOut(1000)) # fee
         tx.wit.vtxinwit.append(CTxInWitness())
         tx.wit.vtxinwit[0].scriptWitness.stack = [CScript([])]
         tx.rehash()
@@ -1081,7 +1104,8 @@ def test_extra_witness_data(self):
         tx2 = CTransaction()
         tx2.vin.append(CTxIn(COutPoint(tx.sha256, 0), b""))  # witness output
         tx2.vin.append(CTxIn(COutPoint(tx.sha256, 1), b""))  # non-witness
-        tx2.vout.append(CTxOut(tx.vout[0].nValue, CScript([OP_TRUE])))
+        tx2.vout.append(CTxOut(tx.vout[0].nValue.getAmount(), CScript([OP_TRUE])))
+        tx2.vout.append(CTxOut(tx.vout[1].nValue.getAmount())) # fee
         tx2.wit.vtxinwit.extend([CTxInWitness(), CTxInWitness()])
         tx2.wit.vtxinwit[0].scriptWitness.stack = [CScript([CScriptNum(1)]), CScript([CScriptNum(1)]), witness_program]
         tx2.wit.vtxinwit[1].scriptWitness.stack = [CScript([OP_TRUE])]
@@ -1115,7 +1139,7 @@ def test_extra_witness_data(self):
 
         # Update utxo for later tests
         self.utxo.pop(0)
-        self.utxo.append(UTXO(tx2.sha256, 0, tx2.vout[0].nValue))
+        self.utxo.append(UTXO(tx2.sha256, 0, tx2.vout[0].nValue.getAmount()))
 
     @subtest
     def test_max_witness_push_length(self):
@@ -1130,11 +1154,13 @@ def test_max_witness_push_length(self):
         tx = CTransaction()
         tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
         tx.vout.append(CTxOut(self.utxo[0].nValue - 1000, script_pubkey))
+        tx.vout.append(CTxOut(1000)) # fee
         tx.rehash()
 
         tx2 = CTransaction()
         tx2.vin.append(CTxIn(COutPoint(tx.sha256, 0), b""))
-        tx2.vout.append(CTxOut(tx.vout[0].nValue - 1000, CScript([OP_TRUE])))
+        tx2.vout.append(CTxOut(tx.vout[0].nValue.getAmount() - 1000, CScript([OP_TRUE])))
+        tx2.vout.append(CTxOut(1000)) # fee
         tx2.wit.vtxinwit.append(CTxInWitness())
         # First try a 521-byte stack element
         tx2.wit.vtxinwit[0].scriptWitness.stack = [b'a' * (MAX_SCRIPT_ELEMENT_SIZE + 1), witness_program]
@@ -1152,7 +1178,7 @@ def test_max_witness_push_length(self):
 
         # Update the utxo for later tests
         self.utxo.pop()
-        self.utxo.append(UTXO(tx2.sha256, 0, tx2.vout[0].nValue))
+        self.utxo.append(UTXO(tx2.sha256, 0, tx2.vout[0].nValue.getAmount()))
 
     @subtest
     def test_max_witness_program_length(self):
@@ -1171,11 +1197,13 @@ def test_max_witness_program_length(self):
         tx = CTransaction()
         tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
         tx.vout.append(CTxOut(self.utxo[0].nValue - 1000, long_script_pubkey))
+        tx.vout.append(CTxOut(1000)) # fee
         tx.rehash()
 
         tx2 = CTransaction()
         tx2.vin.append(CTxIn(COutPoint(tx.sha256, 0), b""))
-        tx2.vout.append(CTxOut(tx.vout[0].nValue - 1000, CScript([OP_TRUE])))
+        tx2.vout.append(CTxOut(tx.vout[0].nValue.getAmount() - 1000, CScript([OP_TRUE])))
+        tx2.vout.append(CTxOut(1000)) # fee
         tx2.wit.vtxinwit.append(CTxInWitness())
         tx2.wit.vtxinwit[0].scriptWitness.stack = [b'a'] * 44 + [long_witness_program]
         tx2.rehash()
@@ -1190,7 +1218,7 @@ def test_max_witness_program_length(self):
         witness_hash = sha256(witness_program)
         script_pubkey = CScript([OP_0, witness_hash])
 
-        tx.vout[0] = CTxOut(tx.vout[0].nValue, script_pubkey)
+        tx.vout[0] = CTxOut(tx.vout[0].nValue.getAmount(), script_pubkey)
         tx.rehash()
         tx2.vin[0].prevout.hash = tx.sha256
         tx2.wit.vtxinwit[0].scriptWitness.stack = [b'a'] * 43 + [witness_program]
@@ -1200,7 +1228,7 @@ def test_max_witness_program_length(self):
         test_witness_block(self.nodes[0], self.test_node, block, accepted=True)
 
         self.utxo.pop()
-        self.utxo.append(UTXO(tx2.sha256, 0, tx2.vout[0].nValue))
+        self.utxo.append(UTXO(tx2.sha256, 0, tx2.vout[0].nValue.getAmount()))
 
     @subtest
     def test_witness_input_length(self):
@@ -1216,8 +1244,9 @@ def test_witness_input_length(self):
         value = self.utxo[0].nValue
         for i in range(10):
             tx.vout.append(CTxOut(int(value / 10), script_pubkey))
-        tx.vout[0].nValue -= 1000
-        assert(tx.vout[0].nValue >= 0)
+        tx.vout[0].nValue.setToAmount(tx.vout[0].nValue.getAmount() - 1000)
+        assert(tx.vout[0].nValue.getAmount() >= 0)
+        tx.vout.append(CTxOut(1000)) # fee
 
         block = self.build_next_block()
         self.update_witness_block_with_transactions(block, [tx])
@@ -1242,9 +1271,14 @@ def serialize_with_witness(self):
                 return r
 
         tx2 = BrokenCTransaction()
+        total_in = 0
         for i in range(10):
             tx2.vin.append(CTxIn(COutPoint(tx.sha256, i), b""))
+            total_in += tx.vout[i].nValue.getAmount()
         tx2.vout.append(CTxOut(value - 3000, CScript([OP_TRUE])))
+        tx2.vout.append(CTxOut(total_in - (value-3000))) # fee
+        tx2.wit.vtxoutwit = [CTxOutWitness(), CTxOutWitness()]
+        tx2.calc_sha256()
 
         # First try using a too long vtxinwit
         for i in range(11):
@@ -1253,8 +1287,7 @@ def serialize_with_witness(self):
 
         block = self.build_next_block()
         self.update_witness_block_with_transactions(block, [tx2])
-        # ELEMENTS: different serialization so doesn't make sense
-        #test_witness_block(self.nodes[0], self.test_node, block, accepted=False)
+        test_witness_block(self.nodes[0], self.test_node, block, accepted=False)
 
         # Now try using a too short vtxinwit
         tx2.wit.vtxinwit.pop()
@@ -1280,7 +1313,7 @@ def serialize_with_witness(self):
         test_witness_block(self.nodes[0], self.test_node, block, accepted=True)
 
         self.utxo.pop()
-        self.utxo.append(UTXO(tx2.sha256, 0, tx2.vout[0].nValue))
+        self.utxo.append(UTXO(tx2.sha256, 0, tx2.vout[0].nValue.getAmount()))
 
     @subtest
     def test_tx_relay_after_segwit_activation(self):
@@ -1297,6 +1330,7 @@ def test_tx_relay_after_segwit_activation(self):
         tx = CTransaction()
         tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
         tx.vout.append(CTxOut(self.utxo[0].nValue - 1000, CScript([OP_TRUE, OP_DROP] * 15 + [OP_TRUE])))
+        tx.vout.append(CTxOut(1000)) # fee
         tx.wit.vtxinwit.append(CTxInWitness())
         tx.wit.vtxinwit[0].scriptWitness.stack = [b'a']
         tx.rehash()
@@ -1318,7 +1352,8 @@ def test_tx_relay_after_segwit_activation(self):
         script_pubkey = CScript([OP_0, witness_hash])
         tx2 = CTransaction()
         tx2.vin.append(CTxIn(COutPoint(tx_hash, 0), b""))
-        tx2.vout.append(CTxOut(tx.vout[0].nValue - 1000, script_pubkey))
+        tx2.vout.append(CTxOut(tx.vout[0].nValue.getAmount() - 1000, script_pubkey))
+        tx2.vout.append(CTxOut(1000)) # fee
         tx2.rehash()
 
         tx3 = CTransaction()
@@ -1329,7 +1364,8 @@ def test_tx_relay_after_segwit_activation(self):
         p2sh_program = CScript([OP_TRUE])
         p2sh_pubkey = hash160(p2sh_program)
         witness_program2 = CScript([b'a' * 400000])
-        tx3.vout.append(CTxOut(tx2.vout[0].nValue - 1000, CScript([OP_HASH160, p2sh_pubkey, OP_EQUAL])))
+        tx3.vout.append(CTxOut(tx2.vout[0].nValue.getAmount() - 1000, CScript([OP_HASH160, p2sh_pubkey, OP_EQUAL])))
+        tx3.vout.append(CTxOut(1000)) # fee
         tx3.wit.vtxinwit[0].scriptWitness.stack = [witness_program2]
         tx3.rehash()
 
@@ -1340,7 +1376,7 @@ def test_tx_relay_after_segwit_activation(self):
         test_transaction_acceptance(self.nodes[1], self.std_node, tx3, True, False, 'tx-size')
 
         # Remove witness stuffing, instead add extra witness push on stack
-        tx3.vout[0] = CTxOut(tx2.vout[0].nValue - 1000, CScript([OP_TRUE, OP_DROP] * 15 + [OP_TRUE]))
+        tx3.vout[0] = CTxOut(tx2.vout[0].nValue.getAmount() - 1000, CScript([OP_TRUE, OP_DROP] * 15 + [OP_TRUE]))
         tx3.wit.vtxinwit[0].scriptWitness.stack = [CScript([CScriptNum(1)]), witness_program]
         tx3.rehash()
 
@@ -1373,7 +1409,7 @@ def test_tx_relay_after_segwit_activation(self):
         assert_equal(len(self.nodes[0].getrawmempool()), 0)
 
         self.utxo.pop(0)
-        self.utxo.append(UTXO(tx3.sha256, 0, tx3.vout[0].nValue))
+        self.utxo.append(UTXO(tx3.sha256, 0, tx3.vout[0].nValue.getAmount()))
 
     @subtest
     def test_segwit_versions(self):
@@ -1389,6 +1425,7 @@ def test_segwit_versions(self):
             split_value = (self.utxo[0].nValue - 4000) // NUM_SEGWIT_VERSIONS
             for i in range(NUM_SEGWIT_VERSIONS):
                 tx.vout.append(CTxOut(split_value, CScript([OP_TRUE])))
+            tx.vout.append(CTxOut(self.utxo[0].nValue - NUM_SEGWIT_VERSIONS*split_value)) # fee
             tx.rehash()
             block = self.build_next_block()
             self.update_witness_block_with_transactions(block, [tx])
@@ -1408,11 +1445,12 @@ def test_segwit_versions(self):
             script_pubkey = CScript([CScriptOp(version), witness_hash])
             tx.vin = [CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b"")]
             tx.vout = [CTxOut(self.utxo[0].nValue - 1000, script_pubkey)]
+            tx.vout.append(CTxOut(1000)) # fee
             tx.rehash()
             test_transaction_acceptance(self.nodes[1], self.std_node, tx, with_witness=True, accepted=False)
             test_transaction_acceptance(self.nodes[0], self.test_node, tx, with_witness=True, accepted=True)
             self.utxo.pop(0)
-            temp_utxo.append(UTXO(tx.sha256, 0, tx.vout[0].nValue))
+            temp_utxo.append(UTXO(tx.sha256, 0, tx.vout[0].nValue.getAmount()))
 
         self.nodes[0].generate(1)  # Mine all the transactions
         sync_blocks(self.nodes)
@@ -1423,7 +1461,8 @@ def test_segwit_versions(self):
         script_pubkey = CScript([CScriptOp(OP_1), witness_hash])
         tx2 = CTransaction()
         tx2.vin = [CTxIn(COutPoint(tx.sha256, 0), b"")]
-        tx2.vout = [CTxOut(tx.vout[0].nValue - 1000, script_pubkey)]
+        tx2.vout = [CTxOut(tx.vout[0].nValue.getAmount() - 1000, script_pubkey)]
+        tx2.vout.append(CTxOut(1000)) # fee
         tx2.wit.vtxinwit.append(CTxInWitness())
         tx2.wit.vtxinwit[0].scriptWitness.stack = [witness_program]
         tx2.rehash()
@@ -1432,7 +1471,7 @@ def test_segwit_versions(self):
         test_transaction_acceptance(self.nodes[0], self.test_node, tx2, with_witness=True, accepted=True)
         test_transaction_acceptance(self.nodes[1], self.std_node, tx2, with_witness=True, accepted=False)
         temp_utxo.pop()  # last entry in temp_utxo was the output we just spent
-        temp_utxo.append(UTXO(tx2.sha256, 0, tx2.vout[0].nValue))
+        temp_utxo.append(UTXO(tx2.sha256, 0, tx2.vout[0].nValue.getAmount()))
 
         # Spend everything in temp_utxo back to an OP_TRUE output.
         tx3 = CTransaction()
@@ -1443,6 +1482,7 @@ def test_segwit_versions(self):
             total_value += i.nValue
         tx3.wit.vtxinwit[-1].scriptWitness.stack = [witness_program]
         tx3.vout.append(CTxOut(total_value - 1000, CScript([OP_TRUE])))
+        tx3.vout.append(CTxOut(1000)) # fee
         tx3.rehash()
         # Spending a higher version witness output is not allowed by policy,
         # even with fRequireStandard=false.
@@ -1455,7 +1495,7 @@ def test_segwit_versions(self):
         sync_blocks(self.nodes)
 
         # Add utxo to our list
-        self.utxo.append(UTXO(tx3.sha256, 0, tx3.vout[0].nValue))
+        self.utxo.append(UTXO(tx3.sha256, 0, tx3.vout[0].nValue.getAmount()))
 
     @subtest
     def test_premature_coinbase_witness_spend(self):
@@ -1473,7 +1513,7 @@ def test_premature_coinbase_witness_spend(self):
 
         spend_tx = CTransaction()
         spend_tx.vin = [CTxIn(COutPoint(block.vtx[0].sha256, 0), b"")]
-        spend_tx.vout = [CTxOut(block.vtx[0].vout[0].nValue, witness_program)]
+        spend_tx.vout = [CTxOut(block.vtx[0].vout[0].nValue.getAmount(), witness_program)]
         spend_tx.wit.vtxinwit.append(CTxInWitness())
         spend_tx.wit.vtxinwit[0].scriptWitness.stack = [witness_program]
         spend_tx.rehash()
@@ -1516,6 +1556,7 @@ def test_uncompressed_pubkey(self):
         tx = CTransaction()
         tx.vin.append(CTxIn(COutPoint(utxo.sha256, utxo.n), b""))
         tx.vout.append(CTxOut(utxo.nValue - 1000, script_pkh))
+        tx.vout.append(CTxOut(1000)) # fee
         tx.rehash()
 
         # Confirm it in a block.
@@ -1531,7 +1572,8 @@ def test_uncompressed_pubkey(self):
 
         tx2 = CTransaction()
         tx2.vin.append(CTxIn(COutPoint(tx.sha256, 0), b""))
-        tx2.vout.append(CTxOut(tx.vout[0].nValue - 1000, script_wsh))
+        tx2.vout.append(CTxOut(tx.vout[0].nValue.getAmount() - 1000, script_wsh))
+        tx2.vout.append(CTxOut(1000)) # fee
         script = get_p2pkh_script(pubkeyhash)
         sig_hash = SegwitVersion1SignatureHash(script, tx2, 0, SIGHASH_ALL, tx.vout[0].nValue)
         signature = key.sign(sig_hash) + b'\x01'  # 0x1 is SIGHASH_ALL
@@ -1555,9 +1597,10 @@ def test_uncompressed_pubkey(self):
 
         tx3 = CTransaction()
         tx3.vin.append(CTxIn(COutPoint(tx2.sha256, 0), b""))
-        tx3.vout.append(CTxOut(tx2.vout[0].nValue - 1000, script_p2sh))
+        tx3.vout.append(CTxOut(tx2.vout[0].nValue.getAmount() - 1000, script_p2sh))
+        tx3.vout.append(CTxOut(1000)) # fee
         tx3.wit.vtxinwit.append(CTxInWitness())
-        sign_p2pk_witness_input(witness_program, tx3, 0, SIGHASH_ALL, tx2.vout[0].nValue, key)
+        sign_p2pk_witness_input(witness_program, tx3, 0, SIGHASH_ALL, tx2.vout[0].nValue.getAmount(), key)
 
         # Should fail policy test.
         test_transaction_acceptance(self.nodes[0], self.test_node, tx3, True, False, 'non-mandatory-script-verify-flag (Using non-compressed keys in segwit)')
@@ -1572,9 +1615,10 @@ def test_uncompressed_pubkey(self):
         script_pubkey = get_p2pkh_script(pubkeyhash)
         tx4 = CTransaction()
         tx4.vin.append(CTxIn(COutPoint(tx3.sha256, 0), script_sig))
-        tx4.vout.append(CTxOut(tx3.vout[0].nValue - 1000, script_pubkey))
+        tx4.vout.append(CTxOut(tx3.vout[0].nValue.getAmount() - 1000, script_pubkey))
+        tx4.vout.append(CTxOut(1000)) # fee
         tx4.wit.vtxinwit.append(CTxInWitness())
-        sign_p2pk_witness_input(witness_program, tx4, 0, SIGHASH_ALL, tx3.vout[0].nValue, key)
+        sign_p2pk_witness_input(witness_program, tx4, 0, SIGHASH_ALL, tx3.vout[0].nValue.getAmount(), key)
 
         # Should fail policy test.
         test_transaction_acceptance(self.nodes[0], self.test_node, tx4, True, False, 'non-mandatory-script-verify-flag (Using non-compressed keys in segwit)')
@@ -1586,7 +1630,8 @@ def test_uncompressed_pubkey(self):
         # transactions.
         tx5 = CTransaction()
         tx5.vin.append(CTxIn(COutPoint(tx4.sha256, 0), b""))
-        tx5.vout.append(CTxOut(tx4.vout[0].nValue - 1000, CScript([OP_TRUE])))
+        tx5.vout.append(CTxOut(tx4.vout[0].nValue.getAmount() - 1000, CScript([OP_TRUE])))
+        tx5.vout.append(CTxOut(1000)) # fee
         (sig_hash, err) = SignatureHash(script_pubkey, tx5, 0, SIGHASH_ALL)
         signature = key.sign(sig_hash) + b'\x01'  # 0x1 is SIGHASH_ALL
         tx5.vin[0].scriptSig = CScript([signature, pubkey])
@@ -1596,7 +1641,7 @@ def test_uncompressed_pubkey(self):
         block = self.build_next_block()
         self.update_witness_block_with_transactions(block, [tx5])
         test_witness_block(self.nodes[0], self.test_node, block, accepted=True)
-        self.utxo.append(UTXO(tx5.sha256, 0, tx5.vout[0].nValue))
+        self.utxo.append(UTXO(tx5.sha256, 0, tx5.vout[0].nValue.getAmount()))
 
     @subtest
     def test_signature_version_1(self):
@@ -1613,6 +1658,7 @@ def test_signature_version_1(self):
         tx = CTransaction()
         tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
         tx.vout.append(CTxOut(self.utxo[0].nValue - 1000, script_pubkey))
+        tx.vout.append(CTxOut(1000)) # fee
         tx.rehash()
 
         test_transaction_acceptance(self.nodes[0], self.test_node, tx, with_witness=True, accepted=True)
@@ -1624,7 +1670,7 @@ def test_signature_version_1(self):
         self.utxo.pop(0)
 
         # Test each hashtype
-        prev_utxo = UTXO(tx.sha256, 0, tx.vout[0].nValue)
+        prev_utxo = UTXO(tx.sha256, 0, tx.vout[0].nValue.getAmount())
         for sigflag in [0, SIGHASH_ANYONECANPAY]:
             for hashtype in [SIGHASH_ALL, SIGHASH_NONE, SIGHASH_SINGLE]:
                 hashtype |= sigflag
@@ -1632,6 +1678,7 @@ def test_signature_version_1(self):
                 tx = CTransaction()
                 tx.vin.append(CTxIn(COutPoint(prev_utxo.sha256, prev_utxo.n), b""))
                 tx.vout.append(CTxOut(prev_utxo.nValue - 1000, script_pubkey))
+                tx.vout.append(CTxOut(1000)) # fee
                 tx.wit.vtxinwit.append(CTxInWitness())
                 # Too-large input value
                 sign_p2pk_witness_input(witness_program, tx, 0, hashtype, prev_utxo.nValue + 1, key)
@@ -1650,7 +1697,7 @@ def test_signature_version_1(self):
                 self.update_witness_block_with_transactions(block, [tx])
                 test_witness_block(self.nodes[0], self.test_node, block, accepted=True)
 
-                prev_utxo = UTXO(tx.sha256, 0, tx.vout[0].nValue)
+                prev_utxo = UTXO(tx.sha256, 0, tx.vout[0].nValue.getAmount())
 
         # Test combinations of signature hashes.
         # Split the utxo into a lot of outputs.
@@ -1665,6 +1712,7 @@ def test_signature_version_1(self):
         split_value = prev_utxo.nValue // NUM_SIGHASH_TESTS
         for i in range(NUM_SIGHASH_TESTS):
             tx.vout.append(CTxOut(split_value, script_pubkey))
+        tx.vout.append(CTxOut(prev_utxo.nValue - NUM_SIGHASH_TESTS*split_value)) # fee
         tx.wit.vtxinwit.append(CTxInWitness())
         sign_p2pk_witness_input(witness_program, tx, 0, SIGHASH_ALL, prev_utxo.nValue, key)
         for i in range(NUM_SIGHASH_TESTS):
@@ -1695,6 +1743,8 @@ def test_signature_version_1(self):
             split_value = total_value // num_outputs
             for i in range(num_outputs):
                 tx.vout.append(CTxOut(split_value, script_pubkey))
+            if total_value % num_outputs > 0:
+                tx.vout.append(CTxOut(total_value - num_outputs*split_value)) # fee
             for i in range(num_inputs):
                 # Now try to sign each input, using a random hashtype.
                 anyonecanpay = 0
@@ -1734,7 +1784,7 @@ def test_signature_version_1(self):
         sign_p2pk_witness_input(witness_program, tx, 0, SIGHASH_ALL, temp_utxos[0].nValue, key)
         tx2 = CTransaction()
         tx2.vin.append(CTxIn(COutPoint(tx.sha256, 0), b""))
-        tx2.vout.append(CTxOut(tx.vout[0].nValue, CScript([OP_TRUE])))
+        tx2.vout.append(CTxOut(tx.vout[0].nValue.getAmount(), CScript([OP_TRUE])))
 
         script = get_p2pkh_script(pubkeyhash)
         sig_hash = SegwitVersion1SignatureHash(script, tx2, 0, SIGHASH_ALL, tx.vout[0].nValue)
@@ -1766,6 +1816,9 @@ def test_signature_version_1(self):
         index = 0
         # Just spend to our usual anyone-can-spend output
         tx.vout = [CTxOut(output_value, CScript([OP_TRUE]))] * 2
+        total_in = sum(i.nValue for i in temp_utxos)
+        if total_in - 2*output_value > 0:
+            tx.vout.append(CTxOut(total_in - 2*output_value)) # fee
         for i in temp_utxos:
             # Use SIGHASH_ALL|SIGHASH_ANYONECANPAY so we can build up
             # the signatures as we go.
@@ -1778,7 +1831,9 @@ def test_signature_version_1(self):
         test_witness_block(self.nodes[0], self.test_node, block, accepted=True)
 
         for i in range(len(tx.vout)):
-            self.utxo.append(UTXO(tx.sha256, i, tx.vout[i].nValue))
+            if tx.vout[i].is_fee():
+                continue
+            self.utxo.append(UTXO(tx.sha256, i, tx.vout[i].nValue.getAmount()))
 
     @subtest
     def test_non_standard_witness_blinding(self):
@@ -1796,6 +1851,7 @@ def test_non_standard_witness_blinding(self):
         tx = CTransaction()
         tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
         tx.vout.append(CTxOut(self.utxo[0].nValue - 1000, script_pubkey))
+        tx.vout.append(CTxOut(1000)) # fee
         tx.rehash()
         test_transaction_acceptance(self.nodes[0], self.test_node, tx, False, True)
         self.nodes[0].generate(1)
@@ -1808,7 +1864,8 @@ def test_non_standard_witness_blinding(self):
         # to the rejection cache.
         tx2 = CTransaction()
         tx2.vin.append(CTxIn(COutPoint(tx.sha256, 0), CScript([p2sh_program])))
-        tx2.vout.append(CTxOut(tx.vout[0].nValue - 1000, script_pubkey))
+        tx2.vout.append(CTxOut(tx.vout[0].nValue.getAmount() - 1000, script_pubkey))
+        tx2.vout.append(CTxOut(1000)) # fee
         tx2.wit.vtxinwit.append(CTxInWitness())
         tx2.wit.vtxinwit[0].scriptWitness.stack = [b'a' * 400]
         tx2.rehash()
@@ -1822,7 +1879,8 @@ def test_non_standard_witness_blinding(self):
         # Now create a new anyone-can-spend utxo for the next test.
         tx3 = CTransaction()
         tx3.vin.append(CTxIn(COutPoint(tx2.sha256, 0), CScript([p2sh_program])))
-        tx3.vout.append(CTxOut(tx2.vout[0].nValue - 1000, CScript([OP_TRUE, OP_DROP] * 15 + [OP_TRUE])))
+        tx3.vout.append(CTxOut(tx2.vout[0].nValue.getAmount() - 1000, CScript([OP_TRUE, OP_DROP] * 15 + [OP_TRUE])))
+        tx3.vout.append(CTxOut(1000)) # fee
         tx3.rehash()
         test_transaction_acceptance(self.nodes[0], self.test_node, tx2, False, True)
         test_transaction_acceptance(self.nodes[0], self.test_node, tx3, False, True)
@@ -1832,7 +1890,7 @@ def test_non_standard_witness_blinding(self):
 
         # Update our utxo list; we spent the first entry.
         self.utxo.pop(0)
-        self.utxo.append(UTXO(tx3.sha256, 0, tx3.vout[0].nValue))
+        self.utxo.append(UTXO(tx3.sha256, 0, tx3.vout[0].nValue.getAmount()))
 
     @subtest
     def test_non_standard_witness(self):
@@ -1859,6 +1917,7 @@ def test_non_standard_witness(self):
             p2wsh_scripts.append(p2wsh)
             tx.vout.append(CTxOut(outputvalue, p2wsh))
             tx.vout.append(CTxOut(outputvalue, CScript([OP_HASH160, p2sh, OP_EQUAL])))
+        tx.vout.append(CTxOut(self.utxo[0].nValue - 2*len(scripts)*outputvalue)) # fee
         tx.rehash()
         txid = tx.sha256
         test_transaction_acceptance(self.nodes[0], self.test_node, tx, with_witness=False, accepted=True)
@@ -1873,12 +1932,14 @@ def test_non_standard_witness(self):
             p2wsh_tx = CTransaction()
             p2wsh_tx.vin.append(CTxIn(COutPoint(txid, i * 2)))
             p2wsh_tx.vout.append(CTxOut(outputvalue - 5000, CScript([OP_0, hash160(hex_str_to_bytes(""))])))
+            p2wsh_tx.vout.append(CTxOut(5000)) # fee
             p2wsh_tx.wit.vtxinwit.append(CTxInWitness())
             p2wsh_tx.rehash()
             p2wsh_txs.append(p2wsh_tx)
             p2sh_tx = CTransaction()
             p2sh_tx.vin.append(CTxIn(COutPoint(txid, i * 2 + 1), CScript([p2wsh_scripts[i]])))
             p2sh_tx.vout.append(CTxOut(outputvalue - 5000, CScript([OP_0, hash160(hex_str_to_bytes(""))])))
+            p2sh_tx.vout.append(CTxOut(5000)) # fee
             p2sh_tx.wit.vtxinwit.append(CTxInWitness())
             p2sh_tx.rehash()
             p2sh_txs.append(p2sh_tx)
@@ -1996,6 +2057,8 @@ def test_witness_sigops(self):
             tx.vout.append(CTxOut(split_value, script_pubkey))
         tx.vout[-2].scriptPubKey = script_pubkey_toomany
         tx.vout[-1].scriptPubKey = script_pubkey_justright
+        if self.utxo[0].nValue % outputs > 0:
+            tx.vout.append(CTxOut(self.utxo[0].nValue - outputs*split_value)) # fee
         tx.rehash()
 
         block_1 = self.build_next_block()
@@ -2010,7 +2073,7 @@ def test_witness_sigops(self):
             tx2.vin.append(CTxIn(COutPoint(tx.sha256, i), b""))
             tx2.wit.vtxinwit.append(CTxInWitness())
             tx2.wit.vtxinwit[-1].scriptWitness.stack = [witness_program]
-            total_value += tx.vout[i].nValue
+            total_value += tx.vout[i].nValue.getAmount()
         tx2.wit.vtxinwit[-1].scriptWitness.stack = [witness_program_toomany]
         tx2.vout.append(CTxOut(total_value, CScript([OP_TRUE])))
         tx2.rehash()
@@ -2023,10 +2086,12 @@ def test_witness_sigops(self):
         # too many sigops (contributing to legacy sigop count).
         checksig_count = (extra_sigops_available // 4) + 1
         script_pubkey_checksigs = CScript([OP_CHECKSIG] * checksig_count)
-        tx2.vout.append(CTxOut(0, script_pubkey_checksigs))
+        # ELEMENTS: no 0-value transactions allowed for non-OP_RETURN outputs
+        tx2.vout.append(CTxOut(1, script_pubkey_checksigs))
+        tx2.vout[0].nValue.setToAmount(tx2.vout[0].nValue.getAmount() - 1)
         tx2.vin.pop()
         tx2.wit.vtxinwit.pop()
-        tx2.vout[0].nValue -= tx.vout[-2].nValue
+        tx2.vout[0].nValue.setToAmount(tx2.vout[0].nValue.getAmount() - tx.vout[-2].nValue.getAmount())
         tx2.rehash()
         block_3 = self.build_next_block()
         self.update_witness_block_with_transactions(block_3, [tx2])
@@ -2047,8 +2112,12 @@ def test_witness_sigops(self):
         # Try replacing the last input of tx2 to be spending the last
         # output of tx
         block_5 = self.build_next_block()
+        # ELEMENTS: need to replace extra value with fee
+        to_replace = tx2.vout[-1].nValue.getAmount()
         tx2.vout.pop()
         tx2.vin.append(CTxIn(COutPoint(tx.sha256, outputs - 1), b""))
+        to_replace +=  tx.vout[outputs-1].nValue.getAmount()
+        tx2.vout.append(CTxOut(to_replace)) # fee
         tx2.wit.vtxinwit.append(CTxInWitness())
         tx2.wit.vtxinwit[-1].scriptWitness.stack = [witness_program_justright]
         tx2.rehash()
diff --git a/test/functional/rpc_createmultisig.py b/test/functional/rpc_createmultisig.py
index 3cc35a7b9a4e0..582260b83a4af 100755
--- a/test/functional/rpc_createmultisig.py
+++ b/test/functional/rpc_createmultisig.py
@@ -43,9 +43,9 @@ def checkbalances(self):
         node0.generate(100)
         self.sync_all()
 
-        bal0 = node0.getbalance()
-        bal1 = node1.getbalance()
-        bal2 = node2.getbalance()
+        bal0 = node0.getbalance()['bitcoin']
+        bal1 = node1.getbalance()['bitcoin']
+        bal2 = node2.getbalance()['bitcoin']
 
         height = node0.getblockchaininfo()["blocks"]
         assert 150 < height < 350
@@ -84,7 +84,7 @@ def do_multisig(self):
         node0.generate(1)
 
         outval = value - decimal.Decimal("0.00001000")
-        rawtx = node2.createrawtransaction([{"txid": txid, "vout": vout}], [{self.final: outval}])
+        rawtx = node2.createrawtransaction([{"txid": txid, "vout": vout}], [{self.final: outval}, {"fee": "0.00001"}])
 
         rawtx2 = node2.signrawtransactionwithkey(rawtx, self.priv[0:self.nsigs-1], prevtxs)
         rawtx3 = node2.signrawtransactionwithkey(rawtx2["hex"], [self.priv[-1]], prevtxs)
diff --git a/test/functional/rpc_decodescript.py b/test/functional/rpc_decodescript.py
index 71c741d0c622c..b0ef427c6530e 100755
--- a/test/functional/rpc_decodescript.py
+++ b/test/functional/rpc_decodescript.py
@@ -166,16 +166,16 @@ def decoderawtransaction_asm_sighashtype(self):
         """
 
         # this test case uses a random plain vanilla mainnet transaction with a single P2PKH input and output
-        tx = '010000000001696a20784a2c70143f634e95227dbdfdf0ecd51647052e70854512235f5986ca010000008a47304402207174775824bec6c2700023309a168231ec80b82c6069282f5133e6f11cbb04460220570edc55c7c5da2ca687ebd0372d3546ebc3f810516a002350cac72dfe192dfb014104d3f898e6487787910a690410b7a917ef198905c27fb9d3b0a42da12aceae0544fc7088d239d9a48f2828a15a09e84043001f27cc80d162cb95404e1210161536ffffffff0100e1f505000000001976a914eb6c6e0cdb2d256a32d97b8df1fc75d1920d9bca88ac11000000'
+        tx = '010000000001696a20784a2c70143f634e95227dbdfdf0ecd51647052e70854512235f5986ca010000008a47304402207174775824bec6c2700023309a168231ec80b82c6069282f5133e6f11cbb04460220570edc55c7c5da2ca687ebd0372d3546ebc3f810516a002350cac72dfe192dfb014104d3f898e6487787910a690410b7a917ef198905c27fb9d3b0a42da12aceae0544fc7088d239d9a48f2828a15a09e84043001f27cc80d162cb95404e1210161536ffffffff0101ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000066a047465737400000000'
         rpc_result = self.nodes[0].decoderawtransaction(tx)
         assert_equal('304402207174775824bec6c2700023309a168231ec80b82c6069282f5133e6f11cbb04460220570edc55c7c5da2ca687ebd0372d3546ebc3f810516a002350cac72dfe192dfb[ALL] 04d3f898e6487787910a690410b7a917ef198905c27fb9d3b0a42da12aceae0544fc7088d239d9a48f2828a15a09e84043001f27cc80d162cb95404e1210161536', rpc_result['vin'][0]['scriptSig']['asm'])
 
         # this test case uses a mainnet transaction that has a P2SH input and both P2PKH and P2SH outputs.
         # it's from James D'Angelo's awesome introductory videos about multisig: https://www.youtube.com/watch?v=zIbUSaZBJgU and https://www.youtube.com/watch?v=OSA1pwlaypc
         # verify that we have not altered scriptPubKey decoding.
-        tx = '0100000000018d1f5635abd06e2c7e2ddf58dc85b3de111e4ad6e0ab51bb0dcf5e84126d927300000000fdfe0000483045022100ae3b4e589dfc9d48cb82d41008dc5fa6a86f94d5c54f9935531924602730ab8002202f88cf464414c4ed9fa11b773c5ee944f66e9b05cc1e51d97abc22ce098937ea01483045022100b44883be035600e9328a01b66c7d8439b74db64187e76b99a68f7893b701d5380220225bf286493e4c4adcf928c40f785422572eb232f84a0b83b0dea823c3a19c75014c695221020743d44be989540d27b1b4bbbcfd17721c337cb6bc9af20eb8a32520b393532f2102c0120a1dda9e51a938d39ddd9fe0ebc45ea97e1d27a7cbd671d5431416d3dd87210213820eb3d5f509d7438c9eeecb4157b2f595105e7cd564b3cdbb9ead3da41eed53aeffffffff02611e0000000000001976a914dc863734a218bfe83ef770ee9d41a27f824a6e5688acee2a02000000000017a9142a5edea39971049a540474c6a99edf0aa4074c588700000000'
+        tx = '0100000000018d1f5635abd06e2c7e2ddf58dc85b3de111e4ad6e0ab51bb0dcf5e84126d927300000000fdfe0000483045022100ae3b4e589dfc9d48cb82d41008dc5fa6a86f94d5c54f9935531924602730ab8002202f88cf464414c4ed9fa11b773c5ee944f66e9b05cc1e51d97abc22ce098937ea01483045022100b44883be035600e9328a01b66c7d8439b74db64187e76b99a68f7893b701d5380220225bf286493e4c4adcf928c40f785422572eb232f84a0b83b0dea823c3a19c75014c695221020743d44be989540d27b1b4bbbcfd17721c337cb6bc9af20eb8a32520b393532f2102c0120a1dda9e51a938d39ddd9fe0ebc45ea97e1d27a7cbd671d5431416d3dd87210213820eb3d5f509d7438c9eeecb4157b2f595105e7cd564b3cdbb9ead3da41eed53aeffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe0010000000000001e61001976a914dc863734a218bfe83ef770ee9d41a27f824a6e5688ac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe0010000000000022aee0017a9142a5edea39971049a540474c6a99edf0aa4074c588700000000'
         rpc_result = self.nodes[0].decoderawtransaction(tx)
-        assert_equal('b7c7a18df6441582674acb436f70a91b0ea03651c79d58d49f7bb987e477ee24', rpc_result['txid'])
+        assert_equal('0640baa19c5df568c1fef1685cf251c33efe2cda37193f3dc2e6b5115774f30a', rpc_result['txid'])
         assert_equal('0 3045022100ae3b4e589dfc9d48cb82d41008dc5fa6a86f94d5c54f9935531924602730ab8002202f88cf464414c4ed9fa11b773c5ee944f66e9b05cc1e51d97abc22ce098937ea[ALL] 3045022100b44883be035600e9328a01b66c7d8439b74db64187e76b99a68f7893b701d5380220225bf286493e4c4adcf928c40f785422572eb232f84a0b83b0dea823c3a19c75[ALL] 5221020743d44be989540d27b1b4bbbcfd17721c337cb6bc9af20eb8a32520b393532f2102c0120a1dda9e51a938d39ddd9fe0ebc45ea97e1d27a7cbd671d5431416d3dd87210213820eb3d5f509d7438c9eeecb4157b2f595105e7cd564b3cdbb9ead3da41eed53ae', rpc_result['vin'][0]['scriptSig']['asm'])
         assert_equal('OP_DUP OP_HASH160 dc863734a218bfe83ef770ee9d41a27f824a6e56 OP_EQUALVERIFY OP_CHECKSIG', rpc_result['vout'][0]['scriptPubKey']['asm'])
         assert_equal('OP_HASH160 2a5edea39971049a540474c6a99edf0aa4074c58 OP_EQUAL', rpc_result['vout'][1]['scriptPubKey']['asm'])
@@ -183,12 +183,12 @@ def decoderawtransaction_asm_sighashtype(self):
         txSave.deserialize(BytesIO(hex_str_to_bytes(tx)))
 
         # make sure that a specifically crafted op_return value will not pass all the IsDERSignature checks and then get decoded as a sighash type
-        tx = '0100000000015ded05872fdbda629c7d3d02b194763ce3b9b1535ea884e3c8e765d42e316724020000006b48304502204c10d4064885c42638cbff3585915b322de33762598321145ba033fc796971e2022100bb153ad3baa8b757e30a2175bd32852d2e1cb9080f84d7e32fcdfd667934ef1b012103163c0ff73511ea1743fb5b98384a2ff09dd06949488028fd819f4d83f56264efffffffff0200000000000000000b6a0930060201000201000180380100000000001976a9141cabd296e753837c086da7a45a6c2fe0d49d7b7b88ac00000000'
+        tx = '0100000000015ded05872fdbda629c7d3d02b194763ce3b9b1535ea884e3c8e765d42e316724020000006b48304502204c10d4064885c42638cbff3585915b322de33762598321145ba033fc796971e2022100bb153ad3baa8b757e30a2175bd32852d2e1cb9080f84d7e32fcdfd667934ef1b012103163c0ff73511ea1743fb5b98384a2ff09dd06949488028fd819f4d83f56264efffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe0010000000000000000000b6a0930060201000201000101ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe0010000000000013880001976a9141cabd296e753837c086da7a45a6c2fe0d49d7b7b88ac00000000'
         rpc_result = self.nodes[0].decoderawtransaction(tx)
         assert_equal('OP_RETURN 300602010002010001', rpc_result['vout'][0]['scriptPubKey']['asm'])
 
         # verify that we have not altered scriptPubKey processing even of a specially crafted P2PKH pubkeyhash and P2SH redeem script hash that is made to pass the der signature checks
-        tx = '0100000000018d1f5635abd06e2c7e2ddf58dc85b3de111e4ad6e0ab51bb0dcf5e84126d927300000000fdfe0000483045022100ae3b4e589dfc9d48cb82d41008dc5fa6a86f94d5c54f9935531924602730ab8002202f88cf464414c4ed9fa11b773c5ee944f66e9b05cc1e51d97abc22ce098937ea01483045022100b44883be035600e9328a01b66c7d8439b74db64187e76b99a68f7893b701d5380220225bf286493e4c4adcf928c40f785422572eb232f84a0b83b0dea823c3a19c75014c695221020743d44be989540d27b1b4bbbcfd17721c337cb6bc9af20eb8a32520b393532f2102c0120a1dda9e51a938d39ddd9fe0ebc45ea97e1d27a7cbd671d5431416d3dd87210213820eb3d5f509d7438c9eeecb4157b2f595105e7cd564b3cdbb9ead3da41eed53aeffffffff02611e0000000000001976a914301102070101010101010102060101010101010188acee2a02000000000017a91430110207010101010101010206010101010101018700000000'
+        tx = '0100000000018d1f5635abd06e2c7e2ddf58dc85b3de111e4ad6e0ab51bb0dcf5e84126d927300000000fdfe0000483045022100ae3b4e589dfc9d48cb82d41008dc5fa6a86f94d5c54f9935531924602730ab8002202f88cf464414c4ed9fa11b773c5ee944f66e9b05cc1e51d97abc22ce098937ea01483045022100b44883be035600e9328a01b66c7d8439b74db64187e76b99a68f7893b701d5380220225bf286493e4c4adcf928c40f785422572eb232f84a0b83b0dea823c3a19c75014c695221020743d44be989540d27b1b4bbbcfd17721c337cb6bc9af20eb8a32520b393532f2102c0120a1dda9e51a938d39ddd9fe0ebc45ea97e1d27a7cbd671d5431416d3dd87210213820eb3d5f509d7438c9eeecb4157b2f595105e7cd564b3cdbb9ead3da41eed53aeffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe0010000000000001e61001976a914301102070101010101010102060101010101010188ac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe0010000000000022aee0017a91430110207010101010101010206010101010101018700000000'
         rpc_result = self.nodes[0].decoderawtransaction(tx)
         assert_equal('OP_DUP OP_HASH160 3011020701010101010101020601010101010101 OP_EQUALVERIFY OP_CHECKSIG', rpc_result['vout'][0]['scriptPubKey']['asm'])
         assert_equal('OP_HASH160 3011020701010101010101020601010101010101 OP_EQUAL', rpc_result['vout'][1]['scriptPubKey']['asm'])
diff --git a/test/functional/rpc_fundrawtransaction.py b/test/functional/rpc_fundrawtransaction.py
index 07ffcab5874db..139916de499c5 100755
--- a/test/functional/rpc_fundrawtransaction.py
+++ b/test/functional/rpc_fundrawtransaction.py
@@ -27,6 +27,7 @@ def get_unspent(listunspent, amount):
 class RawTransactionsTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 4
+        self.extra_args = [["-blindedaddresses=1"]] * self.num_nodes
         self.setup_clean_chain = True
 
     def skip_test_if_missing_module(self):
@@ -54,6 +55,7 @@ def run_test(self):
 
         #            = 2 bytes * minRelayTxFeePerByte
         feeTolerance = 2 * min_relay_tx_fee/1000
+        # ELEMENTS NOTE: fee deltas will be negative due to blinding and no blinding in rawtransaction
 
         self.nodes[2].generate(1)
         self.sync_all()
@@ -67,8 +69,10 @@ def run_test(self):
 
         watchonly_address = self.nodes[0].getnewaddress()
         watchonly_pubkey = self.nodes[0].getaddressinfo(watchonly_address)["pubkey"]
+        watchonly_blindingkey = self.nodes[0].dumpblindingkey(watchonly_address)
         watchonly_amount = Decimal(200)
         self.nodes[3].importpubkey(watchonly_pubkey, "", True)
+        self.nodes[3].importblindingkey(watchonly_address, watchonly_blindingkey)
         watchonly_txid = self.nodes[0].sendtoaddress(watchonly_address, watchonly_amount)
 
         # Lock UTXO so nodes[0] doesn't accidentally spend it
@@ -159,6 +163,8 @@ def run_test(self):
         dec_tx  = self.nodes[2].decoderawtransaction(rawtxfund['hex'])
         totalOut = 0
         for out in dec_tx['vout']:
+            if out["scriptPubKey"]["type"] == "fee":
+                continue
             totalOut += out['value']
 
         assert_equal(fee + totalOut, utx['amount']) #compare vin total and totalout+fee
@@ -180,6 +186,8 @@ def run_test(self):
         dec_tx  = self.nodes[2].decoderawtransaction(rawtxfund['hex'])
         totalOut = 0
         for out in dec_tx['vout']:
+            if out["scriptPubKey"]["type"] == "fee":
+                continue
             totalOut += out['value']
 
         assert_equal(rawtxfund['changepos'], -1)
@@ -227,6 +235,7 @@ def run_test(self):
         assert_equal(utx['txid'], dec_tx['vin'][0]['txid'])
 
         change = self.nodes[2].getnewaddress()
+        change = self.nodes[2].getaddressinfo(change)["unconfidential"]
         assert_raises_rpc_error(-8, "changePosition out of bounds", self.nodes[2].fundrawtransaction, rawtx, {'changeAddress':change, 'changePosition':2})
         rawtxfund = self.nodes[2].fundrawtransaction(rawtx, {'changeAddress': change, 'changePosition': 0})
         dec_tx  = self.nodes[2].decoderawtransaction(rawtxfund['hex'])
@@ -254,6 +263,7 @@ def run_test(self):
 
         inputs  = [ {'txid' : utx['txid'], 'vout' : utx['vout']}]
         outputs = { self.nodes[0].getnewaddress() : 1.0 }
+        output_addrs = [ self.nodes[0].getaddressinfo(addr)["unconfidential"] for addr in outputs.keys() ]
         rawtx   = self.nodes[2].createrawtransaction(inputs, outputs)
 
         # 4-byte version + 1-byte vin count + 36-byte prevout then script_len
@@ -269,8 +279,10 @@ def run_test(self):
         totalOut = 0
         matchingOuts = 0
         for i, out in enumerate(dec_tx['vout']):
+            if out["scriptPubKey"]["type"] == "fee":
+                continue
             totalOut += out['value']
-            if out['scriptPubKey']['addresses'][0] in outputs:
+            if out['scriptPubKey']['addresses'][0] in output_addrs:
                 matchingOuts+=1
             else:
                 assert_equal(i, rawtxfund['changepos'])
@@ -279,7 +291,7 @@ def run_test(self):
         assert_equal("00", dec_tx['vin'][0]['scriptSig']['hex'])
 
         assert_equal(matchingOuts, 1)
-        assert_equal(len(dec_tx['vout']), 2)
+        assert_equal(len(dec_tx['vout']), 3)
 
 
         ###########################################
@@ -290,6 +302,7 @@ def run_test(self):
 
         inputs  = [ {'txid' : utx['txid'], 'vout' : utx['vout']},{'txid' : utx2['txid'], 'vout' : utx2['vout']} ]
         outputs = { self.nodes[0].getnewaddress() : 6.0 }
+        output_addrs = [ self.nodes[0].getaddressinfo(addr)["unconfidential"] for addr in outputs.keys() ]
         rawtx   = self.nodes[2].createrawtransaction(inputs, outputs)
         dec_tx  = self.nodes[2].decoderawtransaction(rawtx)
         assert_equal(utx['txid'], dec_tx['vin'][0]['txid'])
@@ -300,12 +313,14 @@ def run_test(self):
         totalOut = 0
         matchingOuts = 0
         for out in dec_tx['vout']:
+            if out["scriptPubKey"]["type"] == "fee":
+                continue
             totalOut += out['value']
-            if out['scriptPubKey']['addresses'][0] in outputs:
+            if out['scriptPubKey']['addresses'][0] in output_addrs:
                 matchingOuts+=1
 
         assert_equal(matchingOuts, 1)
-        assert_equal(len(dec_tx['vout']), 2)
+        assert_equal(len(dec_tx['vout']), 3)
 
         matchingIns = 0
         for vinOut in dec_tx['vin']:
@@ -323,6 +338,7 @@ def run_test(self):
 
         inputs  = [ {'txid' : utx['txid'], 'vout' : utx['vout']},{'txid' : utx2['txid'], 'vout' : utx2['vout']} ]
         outputs = { self.nodes[0].getnewaddress() : 6.0, self.nodes[0].getnewaddress() : 1.0 }
+        output_addrs = [ self.nodes[0].getaddressinfo(addr)["unconfidential"] for addr in outputs.keys() ]
         rawtx   = self.nodes[2].createrawtransaction(inputs, outputs)
         dec_tx  = self.nodes[2].decoderawtransaction(rawtx)
         assert_equal(utx['txid'], dec_tx['vin'][0]['txid'])
@@ -333,12 +349,14 @@ def run_test(self):
         totalOut = 0
         matchingOuts = 0
         for out in dec_tx['vout']:
+            if out["scriptPubKey"]["type"] == "fee":
+                continue
             totalOut += out['value']
-            if out['scriptPubKey']['addresses'][0] in outputs:
+            if out['scriptPubKey']['addresses'][0] in output_addrs:
                 matchingOuts+=1
 
         assert_equal(matchingOuts, 2)
-        assert_equal(len(dec_tx['vout']), 3)
+        assert_equal(len(dec_tx['vout']), 4)
 
         ##############################################
         # test a fundrawtransaction with invalid vin #
@@ -363,7 +381,7 @@ def run_test(self):
 
         #compare fee
         feeDelta = Decimal(fundedTx['fee']) - Decimal(signedFee)
-        assert(feeDelta >= 0 and feeDelta <= feeTolerance)
+        assert(feeDelta <= feeTolerance)
         ############################################################
 
         ############################################################
@@ -378,7 +396,7 @@ def run_test(self):
 
         #compare fee
         feeDelta = Decimal(fundedTx['fee']) - Decimal(signedFee)
-        assert(feeDelta >= 0 and feeDelta <= feeTolerance)
+        assert(feeDelta <= feeTolerance)
         ############################################################
 
 
@@ -405,7 +423,7 @@ def run_test(self):
 
         #compare fee
         feeDelta = Decimal(fundedTx['fee']) - Decimal(signedFee)
-        assert(feeDelta >= 0 and feeDelta <= feeTolerance)
+        assert(feeDelta <= feeTolerance)
         ############################################################
 
 
@@ -438,7 +456,7 @@ def run_test(self):
 
         #compare fee
         feeDelta = Decimal(fundedTx['fee']) - Decimal(signedFee)
-        assert(feeDelta >= 0 and feeDelta <= feeTolerance)
+        assert(feeDelta <= feeTolerance)
         ############################################################
 
 
@@ -461,7 +479,7 @@ def run_test(self):
         self.nodes[1].generate(1)
         self.sync_all()
 
-        oldBalance = self.nodes[1].getbalance()
+        oldBalance = self.nodes[1].getbalance()['bitcoin']
         inputs = []
         outputs = {self.nodes[1].getnewaddress():1.1}
         rawtx = self.nodes[2].createrawtransaction(inputs, outputs)
@@ -474,7 +492,7 @@ def run_test(self):
         self.sync_all()
 
         # make sure funds are received at node1
-        assert_equal(oldBalance+Decimal('1.10000000'), self.nodes[1].getbalance())
+        assert_equal(oldBalance+Decimal('1.10000000'), self.nodes[1].getbalance()['bitcoin'])
 
         ############################################################
         # locked wallet test
@@ -513,22 +531,23 @@ def run_test(self):
 
         assert_raises_rpc_error(-13, "walletpassphrase", self.nodes[1].sendtoaddress, self.nodes[0].getnewaddress(), 1.2)
 
-        oldBalance = self.nodes[0].getbalance()
+        oldBalance = self.nodes[0].getbalance()['bitcoin']
 
         inputs = []
         outputs = {self.nodes[0].getnewaddress():1.1}
         rawtx = self.nodes[1].createrawtransaction(inputs, outputs)
         fundedTx = self.nodes[1].fundrawtransaction(rawtx)
+        blindedTx = self.nodes[1].blindrawtransaction(fundedTx['hex'])
 
         #now we need to unlock
         self.nodes[1].walletpassphrase("test", 600)
-        signedTx = self.nodes[1].signrawtransactionwithwallet(fundedTx['hex'])
+        signedTx = self.nodes[1].signrawtransactionwithwallet(blindedTx)
         txId = self.nodes[1].sendrawtransaction(signedTx['hex'])
         self.nodes[1].generate(1)
         self.sync_all()
 
         # make sure funds are received at node1
-        assert_equal(oldBalance+Decimal('51.10000000'), self.nodes[0].getbalance())
+        assert_equal(oldBalance+Decimal('51.10000000'), self.nodes[0].getbalance()['bitcoin'])
 
 
         ###############################################
@@ -536,7 +555,7 @@ def run_test(self):
         ###############################################
 
         #empty node1, send some small coins from node0 to node1
-        self.nodes[1].sendtoaddress(self.nodes[0].getnewaddress(), self.nodes[1].getbalance(), "", "", True)
+        self.nodes[1].sendtoaddress(self.nodes[0].getnewaddress(), self.nodes[1].getbalance()['bitcoin'], "", "", True)
         self.sync_all()
         self.nodes[0].generate(1)
         self.sync_all()
@@ -551,6 +570,7 @@ def run_test(self):
         outputs = {self.nodes[0].getnewaddress():0.15,self.nodes[0].getnewaddress():0.04}
         rawtx = self.nodes[1].createrawtransaction(inputs, outputs)
         fundedTx = self.nodes[1].fundrawtransaction(rawtx)
+        blindedTx = self.nodes[1].blindrawtransaction(fundedTx['hex'])
 
         #create same transaction over sendtoaddress
         txId = self.nodes[1].sendmany("", outputs)
@@ -558,7 +578,7 @@ def run_test(self):
 
         #compare fee
         feeDelta = Decimal(fundedTx['fee']) - Decimal(signedFee)
-        assert(feeDelta >= 0 and feeDelta <= feeTolerance*19) #~19 inputs
+        assert(feeDelta <= feeTolerance*19) #~19 inputs
 
 
         #############################################
@@ -566,7 +586,7 @@ def run_test(self):
         #############################################
 
         #again, empty node1, send some small coins from node0 to node1
-        self.nodes[1].sendtoaddress(self.nodes[0].getnewaddress(), self.nodes[1].getbalance(), "", "", True)
+        self.nodes[1].sendtoaddress(self.nodes[0].getnewaddress(), self.nodes[1].getbalance()['bitcoin'], "", "", True)
         self.sync_all()
         self.nodes[0].generate(1)
         self.sync_all()
@@ -577,18 +597,19 @@ def run_test(self):
         self.sync_all()
 
         #fund a tx with ~20 small inputs
-        oldBalance = self.nodes[0].getbalance()
+        oldBalance = self.nodes[0].getbalance()['bitcoin']
 
         inputs = []
         outputs = {self.nodes[0].getnewaddress():0.15,self.nodes[0].getnewaddress():0.04}
         rawtx = self.nodes[1].createrawtransaction(inputs, outputs)
         fundedTx = self.nodes[1].fundrawtransaction(rawtx)
-        fundedAndSignedTx = self.nodes[1].signrawtransactionwithwallet(fundedTx['hex'])
+        blindedTx = self.nodes[1].blindrawtransaction(fundedTx['hex'])
+        fundedAndSignedTx = self.nodes[1].signrawtransactionwithwallet(blindedTx)
         txId = self.nodes[1].sendrawtransaction(fundedAndSignedTx['hex'])
         self.sync_all()
         self.nodes[0].generate(1)
         self.sync_all()
-        assert_equal(oldBalance+Decimal('50.19000000'), self.nodes[0].getbalance()) #0.19+block reward
+        assert_equal(oldBalance+Decimal('50.19000000'), self.nodes[0].getbalance()['bitcoin']) #0.19+block reward
 
         #####################################################
         # test fundrawtransaction with OP_RETURN and no vin #
@@ -596,7 +617,7 @@ def run_test(self):
 
         # pre-segwit
         #rawtx   = "0100000000010000000000000000066a047465737400000000"
-        rawtx   = "010000000000010000000000000000066a047465737400000000"
+        rawtx   = "0100000000000101ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000000000000066a047465737400000000"
         dec_tx  = self.nodes[2].decoderawtransaction(rawtx)
 
         assert_equal(len(dec_tx['vin']), 0)
@@ -606,7 +627,7 @@ def run_test(self):
         dec_tx  = self.nodes[2].decoderawtransaction(rawtxfund['hex'])
 
         assert_greater_than(len(dec_tx['vin']), 0) # at least one vin
-        assert_equal(len(dec_tx['vout']), 2) # one change output added
+        assert_equal(len(dec_tx['vout']), 3) # one change output added
 
 
         ##################################################
@@ -635,7 +656,10 @@ def run_test(self):
 
         # Backward compatibility test (2nd param is includeWatching)
         result = self.nodes[3].fundrawtransaction(rawtx, True)
-        res_dec = self.nodes[0].decoderawtransaction(result["hex"])
+        blinded_result = self.nodes[3].blindrawtransaction(result['hex'])
+        unblinded_result = self.nodes[3].unblindrawtransaction(blinded_result)
+        #res_dec = self.nodes[0].decoderawtransaction(blinded_result)
+        res_dec = self.nodes[0].decoderawtransaction(unblinded_result['hex'])
         assert_equal(len(res_dec["vin"]), 2)
         assert(res_dec["vin"][0]["txid"] == watchonly_txid or res_dec["vin"][1]["txid"] == watchonly_txid)
 
@@ -643,7 +667,7 @@ def run_test(self):
         assert_greater_than(result["changepos"], -1)
         assert_equal(result["fee"] + res_dec["vout"][result["changepos"]]["value"], watchonly_amount / 10)
 
-        signedtx = self.nodes[3].signrawtransactionwithwallet(result["hex"])
+        signedtx = self.nodes[3].signrawtransactionwithwallet(blinded_result)
         assert(not signedtx["complete"])
         signedtx = self.nodes[0].signrawtransactionwithwallet(signedtx["hex"])
         assert(signedtx["complete"])
diff --git a/test/functional/rpc_rawtransaction.py b/test/functional/rpc_rawtransaction.py
index 6eeb5b95290c9..731fc2ea961a3 100755
--- a/test/functional/rpc_rawtransaction.py
+++ b/test/functional/rpc_rawtransaction.py
@@ -74,7 +74,8 @@ def run_test(self):
         assert_raises_rpc_error(-1, "createrawtransaction", self.nodes[0].createrawtransaction, [])
 
         # Test `createrawtransaction` invalid extra parameters
-        assert_raises_rpc_error(-1, "createrawtransaction", self.nodes[0].createrawtransaction, [], {}, 0, False, 'foo')
+        # ELEMENTS: we have extra elements arguments
+        assert_raises_rpc_error(-1, "createrawtransaction", self.nodes[0].createrawtransaction, [], {}, 0, False, [], 'foo')
 
         # Test `createrawtransaction` invalid `inputs`
         txid = '1d1d4e24ed99057e84c3f80fd8fbec79ed9e1acee37da269356ecea000000000'
@@ -253,18 +254,18 @@ def run_test(self):
         mSigObj = self.nodes[2].addmultisigaddress(2, [addr1Obj['pubkey'], addr1])['address']
 
         #use balance deltas instead of absolute values
-        bal = self.nodes[2].getbalance()
+        bal = self.nodes[2].getbalance()['bitcoin']
 
         # send 1.2 BTC to msig adr
         txId = self.nodes[0].sendtoaddress(mSigObj, 1.2)
         self.sync_all()
         self.nodes[0].generate(1)
         self.sync_all()
-        assert_equal(self.nodes[2].getbalance(), bal+Decimal('1.20000000')) #node2 has both keys of the 2of2 ms addr., tx should affect the balance
+        assert_equal(self.nodes[2].getbalance()['bitcoin'], bal+Decimal('1.20000000')) #node2 has both keys of the 2of2 ms addr., tx should affect the balance
 
 
         # 2of3 test from different nodes
-        bal = self.nodes[2].getbalance()
+        bal = self.nodes[2].getbalance()['bitcoin']
         addr1 = self.nodes[1].getnewaddress()
         addr2 = self.nodes[2].getnewaddress()
         addr3 = self.nodes[2].getnewaddress()
@@ -284,7 +285,7 @@ def run_test(self):
 
         #THIS IS AN INCOMPLETE FEATURE
         #NODE2 HAS TWO OF THREE KEY AND THE FUNDS SHOULD BE SPENDABLE AND COUNT AT BALANCE CALCULATION
-        assert_equal(self.nodes[2].getbalance(), bal) #for now, assume the funds of a 2of3 multisig tx are not marked as spendable
+        assert_equal(self.nodes[2].getbalance()['bitcoin'], bal) #for now, assume the funds of a 2of3 multisig tx are not marked as spendable
 
         txDetails = self.nodes[0].gettransaction(txId, True)
         rawTx = self.nodes[0].decoderawtransaction(txDetails['hex'])
@@ -294,9 +295,10 @@ def run_test(self):
                 vout = outpoint
                 break
 
-        bal = self.nodes[0].getbalance()
+        bal = self.nodes[0].getbalance()['bitcoin']
         inputs = [{ "txid" : txId, "vout" : vout['n'], "scriptPubKey" : vout['scriptPubKey']['hex'], "amount" : vout['value']}]
         outputs = { self.nodes[0].getnewaddress() : 2.19 }
+        outputs["fee"] = vout["value"] - Decimal('2.19')
         rawTx = self.nodes[2].createrawtransaction(inputs, outputs)
         rawTxPartialSigned = self.nodes[1].signrawtransactionwithwallet(rawTx, inputs)
         assert_equal(rawTxPartialSigned['complete'], False) #node1 only has one key, can't comp. sign the tx
@@ -308,10 +310,10 @@ def run_test(self):
         self.sync_all()
         self.nodes[0].generate(1)
         self.sync_all()
-        assert_equal(self.nodes[0].getbalance(), bal+Decimal('50.00000000')+Decimal('2.19000000')) #block reward + tx
+        assert_equal(self.nodes[0].getbalance()['bitcoin'], bal+Decimal('50.00000000')+Decimal('2.19000000')) #block reward + tx
 
         # 2of2 test for combining transactions
-        bal = self.nodes[2].getbalance()
+        bal = self.nodes[2].getbalance()['bitcoin']
         addr1 = self.nodes[1].getnewaddress()
         addr2 = self.nodes[2].getnewaddress()
 
@@ -329,7 +331,7 @@ def run_test(self):
         self.nodes[0].generate(1)
         self.sync_all()
 
-        assert_equal(self.nodes[2].getbalance(), bal) # the funds of a 2of2 multisig tx should not be marked as spendable
+        assert_equal(self.nodes[2].getbalance()['bitcoin'], bal) # the funds of a 2of2 multisig tx should not be marked as spendable
 
         txDetails = self.nodes[0].gettransaction(txId, True)
         rawTx2 = self.nodes[0].decoderawtransaction(txDetails['hex'])
@@ -339,9 +341,10 @@ def run_test(self):
                 vout = outpoint
                 break
 
-        bal = self.nodes[0].getbalance()
+        bal = self.nodes[0].getbalance()['bitcoin']
         inputs = [{ "txid" : txId, "vout" : vout['n'], "scriptPubKey" : vout['scriptPubKey']['hex'], "redeemScript" : mSigObjValid['hex'], "amount" : vout['value']}]
         outputs = { self.nodes[0].getnewaddress() : 2.19 }
+        outputs["fee"] = vout["value"] - Decimal('2.19')
         rawTx2 = self.nodes[2].createrawtransaction(inputs, outputs)
         rawTxPartialSigned1 = self.nodes[1].signrawtransactionwithwallet(rawTx2, inputs)
         self.log.debug(rawTxPartialSigned1)
@@ -357,13 +360,13 @@ def run_test(self):
         self.sync_all()
         self.nodes[0].generate(1)
         self.sync_all()
-        assert_equal(self.nodes[0].getbalance(), bal+Decimal('50.00000000')+Decimal('2.19000000')) #block reward + tx
+        assert_equal(self.nodes[0].getbalance()['bitcoin'], bal+Decimal('50.00000000')+Decimal('2.19000000')) #block reward + tx
 
         # decoderawtransaction tests
         # witness transaction
         # new in core:
         #encrawtx = "010000000001010000000000000072c1a6a246ae63f74f931e8365e15a089c68d61900000000000000000000ffffffff0100e1f50500000000000102616100000000"
-        encrawtx = "0100000000010000000000000072c1a6a246ae63f74f931e8365e15a089c68d61900000000000000000000ffffffff0100e1f505000000000000000000"
+        encrawtx = "0100000001010000000000000072c1a6a246ae63f74f931e8365e15a089c68d61900000000000000000000ffffffff0101ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe0010000000005f5e100000000000000000001026161000000"
         decrawtx = self.nodes[0].decoderawtransaction(encrawtx, True) # decode as witness transaction
         assert_equal(decrawtx['vout'][0]['value'], Decimal('1.00000000'))
 
diff --git a/test/functional/rpc_scantxoutset.py b/test/functional/rpc_scantxoutset.py
index b2939ac4b968f..9510e0e073230 100755
--- a/test/functional/rpc_scantxoutset.py
+++ b/test/functional/rpc_scantxoutset.py
@@ -57,39 +57,39 @@ def run_test(self):
 
         self.restart_node(0, ['-nowallet'])
         self.log.info("Test if we have found the non HD unspent outputs.")
-        assert_equal(self.nodes[0].scantxoutset("start", [ "pkh(" + pubk1 + ")", "pkh(" + pubk2 + ")", "pkh(" + pubk3 + ")"])['total_amount'], Decimal("0.002"))
-        assert_equal(self.nodes[0].scantxoutset("start", [ "wpkh(" + pubk1 + ")", "wpkh(" + pubk2 + ")", "wpkh(" + pubk3 + ")"])['total_amount'], Decimal("0.004"))
-        assert_equal(self.nodes[0].scantxoutset("start", [ "sh(wpkh(" + pubk1 + "))", "sh(wpkh(" + pubk2 + "))", "sh(wpkh(" + pubk3 + "))"])['total_amount'], Decimal("0.001"))
-        assert_equal(self.nodes[0].scantxoutset("start", [ "combo(" + pubk1 + ")", "combo(" + pubk2 + ")", "combo(" + pubk3 + ")"])['total_amount'], Decimal("0.007"))
-        assert_equal(self.nodes[0].scantxoutset("start", [ "addr(" + addr_P2SH_SEGWIT + ")", "addr(" + addr_LEGACY + ")", "addr(" + addr_BECH32 + ")"])['total_amount'], Decimal("0.007"))
-        assert_equal(self.nodes[0].scantxoutset("start", [ "addr(" + addr_P2SH_SEGWIT + ")", "addr(" + addr_LEGACY + ")", "combo(" + pubk3 + ")"])['total_amount'], Decimal("0.007"))
+        assert_equal(self.nodes[0].scantxoutset("start", [ "pkh(" + pubk1 + ")", "pkh(" + pubk2 + ")", "pkh(" + pubk3 + ")"])['total_unblinded_bitcoin_amount'], Decimal("0.002"))
+        assert_equal(self.nodes[0].scantxoutset("start", [ "wpkh(" + pubk1 + ")", "wpkh(" + pubk2 + ")", "wpkh(" + pubk3 + ")"])['total_unblinded_bitcoin_amount'], Decimal("0.004"))
+        assert_equal(self.nodes[0].scantxoutset("start", [ "sh(wpkh(" + pubk1 + "))", "sh(wpkh(" + pubk2 + "))", "sh(wpkh(" + pubk3 + "))"])['total_unblinded_bitcoin_amount'], Decimal("0.001"))
+        assert_equal(self.nodes[0].scantxoutset("start", [ "combo(" + pubk1 + ")", "combo(" + pubk2 + ")", "combo(" + pubk3 + ")"])['total_unblinded_bitcoin_amount'], Decimal("0.007"))
+        assert_equal(self.nodes[0].scantxoutset("start", [ "addr(" + addr_P2SH_SEGWIT + ")", "addr(" + addr_LEGACY + ")", "addr(" + addr_BECH32 + ")"])['total_unblinded_bitcoin_amount'], Decimal("0.007"))
+        assert_equal(self.nodes[0].scantxoutset("start", [ "addr(" + addr_P2SH_SEGWIT + ")", "addr(" + addr_LEGACY + ")", "combo(" + pubk3 + ")"])['total_unblinded_bitcoin_amount'], Decimal("0.007"))
 
         self.log.info("Test extended key derivation.")
-        assert_equal(self.nodes[0].scantxoutset("start", [ "combo(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/0'/0h/0h)"])['total_amount'], Decimal("0.008"))
-        assert_equal(self.nodes[0].scantxoutset("start", [ "combo(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/0'/0'/1h)"])['total_amount'], Decimal("0.016"))
-        assert_equal(self.nodes[0].scantxoutset("start", [ "combo(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/0h/0'/1500')"])['total_amount'], Decimal("0.032"))
-        assert_equal(self.nodes[0].scantxoutset("start", [ "combo(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/0h/0h/0)"])['total_amount'], Decimal("0.064"))
-        assert_equal(self.nodes[0].scantxoutset("start", [ "combo(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/0'/0h/1)"])['total_amount'], Decimal("0.128"))
-        assert_equal(self.nodes[0].scantxoutset("start", [ "combo(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/0h/0'/1500)"])['total_amount'], Decimal("0.256"))
-        assert_equal(self.nodes[0].scantxoutset("start", [ {"desc": "combo(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/0'/0h/*h)", "range": 1499}])['total_amount'], Decimal("0.024"))
-        assert_equal(self.nodes[0].scantxoutset("start", [ {"desc": "combo(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/0'/0'/*h)", "range": 1500}])['total_amount'], Decimal("0.056"))
-        assert_equal(self.nodes[0].scantxoutset("start", [ {"desc": "combo(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/0h/0'/*)", "range": 1499}])['total_amount'], Decimal("0.192"))
-        assert_equal(self.nodes[0].scantxoutset("start", [ {"desc": "combo(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/0'/0h/*)", "range": 1500}])['total_amount'], Decimal("0.448"))
-        assert_equal(self.nodes[0].scantxoutset("start", [ "combo(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/1/1/0')"])['total_amount'], Decimal("0.512"))
-        assert_equal(self.nodes[0].scantxoutset("start", [ "combo(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/1/1/1')"])['total_amount'], Decimal("1.024"))
-        assert_equal(self.nodes[0].scantxoutset("start", [ "combo(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/1/1/1500h)"])['total_amount'], Decimal("2.048"))
-        assert_equal(self.nodes[0].scantxoutset("start", [ "combo(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/1/1/0)"])['total_amount'], Decimal("4.096"))
-        assert_equal(self.nodes[0].scantxoutset("start", [ "combo(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/1/1/1)"])['total_amount'], Decimal("8.192"))
-        assert_equal(self.nodes[0].scantxoutset("start", [ "combo(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/1/1/1500)"])['total_amount'], Decimal("16.384"))
-        assert_equal(self.nodes[0].scantxoutset("start", [ "combo(tpubD6NzVbkrYhZ4WaWSyoBvQwbpLkojyoTZPRsgXELWz3Popb3qkjcJyJUGLnL4qHHoQvao8ESaAstxYSnhyswJ76uZPStJRJCTKvosUCJZL5B/1/1/0)"])['total_amount'], Decimal("4.096"))
-        assert_equal(self.nodes[0].scantxoutset("start", [ "combo(tpubD6NzVbkrYhZ4WaWSyoBvQwbpLkojyoTZPRsgXELWz3Popb3qkjcJyJUGLnL4qHHoQvao8ESaAstxYSnhyswJ76uZPStJRJCTKvosUCJZL5B/1/1/1)"])['total_amount'], Decimal("8.192"))
-        assert_equal(self.nodes[0].scantxoutset("start", [ "combo(tpubD6NzVbkrYhZ4WaWSyoBvQwbpLkojyoTZPRsgXELWz3Popb3qkjcJyJUGLnL4qHHoQvao8ESaAstxYSnhyswJ76uZPStJRJCTKvosUCJZL5B/1/1/1500)"])['total_amount'], Decimal("16.384"))
-        assert_equal(self.nodes[0].scantxoutset("start", [ {"desc": "combo(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/1/1/*')", "range": 1499}])['total_amount'], Decimal("1.536"))
-        assert_equal(self.nodes[0].scantxoutset("start", [ {"desc": "combo(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/1/1/*')", "range": 1500}])['total_amount'], Decimal("3.584"))
-        assert_equal(self.nodes[0].scantxoutset("start", [ {"desc": "combo(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/1/1/*)", "range": 1499}])['total_amount'], Decimal("12.288"))
-        assert_equal(self.nodes[0].scantxoutset("start", [ {"desc": "combo(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/1/1/*)", "range": 1500}])['total_amount'], Decimal("28.672"))
-        assert_equal(self.nodes[0].scantxoutset("start", [ {"desc": "combo(tpubD6NzVbkrYhZ4WaWSyoBvQwbpLkojyoTZPRsgXELWz3Popb3qkjcJyJUGLnL4qHHoQvao8ESaAstxYSnhyswJ76uZPStJRJCTKvosUCJZL5B/1/1/*)", "range": 1499}])['total_amount'], Decimal("12.288"))
-        assert_equal(self.nodes[0].scantxoutset("start", [ {"desc": "combo(tpubD6NzVbkrYhZ4WaWSyoBvQwbpLkojyoTZPRsgXELWz3Popb3qkjcJyJUGLnL4qHHoQvao8ESaAstxYSnhyswJ76uZPStJRJCTKvosUCJZL5B/1/1/*)", "range": 1500}])['total_amount'], Decimal("28.672"))
+        assert_equal(self.nodes[0].scantxoutset("start", [ "combo(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/0'/0h/0h)"])['total_unblinded_bitcoin_amount'], Decimal("0.008"))
+        assert_equal(self.nodes[0].scantxoutset("start", [ "combo(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/0'/0'/1h)"])['total_unblinded_bitcoin_amount'], Decimal("0.016"))
+        assert_equal(self.nodes[0].scantxoutset("start", [ "combo(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/0h/0'/1500')"])['total_unblinded_bitcoin_amount'], Decimal("0.032"))
+        assert_equal(self.nodes[0].scantxoutset("start", [ "combo(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/0h/0h/0)"])['total_unblinded_bitcoin_amount'], Decimal("0.064"))
+        assert_equal(self.nodes[0].scantxoutset("start", [ "combo(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/0'/0h/1)"])['total_unblinded_bitcoin_amount'], Decimal("0.128"))
+        assert_equal(self.nodes[0].scantxoutset("start", [ "combo(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/0h/0'/1500)"])['total_unblinded_bitcoin_amount'], Decimal("0.256"))
+        assert_equal(self.nodes[0].scantxoutset("start", [ {"desc": "combo(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/0'/0h/*h)", "range": 1499}])['total_unblinded_bitcoin_amount'], Decimal("0.024"))
+        assert_equal(self.nodes[0].scantxoutset("start", [ {"desc": "combo(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/0'/0'/*h)", "range": 1500}])['total_unblinded_bitcoin_amount'], Decimal("0.056"))
+        assert_equal(self.nodes[0].scantxoutset("start", [ {"desc": "combo(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/0h/0'/*)", "range": 1499}])['total_unblinded_bitcoin_amount'], Decimal("0.192"))
+        assert_equal(self.nodes[0].scantxoutset("start", [ {"desc": "combo(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/0'/0h/*)", "range": 1500}])['total_unblinded_bitcoin_amount'], Decimal("0.448"))
+        assert_equal(self.nodes[0].scantxoutset("start", [ "combo(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/1/1/0')"])['total_unblinded_bitcoin_amount'], Decimal("0.512"))
+        assert_equal(self.nodes[0].scantxoutset("start", [ "combo(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/1/1/1')"])['total_unblinded_bitcoin_amount'], Decimal("1.024"))
+        assert_equal(self.nodes[0].scantxoutset("start", [ "combo(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/1/1/1500h)"])['total_unblinded_bitcoin_amount'], Decimal("2.048"))
+        assert_equal(self.nodes[0].scantxoutset("start", [ "combo(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/1/1/0)"])['total_unblinded_bitcoin_amount'], Decimal("4.096"))
+        assert_equal(self.nodes[0].scantxoutset("start", [ "combo(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/1/1/1)"])['total_unblinded_bitcoin_amount'], Decimal("8.192"))
+        assert_equal(self.nodes[0].scantxoutset("start", [ "combo(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/1/1/1500)"])['total_unblinded_bitcoin_amount'], Decimal("16.384"))
+        assert_equal(self.nodes[0].scantxoutset("start", [ "combo(tpubD6NzVbkrYhZ4WaWSyoBvQwbpLkojyoTZPRsgXELWz3Popb3qkjcJyJUGLnL4qHHoQvao8ESaAstxYSnhyswJ76uZPStJRJCTKvosUCJZL5B/1/1/0)"])['total_unblinded_bitcoin_amount'], Decimal("4.096"))
+        assert_equal(self.nodes[0].scantxoutset("start", [ "combo(tpubD6NzVbkrYhZ4WaWSyoBvQwbpLkojyoTZPRsgXELWz3Popb3qkjcJyJUGLnL4qHHoQvao8ESaAstxYSnhyswJ76uZPStJRJCTKvosUCJZL5B/1/1/1)"])['total_unblinded_bitcoin_amount'], Decimal("8.192"))
+        assert_equal(self.nodes[0].scantxoutset("start", [ "combo(tpubD6NzVbkrYhZ4WaWSyoBvQwbpLkojyoTZPRsgXELWz3Popb3qkjcJyJUGLnL4qHHoQvao8ESaAstxYSnhyswJ76uZPStJRJCTKvosUCJZL5B/1/1/1500)"])['total_unblinded_bitcoin_amount'], Decimal("16.384"))
+        assert_equal(self.nodes[0].scantxoutset("start", [ {"desc": "combo(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/1/1/*')", "range": 1499}])['total_unblinded_bitcoin_amount'], Decimal("1.536"))
+        assert_equal(self.nodes[0].scantxoutset("start", [ {"desc": "combo(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/1/1/*')", "range": 1500}])['total_unblinded_bitcoin_amount'], Decimal("3.584"))
+        assert_equal(self.nodes[0].scantxoutset("start", [ {"desc": "combo(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/1/1/*)", "range": 1499}])['total_unblinded_bitcoin_amount'], Decimal("12.288"))
+        assert_equal(self.nodes[0].scantxoutset("start", [ {"desc": "combo(tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK/1/1/*)", "range": 1500}])['total_unblinded_bitcoin_amount'], Decimal("28.672"))
+        assert_equal(self.nodes[0].scantxoutset("start", [ {"desc": "combo(tpubD6NzVbkrYhZ4WaWSyoBvQwbpLkojyoTZPRsgXELWz3Popb3qkjcJyJUGLnL4qHHoQvao8ESaAstxYSnhyswJ76uZPStJRJCTKvosUCJZL5B/1/1/*)", "range": 1499}])['total_unblinded_bitcoin_amount'], Decimal("12.288"))
+        assert_equal(self.nodes[0].scantxoutset("start", [ {"desc": "combo(tpubD6NzVbkrYhZ4WaWSyoBvQwbpLkojyoTZPRsgXELWz3Popb3qkjcJyJUGLnL4qHHoQvao8ESaAstxYSnhyswJ76uZPStJRJCTKvosUCJZL5B/1/1/*)", "range": 1500}])['total_unblinded_bitcoin_amount'], Decimal("28.672"))
 
 if __name__ == '__main__':
     ScantxoutsetTest().main()
diff --git a/test/functional/rpc_signrawtransaction.py b/test/functional/rpc_signrawtransaction.py
index 526691b5b56ec..fd06535e6afd5 100755
--- a/test/functional/rpc_signrawtransaction.py
+++ b/test/functional/rpc_signrawtransaction.py
@@ -112,7 +112,7 @@ def script_verification_error_test(self):
         assert not rawTxSigned['errors'][0]['witness']
 
         # Now test signing failure for transaction with input witnesses
-        p2wpkh_raw_tx = "010000000102fff7f7881a8099afa6940d42d1e7f6362bec38171ea3edf433541db4e4ad969f00000000494830450221008b9d1dc26ba6a9cb62127b02742fa9d754cd3bebf337f7a55d114c8e5cdd30be022040529b194ba3f9281a99f2b1c0a19c0489bc22ede944ccf4ecbab4cc618ef3ed01eeffffffef51e1b804cc89d182d279655c3aa89e815b1b309fe287d9b2b55d57b90ec68a0100000000ffffffff02202cb206000000001976a9148280b37df378db99f66f85c95a783a76ac7a6d5988ac9093510d000000001976a9143bde42dbee7e4dbe6a21b2d50ce2f0167faa815988ac1100000000000247304402203609e17b84f6a7d30c80bfa610b5b4542f32a8a0d5447a12fb1366d7f01cc44a0220573a954c4518331561406f90300e8f3358f51928d43c212a8caed02de67eebee0121025476c2e83188368da1ff3e292e7acafcdb3566bb0ad253f62fc70f07aeee635700"
+        p2wpkh_raw_tx = "010000000102fff7f7881a8099afa6940d42d1e7f6362bec38171ea3edf433541db4e4ad969f00000000494830450221008b9d1dc26ba6a9cb62127b02742fa9d754cd3bebf337f7a55d114c8e5cdd30be022040529b194ba3f9281a99f2b1c0a19c0489bc22ede944ccf4ecbab4cc618ef3ed01eeffffffef51e1b804cc89d182d279655c3aa89e815b1b309fe287d9b2b55d57b90ec68a0100000000ffffffff0201ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe0010000000006b22c20001976a9148280b37df378db99f66f85c95a783a76ac7a6d5988ac01ac2e6a47e85fdc2a5a27334544440f2f5135553a7476f4f5e3b9792da6a58fe001000000000d519390001976a9143bde42dbee7e4dbe6a21b2d50ce2f0167faa815988ac110000000000000000000247304402203609e17b84f6a7d30c80bfa610b5b4542f32a8a0d5447a12fb1366d7f01cc44a0220573a954c4518331561406f90300e8f3358f51928d43c212a8caed02de67eebee0121025476c2e83188368da1ff3e292e7acafcdb3566bb0ad253f62fc70f07aeee63570000000000"
 
         rawTxSigned = self.nodes[0].signrawtransactionwithwallet(p2wpkh_raw_tx)
 
diff --git a/test/functional/rpc_tweakfedpeg.py b/test/functional/rpc_tweakfedpeg.py
new file mode 100755
index 0000000000000..4d54bcfbd9ec1
--- /dev/null
+++ b/test/functional/rpc_tweakfedpeg.py
@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+
+import re
+
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import assert_equal
+
+# Example script templates that we get proper responses from elements-0.14 based software
+OP_TRUE_SCRIPT="51"
+OP_CMS_SCRIPT="52210307fd375ed7cced0f50723e3e1a97bbe7ccff7318c815df4e99a59bc94dbcd819210367c4f666f18279009c941e57fab3e42653c6553e5ca092c104d1db279e328a2852ae"
+LIQUID_SCRIPT="745c87635b21020e0338c96a8870479f2396c373cc7696ba124e8635d41b0ea581112b678172612102675333a4e4b8fb51d9d4e22fa5a8eaced3fdac8a8cbf9be8c030f75712e6af992102896807d54bc55c24981f24a453c60ad3e8993d693732288068a23df3d9f50d4821029e51a5ef5db3137051de8323b001749932f2ff0d34c82e96a2c2461de96ae56c2102a4e1a9638d46923272c266631d94d36bdb03a64ee0e14c7518e49d2f29bc40102102f8a00b269f8c5e59c67d36db3cdc11b11b21f64b4bffb2815e9100d9aa8daf072103079e252e85abffd3c401a69b087e590a9b86f33f574f08129ccbd3521ecf516b2103111cf405b627e22135b3b3733a4a34aa5723fb0f58379a16d32861bf576b0ec2210318f331b3e5d38156da6633b31929c5b220349859cc9ca3d33fb4e68aa08401742103230dae6b4ac93480aeab26d000841298e3b8f6157028e47b0897c1e025165de121035abff4281ff00660f99ab27bb53e6b33689c2cd8dcd364bc3c90ca5aea0d71a62103bd45cddfacf2083b14310ae4a84e25de61e451637346325222747b157446614c2103cc297026b06c71cbfa52089149157b5ff23de027ac5ab781800a578192d175462103d3bde5d63bdb3a6379b461be64dad45eabff42f758543a9645afd42f6d4248282103ed1e8d5109c9ed66f7941bc53cc71137baa76d50d274bda8d5e8ffbd6e61fe9a5f6702c00fb275522103aab896d53a8e7d6433137bbba940f9c521e085dd07e60994579b64a6d992cf79210291b7d0b1b692f8f524516ed950872e5da10fb1b808b5a526dedc6fed1cf29807210386aa9372fbab374593466bc5451dc59954e90787f08060964d95c87ef34ca5bb5368ae"
+
+class TweakFedpegTest(BitcoinTestFramework):
+
+    def set_test_params(self):
+        self.num_nodes = 3
+        self.setup_clean_chain = True
+        self.extra_args = [[
+            "-fedpegscript="+OP_TRUE_SCRIPT
+        ],
+        [
+            "-fedpegscript="+OP_CMS_SCRIPT
+        ],
+        [
+            "-fedpegscript="+LIQUID_SCRIPT
+        ]]
+
+    def setup_network(self):
+        self.setup_nodes()
+
+    def run_test(self):
+        # Test that OP_TRUE mainchain_addr/claim_script never changes
+        assert_equal(self.nodes[0].getsidechaininfo()["fedpegscript"], OP_TRUE_SCRIPT)
+        pegin_addr = self.nodes[0].getpeginaddress()
+        for _ in range(5):
+            assert_equal(pegin_addr["mainchain_address"], self.nodes[0].getpeginaddress()["mainchain_address"])
+            assert_equal(self.nodes[0].tweakfedpegscript(pegin_addr["claim_script"])["script"], OP_TRUE_SCRIPT)
+
+        # Test that OP_CMS has all keys change and matches elements-0.14 example
+        pegin_addr = self.nodes[1].getpeginaddress()
+        assert_equal(self.nodes[1].getsidechaininfo()["fedpegscript"], OP_CMS_SCRIPT)
+        nontweak_decoded = self.nodes[1].decodescript(OP_CMS_SCRIPT)["asm"]
+        tweak_decoded = self.nodes[1].decodescript(self.nodes[1].tweakfedpegscript(pegin_addr["claim_script"])["script"])["asm"]
+        for nontweak, tweak in zip(re.split(" ", nontweak_decoded), re.split(" ", tweak_decoded)):
+            assert_equal(len(nontweak), len(tweak)) # same opcodes/push sizes
+            # All pubkeys must be different
+            if len(nontweak) == 66:
+                assert(nontweak != tweak)
+            else:
+                assert_equal(tweak, nontweak)
+
+        # Elements 0.14 Daemon example
+        assert_equal(self.nodes[1].tweakfedpegscript("0014008b1fdbaec5a82a9322af1640e871727245bce1")["script"],
+                "522102f5bc6bc407187d06854005c366b84b411534757f4503587cf335645a620f896a2102fd90164e4e7d53417e4eacfa3f86fd39fe40594791758739e8af31eeea4e79c552ae")
+
+        # Test Liquid-style fedpegscript with CSV emergency keys(which don't get tweaked!)
+        pegin_addr = self.nodes[2].getpeginaddress()
+        assert_equal(self.nodes[2].getsidechaininfo()["fedpegscript"], LIQUID_SCRIPT)
+        nontweak_decoded = self.nodes[2].decodescript(LIQUID_SCRIPT)["asm"]
+        tweak_decoded = self.nodes[2].decodescript(self.nodes[2].tweakfedpegscript(pegin_addr["claim_script"])["script"])["asm"]
+        assert_equal(len(nontweak_decoded), len(tweak_decoded))
+        tweak_match = False # All pubkeys for now must differ
+        for nontweak, tweak in zip(re.split(" ", nontweak_decoded), re.split(" ", tweak_decoded)):
+            assert_equal(len(nontweak), len(tweak)) # same opcodes/push sizes
+            if nontweak == "OP_ELSE":
+                tweak_match = True
+            # All pubkeys must be different
+            if len(nontweak) == 66:
+                assert(tweak_match == (nontweak == tweak))
+            else:
+                assert_equal(tweak, nontweak)
+
+
+        # Liquid Daemon example:
+        assert_equal(self.nodes[2].tweakfedpegscript("0014008b1fdbaec5a82a9322af1640e871727245bce1")["script"],
+                "745c87635b2103258857ed88024e5296436f851337451d3d68522fbb21dc5a047b965cd2f790932103ab43d77e8706a799cee3c14678574bccaca98c101217369cee987073cd2546492102ee5c8dfdf742bcc2b08386a6a3ec4b6087d39a6fd7e6f0fdeb82ecc30b11d0342102b104b6a469d8b3ccf0a671198e5f7d7010dbf2eb5587733b168f6e0d3be75760210207fc37d4877529fb0d63b1de352689627400a43f18717fa182fe0eea283bdd7921025d8724d82c61708458bc1a08ec9a7fcaf0ab6747ccf0a7d378faea07a261ab3e2102af6859d48d0a4518a4811f12adb974bbd051931e3f96f0b6ae16142c43ae6fd12102458215967f7977effc21b964bd92d870ae7eca98f343801031639150139e63ed2102cdef66bf4b5d26d0be22cabd5761970cfa84be905dc0137ad08ab634f104cb9e210297fb764f808c126f46ce0444124213bdc6a18f2904e75c9144f53bed4c19376e2103c631e77d14a5eb2fc61496ee3e9ea19d1e56e7e65a07aaa786f25ffc2921efde210270addb9011a4b41987b0848a8dc52e5442964fe5188c6a4c9320fbb9016390772103bf9aa75444d0013c46dcf10d70831b75b46a25d901fb7c6360beb2f6cac9c503210278f303dbaad1410a26d99e4dca8925fae4c90532a156c29e8ab1abf5ccaa663d210394cc0983add2dc60aa988c9faedebdc5463106184d72dd430ef24d215daf8b935f6702c00fb275522103aab896d53a8e7d6433137bbba940f9c521e085dd07e60994579b64a6d992cf79210291b7d0b1b692f8f524516ed950872e5da10fb1b808b5a526dedc6fed1cf29807210386aa9372fbab374593466bc5451dc59954e90787f08060964d95c87ef34ca5bb5368ae")
+
+
+if __name__ == '__main__':
+    TweakFedpegTest().main()
diff --git a/test/functional/rpc_txoutproof.py b/test/functional/rpc_txoutproof.py
index 867ba25022a67..2c6246eed910f 100755
--- a/test/functional/rpc_txoutproof.py
+++ b/test/functional/rpc_txoutproof.py
@@ -33,13 +33,13 @@ def run_test(self):
 
         chain_height = self.nodes[1].getblockcount()
         assert_equal(chain_height, 105)
-        assert_equal(self.nodes[1].getbalance(), 0)
-        assert_equal(self.nodes[2].getbalance(), 0)
+        assert_equal(self.nodes[1].getbalance()['bitcoin'], 0)
+        assert_equal(self.nodes[2].getbalance()['bitcoin'], 0)
 
         node0utxos = self.nodes[0].listunspent(1)
-        tx1 = self.nodes[0].createrawtransaction([node0utxos.pop()], {self.nodes[1].getnewaddress(): 49.99})
+        tx1 = self.nodes[0].createrawtransaction([node0utxos.pop()], {self.nodes[1].getnewaddress(): 49.99, "fee": 0.01})
         txid1 = self.nodes[0].sendrawtransaction(self.nodes[0].signrawtransactionwithwallet(tx1)["hex"])
-        tx2 = self.nodes[0].createrawtransaction([node0utxos.pop()], {self.nodes[1].getnewaddress(): 49.99})
+        tx2 = self.nodes[0].createrawtransaction([node0utxos.pop()], {self.nodes[1].getnewaddress(): 49.99, "fee": 0.01})
         txid2 = self.nodes[0].sendrawtransaction(self.nodes[0].signrawtransactionwithwallet(tx2)["hex"])
         # This will raise an exception because the transaction is not yet in a block
         assert_raises_rpc_error(-5, "Transaction not yet in block", self.nodes[0].gettxoutproof, [txid1])
@@ -58,7 +58,7 @@ def run_test(self):
         assert_equal(self.nodes[2].verifytxoutproof(self.nodes[2].gettxoutproof([txid1, txid2], blockhash)), txlist)
 
         txin_spent = self.nodes[1].listunspent(1).pop()
-        tx3 = self.nodes[1].createrawtransaction([txin_spent], {self.nodes[0].getnewaddress(): 49.98})
+        tx3 = self.nodes[1].createrawtransaction([txin_spent], {self.nodes[0].getnewaddress(): 49.98, "fee": 0.01})
         txid3 = self.nodes[0].sendrawtransaction(self.nodes[1].signrawtransactionwithwallet(tx3)["hex"])
         self.nodes[0].generate(1)
         self.sync_all()
diff --git a/test/functional/test_framework/blocktools.py b/test/functional/test_framework/blocktools.py
index 13baa3357858c..3d898df3a1c1f 100644
--- a/test/functional/test_framework/blocktools.py
+++ b/test/functional/test_framework/blocktools.py
@@ -18,6 +18,7 @@
     CTxIn,
     CTxInWitness,
     CTxOut,
+    CTxOutValue,
     FromHex,
     ToHex,
     bytes_to_hex_str,
@@ -80,13 +81,20 @@ def add_witness_commitment(block, nonce=0):
     # First calculate the merkle root of the block's
     # transactions, with witnesses.
     witness_nonce = nonce
-    witness_root = block.calc_witness_merkle_root()
+
+    # ELEMENTS: add empty txout to end of coinbase tx
+    block.vtx[0].vout.append(CTxOut())
+    # block.vtx[0].vout[-1].nAsset.setNull() # TODO find out why this breaks stuff
+    # unless you directly put back in a valid .vchCommitment
+
+    witness_root_hex = block.calc_witness_merkle_root()
+    witness_root = uint256_from_str(hex_str_to_bytes(witness_root_hex)[::-1])
     # witness_nonce should go to coinbase witness.
     block.vtx[0].wit.vtxinwit = [CTxInWitness()]
     block.vtx[0].wit.vtxinwit[0].scriptWitness.stack = [ser_uint256(witness_nonce)]
 
     # witness commitment is the last OP_RETURN output in coinbase
-    block.vtx[0].vout.append(CTxOut(0, get_witness_script(witness_root, witness_nonce)))
+    block.vtx[0].vout[-1] = CTxOut(0, get_witness_script(witness_root, witness_nonce))
     block.vtx[0].rehash()
     block.hashMerkleRoot = block.calc_merkle_root()
     block.rehash()
@@ -115,9 +123,10 @@ def create_coinbase(height, pubkey=None):
     coinbase.vin.append(CTxIn(COutPoint(0, 0xffffffff),
                         ser_string(serialize_script_num(height)), 0xffffffff))
     coinbaseoutput = CTxOut()
-    coinbaseoutput.nValue = 50 * COIN
+    value = 50 * COIN
     halvings = int(height / 150)  # regtest
-    coinbaseoutput.nValue >>= halvings
+    value >>= halvings
+    coinbaseoutput.nValue = CTxOutValue(value)
     if (pubkey is not None):
         coinbaseoutput.scriptPubKey = CScript([pubkey, OP_CHECKSIG])
     else:
@@ -126,7 +135,7 @@ def create_coinbase(height, pubkey=None):
     coinbase.calc_sha256()
     return coinbase
 
-def create_tx_with_script(prevtx, n, script_sig=b"", *, amount, script_pub_key=CScript()):
+def create_tx_with_script(prevtx, n, script_sig=b"", *, amount, fee=0, script_pub_key=CScript()):
     """Return one-input, one-output transaction object
        spending the prevtx's n-th output with the given amount.
 
@@ -136,27 +145,29 @@ def create_tx_with_script(prevtx, n, script_sig=b"", *, amount, script_pub_key=C
     assert(n < len(prevtx.vout))
     tx.vin.append(CTxIn(COutPoint(prevtx.sha256, n), script_sig, 0xffffffff))
     tx.vout.append(CTxOut(amount, script_pub_key))
+    if fee > 0:
+        tx.vout.append(CTxOut(fee))
     tx.calc_sha256()
     return tx
 
-def create_transaction(node, txid, to_address, *, amount):
+def create_transaction(node, txid, to_address, *, amount, fee):
     """ Return signed transaction spending the first output of the
         input txid. Note that the node must be able to sign for the
         output that is being spent, and the node must not be running
         multiple wallets.
     """
-    raw_tx = create_raw_transaction(node, txid, to_address, amount=amount)
+    raw_tx = create_raw_transaction(node, txid, to_address, amount=amount, fee=fee)
     tx = CTransaction()
     tx.deserialize(BytesIO(hex_str_to_bytes(raw_tx)))
     return tx
 
-def create_raw_transaction(node, txid, to_address, *, amount):
+def create_raw_transaction(node, txid, to_address, *, amount, fee):
     """ Return raw signed transaction spending the first output of the
         input txid. Note that the node must be able to sign for the
         output that is being spent, and the node must not be running
         multiple wallets.
     """
-    rawtx = node.createrawtransaction(inputs=[{"txid": txid, "vout": 0}], outputs={to_address: amount})
+    rawtx = node.createrawtransaction(inputs=[{"txid": txid, "vout": 0}], outputs={to_address: amount, "fee": fee})
     signresult = node.signrawtransactionwithwallet(rawtx)
     assert_equal(signresult["complete"], True)
     return signresult['hex']
@@ -170,7 +181,7 @@ def get_legacy_sigopcount_block(block, accurate=True):
 def get_legacy_sigopcount_tx(tx, accurate=True):
     count = 0
     for i in tx.vout:
-        count += i.scriptPubKey.GetSigOpCount(accurate)
+        count += CScript(i.scriptPubKey).GetSigOpCount(accurate)
     for j in tx.vin:
         # scriptSig might be of type bytes, so convert to CScript for the moment
         count += CScript(j.scriptSig).GetSigOpCount(accurate)
@@ -204,7 +215,9 @@ def create_witness_tx(node, use_p2wsh, utxo, pubkey, encode_p2sh, amount):
         addr = key_to_p2sh_p2wpkh(pubkey) if encode_p2sh else key_to_p2wpkh(pubkey)
     if not encode_p2sh:
         assert_equal(node.getaddressinfo(addr)['scriptPubKey'], witness_script(use_p2wsh, pubkey))
-    return node.createrawtransaction([utxo], {addr: amount})
+    if "amount" not in utxo:
+        utxo["amount"] = node.gettxout(utxo["txid"], utxo["vout"])["value"]
+    return node.createrawtransaction([utxo], {addr: amount, "fee": utxo["amount"]-amount})
 
 def send_to_witness(use_p2wsh, node, utxo, pubkey, encode_p2sh, amount, sign=True, insert_redeem_script=""):
     """Create a transaction spending a given utxo to a segwit output.
diff --git a/test/functional/test_framework/liquid_addr.py b/test/functional/test_framework/liquid_addr.py
new file mode 100644
index 0000000000000..c8ae77275b096
--- /dev/null
+++ b/test/functional/test_framework/liquid_addr.py
@@ -0,0 +1,106 @@
+#!/usr/bin/env python3
+# Copyright (c) 2017 Pieter Wuille
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+"""Reference implementation for Blech32 and segwit addresses."""
+
+
+CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l"
+
+def blech32_polymod(values):
+    """Internal function that computes the blech32 checksum."""
+    generator = [0x7d52fba40bd886, 0x5e8dbf1a03950c, 0x1c3a3c74072a18, 0x385d72fa0e5139, 0x7093e5a608865b] # new generators, 7 bytes
+    chk = 1
+    for value in values:
+        top = chk >> 55 # 25->55
+        chk = ((chk & 0x7fffffffffffff) << 5) ^^ value # 0x1ffffff->0x7fffffffffffff
+        for i in range(5):
+            chk ^= generator[i] if ((top >> i) & 1) else 0
+    return chk
+
+
+def blech32_hrp_expand(hrp):
+    """Expand the HRP into values for checksum computation."""
+    return [ord(x) >> 5 for x in hrp] + [0] + [ord(x) & 31 for x in hrp]
+
+
+def blech32_verify_checksum(hrp, data):
+    """Verify a checksum given HRP and converted data characters."""
+    return blech32_polymod(blech32_hrp_expand(hrp) + data) == 1
+
+
+def blech32_create_checksum(hrp, data):
+    """Compute the checksum values given HRP and data."""
+    values = blech32_hrp_expand(hrp) + data
+    polymod = blech32_polymod(values + [0]*12) ^^ 1 # 6->12
+    return [(polymod >> 5 * (11 - i)) & 31 for i in range(12)]
+#                            ^ 5                          ^ 6
+
+def blech32_encode(hrp, data):
+    """Compute a blech32 string given HRP and data values."""
+    combined = data + blech32_create_checksum(hrp, data)
+    return hrp + '1' + ''.join([CHARSET[d] for d in combined])
+
+
+def blech32_decode(bech):
+    """Validate a blech32 string, and determine HRP and data."""
+    if ((any(ord(x) < 33 or ord(x) > 126 for x in bech)) or
+            (bech.lower() != bech and bech.upper() != bech)):
+        return (None, None)
+    bech = bech.lower()
+    pos = bech.rfind('1')
+    if pos < 1 or pos + 13 > len(bech) or len(bech) > 1000: # 7->13 90->1000
+        return (None, None)
+    if not all(x in CHARSET for x in bech[pos+1:]):
+        return (None, None)
+    hrp = bech[:pos]
+    data = [CHARSET.find(x) for x in bech[pos+1:]]
+    if not blech32_verify_checksum(hrp, data):
+        return (None, None)
+    return (hrp, data[:-12]) # 6->12
+
+
+def convertbits(data, frombits, tobits, pad=True):
+    """General power-of-2 base conversion."""
+    acc = 0
+    bits = 0
+    ret = []
+    maxv = (1 << tobits) - 1
+    max_acc = (1 << (frombits + tobits - 1)) - 1
+    for value in data:
+        if value < 0 or (value >> frombits):
+            return None
+        acc = ((acc << frombits) | value) & max_acc
+        bits += frombits
+        while bits >= tobits:
+            bits -= tobits
+            ret.append((acc >> bits) & maxv)
+    if pad:
+        if bits:
+            ret.append((acc << (tobits - bits)) & maxv)
+    elif bits >= frombits or ((acc << (tobits - bits)) & maxv):
+        return None
+    return ret
+
+
+def decode(hrp, addr):
+    """Decode a segwit address."""
+    hrpgot, data = blech32_decode(addr)
+    if hrpgot != hrp:
+        return (None, None)
+    decoded = convertbits(data[1:], 5, 8, False)
+    if decoded is None or len(decoded) < 2 or len(decoded) > 40:
+        return (None, None)
+    if data[0] > 16:
+        return (None, None)
+    if data[0] == 0 and len(decoded) != 20 and len(decoded) != 32:
+        return (None, None)
+    return (data[0], decoded)
+
+
+def encode(hrp, witver, witprog):
+    """Encode a segwit address."""
+    ret = blech32_encode(hrp, [witver] + convertbits(witprog, 8, 5))
+    if decode(hrp, ret) == (None, None):
+        return None
+    return ret
diff --git a/test/functional/test_framework/messages.py b/test/functional/test_framework/messages.py
index f262ee2d5b43d..f6ed8bc83e038 100755
--- a/test/functional/test_framework/messages.py
+++ b/test/functional/test_framework/messages.py
@@ -24,7 +24,7 @@
 import time
 
 from test_framework.siphash import siphash256
-from test_framework.util import hex_str_to_bytes, bytes_to_hex_str, calcfastmerkleroot
+from test_framework.util import hex_str_to_bytes, bytes_to_hex_str, calcfastmerkleroot, BITCOIN_ASSET_OUT
 
 MIN_VERSION_SUPPORTED = 60001
 MY_VERSION = 70014  # past bip-31 for ping/pong
@@ -269,6 +269,9 @@ def __init__(self, hash=0, n=0):
         self.hash = hash
         self.n = n
 
+    def isNull(self):
+        return self.hash == 0 and self.n == 4294967295
+
     def deserialize(self, f):
         self.hash = deser_uint256(f)
         self.n = struct.unpack("<I", f.read(4))[0]
@@ -310,26 +313,155 @@ def __repr__(self):
             % (repr(self.prevout), bytes_to_hex_str(self.scriptSig),
                self.nSequence)
 
+class CTxOutAsset(object):
+    def __init__(self, vchCommitment=b"\x00"):
+        self.vchCommitment = vchCommitment
+
+    def setNull(self):
+        self.vchCommitment = b'\x00'
+
+    def deserialize(self, f):
+        version = ord(f.read(1))
+        if version == 0:
+            self.vchCommitment = b'\x00'
+        elif version == 1:
+            self.vchCommitment = b'\x01' + f.read(32)
+        elif version == 0xff:
+            self.vchCommitment = b'\xff' + f.read(32)
+        elif version == 10 or version == 11:
+            self.vchCommitment = bytes([version]) + f.read(32)
+        else:
+            raise 'invalid CTxOutAsset in deserialize'
+
+    def serialize(self):
+        r = b""
+        r += self.vchCommitment
+        return r
+
+    def setToAsset(self, val):
+        if len(val) != 32:
+            raise 'invalid asset hash (expected 32 bytes got %d)' % len(val)
+        self.vchCommitment = b'\x01' + val
+
+    def __repr__(self):
+        return "CTxOutAsset(vchCommitment=%s)" % self.vchCommitment
+
+class CTxOutValue(object):
+
+    def __init__(self, value=None):
+        self.setNull()
+        if value is not None:
+            self.setToAmount(value)
+
+    def setNull(self):
+        self.vchCommitment = b'\x00'
+
+    def deserialize(self, f):
+        version = ord(f.read(1))
+        if version == 0:
+            self.vchCommitment = b'\x00'
+        elif version == 1:
+            self.vchCommitment = b'\x01' + f.read(8)
+        elif version == 0xff:
+            self.vchCommitment = b'\xff' + f.read(8)
+        elif version == 8 or version == 9:
+            self.vchCommitment = bytes([version]) + f.read(32)
+        else:
+            raise Exception('invalid CTxOutValue in deserialize. version %d' % version)
+
+    def serialize(self):
+        r = b""
+        if len(self.vchCommitment) < 1:
+            raise ValueError('invalid commitment')
+        r += self.vchCommitment
+        return r
+
+    def setToAmount(self, amount):
+        commit = [1]*9
+        for i in range(8): #8 bytes
+            commit[8-i] = ((amount >> (i*8)) & 0xff)
+        self.vchCommitment = bytes(commit)
+
+    def getAmount(self):
+        if self.vchCommitment[0] != 1:
+            raise ValueError('getAmount() called on non-explicit CTxOutValue')
+        ret = 0
+        for i in range(8): #8 bytes
+            ret <<= 8
+            ret |= self.vchCommitment[i+1]
+        return ret
+
+    def __repr__(self):
+        return "CTxOutValue(vchCommitment=%s)" % self.vchCommitment
+
+class CTxOutNonce(object):
+    def __init__(self, vchCommitment=b"\x00"):
+        self.vchCommitment = vchCommitment
+
+    def setNull(self):
+        self.vchCommitment = b'\x00'
+
+    def deserialize(self, f):
+        version = ord(f.read(1))
+        if version == 0:
+            self.vchCommitment = b'\x00'
+        elif version == 1:
+            self.vchCommitment = b'\x01' + f.read(32)
+        elif version == 0xff:
+            self.vchCommitment = b'\xff' + f.read(32)
+        elif version == 2 or version == 3:
+            self.vchCommitment = bytes([version]) + f.read(32)
+        else:
+            raise ValueError('invalid CTxOutNonce in deserialize')
+
+    def serialize(self):
+        r = b""
+        r += self.vchCommitment
+        return r
+
+    def __repr__(self):
+        return "CTxOutNonce(vchCommitment=%s)" % self.vchCommitment
+
 
 class CTxOut():
-    def __init__(self, nValue=0, scriptPubKey=b""):
-        self.nValue = nValue
+    def __init__(self, nValue=CTxOutValue(), scriptPubKey=b'', nAsset=CTxOutAsset(BITCOIN_ASSET_OUT), nNonce=CTxOutNonce()):
+        self.nAsset = nAsset
+        if type(nValue) is int:
+            self.nValue = CTxOutValue(nValue)
+        else:
+            self.nValue = nValue
+        self.nNonce = nNonce
         self.scriptPubKey = scriptPubKey
 
+    def setNull(self):
+        self.nAsset.setNull()
+        self.nValue.setNull()
+        self.nNonce.setNull()
+        self.scriptPubKey = b''
+
+    def is_fee(self):
+        return len(self.scriptPubKey) == 0
+
     def deserialize(self, f):
-        self.nValue = struct.unpack("<q", f.read(8))[0]
+        self.nAsset = CTxOutAsset()
+        self.nAsset.deserialize(f)
+        self.nValue = CTxOutValue()
+        self.nValue.deserialize(f)
+        self.nNonce = CTxOutNonce()
+        self.nNonce.deserialize(f)
         self.scriptPubKey = deser_string(f)
 
     def serialize(self):
         r = b""
-        r += struct.pack("<q", self.nValue)
+        r += self.nAsset.serialize()
+        r += self.nValue.serialize()
+        r += self.nNonce.serialize()
         r += ser_string(self.scriptPubKey)
         return r
 
     def __repr__(self):
-        return "CTxOut(nValue=%i.%08i scriptPubKey=%s)" \
-            % (self.nValue // COIN, self.nValue % COIN,
-               bytes_to_hex_str(self.scriptPubKey))
+        return "CTxOut(nAsset=%s nValue=%s nNonce=%s scriptPubKey=%s)" \
+            % (self.nAsset, self.nValue, self.nNonce, bytes_to_hex_str(self.scriptPubKey))
 
 
 class CScriptWitness():
@@ -355,23 +487,23 @@ def __init__(self):
         self.peginWitness = CScriptWitness()
 
     def deserialize(self, f):
-        #TODO(rebase) CA/CT
-        #self.vchIssuanceAmountRangeproof = deser_string(f)
-        #self.vchInflationKeysRangeproof = deser_string(f)
+        self.vchIssuanceAmountRangeproof = deser_string(f)
+        self.vchInflationKeysRangeproof = deser_string(f)
         self.scriptWitness.stack = deser_string_vector(f)
         self.peginWitness.stack = deser_string_vector(f)
 
     def serialize(self):
         r = b''
-        #TODO(rebase) CA/CT
-        #r += ser_string(self.vchIssuanceAmountRangeproof)
-        #r += ser_string(self.vchInflationKeysRangeproof)
+        r += ser_string(self.vchIssuanceAmountRangeproof)
+        r += ser_string(self.vchInflationKeysRangeproof)
         r += ser_string_vector(self.scriptWitness.stack)
         r += ser_string_vector(self.peginWitness.stack)
         return r
 
     def calc_witness_hash(self):
         leaves = [
+            encode(hash256(ser_string(self.vchIssuanceAmountRangeproof))[::-1], 'hex_codec').decode('ascii'),
+            encode(hash256(ser_string(self.vchInflationKeysRangeproof))[::-1], 'hex_codec').decode('ascii'),
             encode(hash256(ser_string_vector(self.scriptWitness.stack))[::-1], 'hex_codec').decode('ascii'),
             encode(hash256(ser_string_vector(self.peginWitness.stack))[::-1], 'hex_codec').decode('ascii')
         ]
@@ -383,8 +515,8 @@ def __repr__(self):
 
     def is_null(self):
         return len(self.vchIssuanceAmountRangeproof) == 0 \
-        and len(self.vchInflationKeysRangeproof) == 0 \
-        and self.scriptWitness.is_null()
+            and len(self.vchInflationKeysRangeproof) == 0 \
+            and self.scriptWitness.is_null()
 
 
 class CTxOutWitness(object):
@@ -425,9 +557,8 @@ def __init__(self):
     def deserialize(self, f):
         for i in range(len(self.vtxinwit)):
             self.vtxinwit[i].deserialize(f)
-        #TODO(rebase) CA/CT
-        #for i in range(len(self.vtxoutwit)):
-        #    self.vtxoutwit[i].deserialize(f)
+        for i in range(len(self.vtxoutwit)):
+            self.vtxoutwit[i].deserialize(f)
 
     def serialize(self):
         r = b""
@@ -436,6 +567,8 @@ def serialize(self):
         # the same length as the transaction's vin vector.
         for x in self.vtxinwit:
             r += x.serialize()
+        for x in self.vtxoutwit:
+            r += x.serialize()
         return r
 
     def __repr__(self):
@@ -510,14 +643,16 @@ def serialize_with_witness(self):
         r += ser_vector(self.vout)
         r += struct.pack("<I", self.nLockTime)
         if flags & 1:
-            if (len(self.wit.vtxinwit) != len(self.vin)):
+            if len(self.wit.vtxinwit) != len(self.vin):
                 # vtxinwit must have the same length as vin
                 self.wit.vtxinwit = self.wit.vtxinwit[:len(self.vin)]
                 for i in range(len(self.wit.vtxinwit), len(self.vin)):
                     self.wit.vtxinwit.append(CTxInWitness())
+            if len(self.wit.vtxoutwit) != len(self.vout):
+                # vtxoutwit must have the same length as vout
                 self.wit.vtxoutwit = self.wit.vtxoutwit[:len(self.vout)]
                 for i in range(len(self.wit.vtxoutwit), len(self.vout)):
-                    self.wit.vtxoutwit.append(CTxInWitness())
+                    self.wit.vtxoutwit.append(CTxOutWitness())
             r += self.wit.serialize()
         return r
 
@@ -543,7 +678,10 @@ def calc_sha256(self, with_witness=False):
     def calc_witness_hash(self):
         leaves = []
         for i in range(len(self.vin)):
-            wit = self.wit.vtxinwit[i] if i < len(self.wit.vtxinwit) else CTxInWitness()
+            if i >= len(self.wit.vtxinwit) or self.vin[i].prevout.isNull():
+                wit = CTxInWitness()
+            else:
+                wit = self.wit.vtxinwit[i]
             leaves.append(wit.calc_witness_hash())
         inwitroot = calcfastmerkleroot(leaves)
 
@@ -553,7 +691,8 @@ def calc_witness_hash(self):
             leaves.append(wit.calc_witness_hash())
         outwitroot = calcfastmerkleroot(leaves)
 
-        return uint256_from_str(hex_str_to_bytes(calcfastmerkleroot([inwitroot, outwitroot]))[::-1])
+        # returns bitcoin hash print style string
+        return calcfastmerkleroot([inwitroot, outwitroot])
 
     def is_valid(self):
         self.calc_sha256()
@@ -701,15 +840,13 @@ def calc_merkle_root(self):
         return self.get_merkle_root(hashes)
 
     def calc_witness_merkle_root(self):
-        # For witness root purposes, the hash of the
-        # coinbase, with witness, is defined to be 0...0
-        hashes = [ser_uint256(0)]
-
-        for tx in self.vtx[1:]:
+        hashes = []
+        for tx in self.vtx:
             # Calculate the hashes with witness data
-            hashes.append(ser_uint256(tx.calc_witness_hash()))
+            hashes.append(tx.calc_witness_hash())
 
-        return self.get_merkle_root(hashes)
+        # returns bitcoin hash print order hex string
+        return calcfastmerkleroot(hashes)
 
     def is_valid(self):
         self.calc_sha256()
diff --git a/test/functional/test_framework/script.py b/test/functional/test_framework/script.py
index 4187de954a79e..a966807ca30ce 100644
--- a/test/functional/test_framework/script.py
+++ b/test/functional/test_framework/script.py
@@ -671,6 +671,7 @@ def SegwitVersion1SignatureHash(script, txTo, inIdx, hashtype, amount):
 
     hashPrevouts = 0
     hashSequence = 0
+    hashIssuance = 0
     hashOutputs = 0
 
     if not (hashtype & SIGHASH_ANYONECANPAY):
@@ -685,6 +686,13 @@ def SegwitVersion1SignatureHash(script, txTo, inIdx, hashtype, amount):
             serialize_sequence += struct.pack("<I", i.nSequence)
         hashSequence = uint256_from_str(hash256(serialize_sequence))
 
+    if not (hashtype & SIGHASH_ANYONECANPAY):
+        serialize_issuance = bytes()
+        # TODO actually serialize issuances
+        for _ in txTo.vin:
+            serialize_issuance += b'\x00'
+        hashIssuance = uint256_from_str(hash256(serialize_issuance))
+
     if ((hashtype & 0x1f) != SIGHASH_SINGLE and (hashtype & 0x1f) != SIGHASH_NONE):
         serialize_outputs = bytes()
         for o in txTo.vout:
@@ -698,9 +706,10 @@ def SegwitVersion1SignatureHash(script, txTo, inIdx, hashtype, amount):
     ss += struct.pack("<i", txTo.nVersion)
     ss += ser_uint256(hashPrevouts)
     ss += ser_uint256(hashSequence)
+    ss += ser_uint256(hashIssuance)
     ss += txTo.vin[inIdx].prevout.serialize()
     ss += ser_string(script)
-    ss += struct.pack("<q", amount)
+    ss += amount.serialize()
     ss += struct.pack("<I", txTo.vin[inIdx].nSequence)
     ss += ser_uint256(hashOutputs)
     ss += struct.pack("<i", txTo.nLockTime)
diff --git a/test/functional/test_framework/util.py b/test/functional/test_framework/util.py
index b2d9c347fcdf6..ce9fdf03ef809 100644
--- a/test/functional/test_framework/util.py
+++ b/test/functional/test_framework/util.py
@@ -23,6 +23,11 @@
 
 logger = logging.getLogger("TestFramework.utils")
 
+BITCOIN_ASSET = "e08fa5a62d79b9e3f5f476743a5535512f0f44444533275a2adc5fe8476a2eac"
+BITCOIN_ASSET_BYTES = bytearray.fromhex(BITCOIN_ASSET)
+BITCOIN_ASSET_BYTES.reverse()
+BITCOIN_ASSET_OUT = b"\x01"+BITCOIN_ASSET_BYTES
+
 # This variable should be set to the node being used for CalcFastMerkleRoot calls
 node_fastmerkle = None
 
@@ -314,6 +319,7 @@ def initialize_datadir(dirname, n, chain):
         f.write("listenonion=0\n")
         f.write("printtoconsole=0\n")
         # Elements:
+        f.write("con_parent_pegged_asset=" + BITCOIN_ASSET + "\n")
         f.write("con_blocksubsidy=5000000000\n")
         f.write("con_connect_coinbase=0\n")
         f.write("anyonecanspendaremine=0\n")
@@ -322,6 +328,7 @@ def initialize_datadir(dirname, n, chain):
         f.write("con_bip65height=1351\n")
         f.write("con_bip66height=1251\n")
         f.write("con_csv_deploy_start=0\n") # Enhance tests if removing this line
+        f.write("blindedaddresses=0\n") # Set to minimize broken tests in favor of custom
         os.makedirs(os.path.join(datadir, 'stderr'), exist_ok=True)
         os.makedirs(os.path.join(datadir, 'stdout'), exist_ok=True)
     return datadir
@@ -512,6 +519,7 @@ def create_confirmed_utxos(fee, node, count):
         send_value = t['amount'] - fee
         outputs[addr1] = satoshi_round(send_value / 2)
         outputs[addr2] = satoshi_round(send_value / 2)
+        outputs["fee"] = fee
         raw_tx = node.createrawtransaction(inputs, outputs)
         signed_tx = node.signrawtransactionwithwallet(raw_tx)["hex"]
         node.sendrawtransaction(signed_tx)
@@ -534,10 +542,10 @@ def gen_return_txouts():
         script_pubkey = script_pubkey + "01"
     # concatenate 128 txouts of above script_pubkey which we'll insert before the txout for change
     txouts = []
-    from .messages import CTxOut
+    from .messages import CTxOut, CTxOutValue
     for k in range(128):
         txout = CTxOut()
-        txout.nValue = 0
+        txout.nValue = CTxOutValue(0)
         txout.scriptPubKey = hex_str_to_bytes(script_pubkey)
         txouts.append(txout)
     return txouts
@@ -554,6 +562,7 @@ def create_lots_of_big_transactions(node, txouts, utxos, num, fee):
         outputs = {}
         change = t['amount'] - fee
         outputs[addr] = satoshi_round(change)
+        outputs["fee"] = fee
         rawtx = node.createrawtransaction(inputs, outputs)
         tx = CTransaction()
         tx.deserialize(BytesIO(hex_str_to_bytes(rawtx)))
@@ -584,7 +593,10 @@ def find_vout_for_address(node, txid, addr):
     given address. Raises runtime error exception if not found.
     """
     tx = node.getrawtransaction(txid, True)
+    unblind_addr = node.validateaddress(addr)["unconfidential"]
     for i in range(len(tx["vout"])):
-        if any([addr == a for a in tx["vout"][i]["scriptPubKey"]["addresses"]]):
+        if tx["vout"][i]["scriptPubKey"]["type"] == "fee":
+            continue
+        if any([unblind_addr == a for a in tx["vout"][i]["scriptPubKey"]["addresses"]]):
             return i
     raise RuntimeError("Vout not found for address: txid=%s, addr=%s" % (txid, addr))
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
index 8f258a0d8e9a8..a9f7ebbff4d6b 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -67,12 +67,18 @@
     'feature_blocksign.py',
     'rpc_calcfastmerkleroot.py',
     'feature_txwitness.py',
+    'rpc_tweakfedpeg.py',
+    'feature_issuance.py',
+    'feature_confidential_transactions.py',
+    'feature_default_asset_name.py',
+    'feature_assetsdir.py',
+    'feature_initial_reissuance_token.py',
     # Longest test should go first, to favor running tests in parallel
-    'feature_fee_estimation.py',
     'wallet_hd.py',
     'wallet_backup.py',
     # vv Tests less than 5m vv
-    'mining_getblocktemplate_longpoll.py',
+    # ELEMENTS: no longpolling
+    #'mining_getblocktemplate_longpoll.py',
     'feature_maxuploadtarget.py',
     'feature_block.py',
     'rpc_fundrawtransaction.py',
@@ -93,7 +99,8 @@
     'rpc_txoutproof.py',
     'wallet_listreceivedby.py',
     'wallet_abandonconflict.py',
-    'feature_csv_activation.py',
+    # ELEMENTS: no transitions in Elements
+    #'feature_csv_activation.py',
     'rpc_rawtransaction.py',
     'wallet_address_types.py',
     'feature_bip68_sequence.py',
@@ -144,7 +151,8 @@
     'feature_rbf.py',
     'mempool_packages.py',
     'rpc_createmultisig.py',
-    'feature_versionbits_warning.py',
+    # ELEMENTS: no versionbits in use
+    #'feature_versionbits_warning.py',
     'rpc_preciousblock.py',
     'wallet_importprunedfunds.py',
     'rpc_zmq.py',
@@ -187,6 +195,8 @@
     # Longest test should go first, to favor running tests in parallel
     'feature_pruning.py',
     'feature_dbcrash.py',
+    'feature_fee_estimation.py',
+
 ]
 
 # Place EXTENDED_SCRIPTS first since it has the 3 longest running tests
diff --git a/test/functional/wallet_abandonconflict.py b/test/functional/wallet_abandonconflict.py
index e5ac2c8bd4597..63cae4364c8b5 100755
--- a/test/functional/wallet_abandonconflict.py
+++ b/test/functional/wallet_abandonconflict.py
@@ -26,7 +26,7 @@ def skip_test_if_missing_module(self):
     def run_test(self):
         self.nodes[1].generate(100)
         sync_blocks(self.nodes)
-        balance = self.nodes[0].getbalance()
+        balance = self.nodes[0].getbalance()['bitcoin']
         txA = self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), Decimal("10"))
         txB = self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), Decimal("10"))
         txC = self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), Decimal("10"))
@@ -39,7 +39,7 @@ def run_test(self):
         assert_raises_rpc_error(-5, 'Transaction not eligible for abandonment', lambda: self.nodes[0].abandontransaction(txid=txA))
 
         sync_blocks(self.nodes)
-        newbalance = self.nodes[0].getbalance()
+        newbalance = self.nodes[0].getbalance()['bitcoin']
         assert(balance - newbalance < Decimal("0.001")) #no more than fees lost
         balance = newbalance
 
@@ -59,6 +59,7 @@ def run_test(self):
 
         outputs[self.nodes[0].getnewaddress()] = Decimal("14.99998")
         outputs[self.nodes[1].getnewaddress()] = Decimal("5")
+        outputs["fee"] = 2 * Decimal('10') - Decimal('14.99998') - Decimal('5')
         signed = self.nodes[0].signrawtransactionwithwallet(self.nodes[0].createrawtransaction(inputs, outputs))
         txAB1 = self.nodes[0].sendrawtransaction(signed["hex"])
 
@@ -71,6 +72,7 @@ def run_test(self):
         inputs.append({"txid":txC, "vout":nC})
         outputs = {}
         outputs[self.nodes[0].getnewaddress()] = Decimal("24.9996")
+        outputs["fee"] = Decimal('14.99998') + Decimal('10') - Decimal('24.9996')
         signed2 = self.nodes[0].signrawtransactionwithwallet(self.nodes[0].createrawtransaction(inputs, outputs))
         txABC2 = self.nodes[0].sendrawtransaction(signed2["hex"])
 
@@ -78,12 +80,13 @@ def run_test(self):
         signed3_change = Decimal("24.999")
         inputs = [ {"txid":txABC2, "vout":0} ]
         outputs = { self.nodes[0].getnewaddress(): signed3_change }
+        outputs["fee"] = Decimal('24.9996') - signed3_change
         signed3 = self.nodes[0].signrawtransactionwithwallet(self.nodes[0].createrawtransaction(inputs, outputs))
         # note tx is never directly referenced, only abandoned as a child of the above
         self.nodes[0].sendrawtransaction(signed3["hex"])
 
         # In mempool txs from self should increase balance from change
-        newbalance = self.nodes[0].getbalance()
+        newbalance = self.nodes[0].getbalance()['bitcoin']
         assert_equal(newbalance, balance - Decimal("30") + signed3_change)
         balance = newbalance
 
@@ -98,11 +101,11 @@ def run_test(self):
 
         # Not in mempool txs from self should only reduce balance
         # inputs are still spent, but change not received
-        newbalance = self.nodes[0].getbalance()
+        newbalance = self.nodes[0].getbalance()['bitcoin']
         assert_equal(newbalance, balance - signed3_change)
         # Unconfirmed received funds that are not in mempool, also shouldn't show
         # up in unconfirmed balance
-        unconfbalance = self.nodes[0].getunconfirmedbalance() + self.nodes[0].getbalance()
+        unconfbalance = self.nodes[0].getunconfirmedbalance()['bitcoin']+ self.nodes[0].getbalance()['bitcoin']
         assert_equal(unconfbalance, newbalance)
         # Also shouldn't show up in listunspent
         assert(not txABC2 in [utxo["txid"] for utxo in self.nodes[0].listunspent(0)])
@@ -111,7 +114,7 @@ def run_test(self):
         # Abandon original transaction and verify inputs are available again
         # including that the child tx was also abandoned
         self.nodes[0].abandontransaction(txAB1)
-        newbalance = self.nodes[0].getbalance()
+        newbalance = self.nodes[0].getbalance()['bitcoin']
         assert_equal(newbalance, balance + Decimal("30"))
         balance = newbalance
 
@@ -119,19 +122,19 @@ def run_test(self):
         self.stop_node(0)
         self.start_node(0, extra_args=["-minrelaytxfee=0.00001"])
         assert_equal(len(self.nodes[0].getrawmempool()), 0)
-        assert_equal(self.nodes[0].getbalance(), balance)
+        assert_equal(self.nodes[0].getbalance()['bitcoin'], balance)
 
         # But if it is received again then it is unabandoned
         # And since now in mempool, the change is available
         # But its child tx remains abandoned
         self.nodes[0].sendrawtransaction(signed["hex"])
-        newbalance = self.nodes[0].getbalance()
+        newbalance = self.nodes[0].getbalance()['bitcoin']
         assert_equal(newbalance, balance - Decimal("20") + Decimal("14.99998"))
         balance = newbalance
 
         # Send child tx again so it is unabandoned
         self.nodes[0].sendrawtransaction(signed2["hex"])
-        newbalance = self.nodes[0].getbalance()
+        newbalance = self.nodes[0].getbalance()['bitcoin']
         assert_equal(newbalance, balance - Decimal("10") - Decimal("14.99998") + Decimal("24.9996"))
         balance = newbalance
 
@@ -139,7 +142,7 @@ def run_test(self):
         self.stop_node(0)
         self.start_node(0, extra_args=["-minrelaytxfee=0.0001"])
         assert_equal(len(self.nodes[0].getrawmempool()), 0)
-        newbalance = self.nodes[0].getbalance()
+        newbalance = self.nodes[0].getbalance()['bitcoin']
         assert_equal(newbalance, balance - Decimal("24.9996"))
         balance = newbalance
 
@@ -149,6 +152,7 @@ def run_test(self):
         inputs.append({"txid":txA, "vout":nA})
         outputs = {}
         outputs[self.nodes[1].getnewaddress()] = Decimal("9.9999")
+        outputs["fee"] = Decimal('10') - Decimal('9.9999')
         tx = self.nodes[0].createrawtransaction(inputs, outputs)
         signed = self.nodes[0].signrawtransactionwithwallet(tx)
         self.nodes[1].sendrawtransaction(signed["hex"])
@@ -158,7 +162,7 @@ def run_test(self):
         sync_blocks(self.nodes)
 
         # Verify that B and C's 10 BTC outputs are available for spending again because AB1 is now conflicted
-        newbalance = self.nodes[0].getbalance()
+        newbalance = self.nodes[0].getbalance()['bitcoin']
         assert_equal(newbalance, balance + Decimal("20"))
         balance = newbalance
 
@@ -166,7 +170,7 @@ def run_test(self):
         # Invalidate the block with the double spend and B's 10 BTC output should no longer be available
         # Don't think C's should either
         self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
-        newbalance = self.nodes[0].getbalance()
+        newbalance = self.nodes[0].getbalance()['bitcoin']
         #assert_equal(newbalance, balance - Decimal("10"))
         self.log.info("If balance has not declined after invalidateblock then out of mempool wallet tx which is no longer")
         self.log.info("conflicted has not resumed causing its inputs to be seen as spent.  See Issue #7315")
diff --git a/test/functional/wallet_address_types.py b/test/functional/wallet_address_types.py
index 0f75045c9dce5..f2ee2e37cb0ec 100755
--- a/test/functional/wallet_address_types.py
+++ b/test/functional/wallet_address_types.py
@@ -91,9 +91,9 @@ def setup_network(self):
     def get_balances(self, confirmed=True):
         """Return a list of confirmed or unconfirmed balances."""
         if confirmed:
-            return [self.nodes[i].getbalance() for i in range(4)]
+            return [self.nodes[i].getbalance()['bitcoin'] for i in range(4)]
         else:
-            return [self.nodes[i].getunconfirmedbalance() for i in range(4)]
+            return [self.nodes[i].getunconfirmedbalance()['bitcoin'] for i in range(4)]
 
     def test_address(self, node, address, multisig, typ):
         """Run sanity checks on an address."""
@@ -152,11 +152,12 @@ def test_change_output_type(self, node_sender, destinations, expected_type):
         tx = self.nodes[node_sender].decoderawtransaction(raw_tx)
 
         # Make sure the transaction has change:
-        assert_equal(len(tx["vout"]), len(destinations) + 1)
+        assert_equal(len(tx["vout"]), len(destinations) + 2)
 
         # Make sure the destinations are included, and remove them:
-        output_addresses = [vout['scriptPubKey']['addresses'][0] for vout in tx["vout"]]
-        change_addresses = [d for d in output_addresses if d not in destinations]
+        output_addresses = [vout['scriptPubKey']['addresses'][0] for vout in tx["vout"] if vout["scriptPubKey"]["type"] != "fee"]
+        unconfidential_destinations = [self.nodes[node_sender].getaddressinfo(addr)["unconfidential"] for addr in destinations]
+        change_addresses = [d for d in output_addresses if d not in unconfidential_destinations]
         assert_equal(len(change_addresses), 1)
 
         self.log.debug("Check if change address " + change_addresses[0] + " is " + expected_type)
@@ -262,7 +263,7 @@ def run_test(self):
         self.nodes[5].sendtoaddress(self.nodes[4].getnewaddress(), Decimal("1"))
         self.nodes[5].generate(1)
         sync_blocks(self.nodes)
-        assert_equal(self.nodes[4].getbalance(), 1)
+        assert_equal(self.nodes[4].getbalance()['bitcoin'], 1)
 
         self.log.info("Nodes with addresstype=legacy never use a P2WPKH change output")
         self.test_change_output_type(0, [to_address_bech32_1], 'legacy')
diff --git a/test/functional/wallet_backup.py b/test/functional/wallet_backup.py
index c4798e1c87abf..cf613cf1c383d 100755
--- a/test/functional/wallet_backup.py
+++ b/test/functional/wallet_backup.py
@@ -110,10 +110,10 @@ def run_test(self):
         self.nodes[3].generate(100)
         sync_blocks(self.nodes)
 
-        assert_equal(self.nodes[0].getbalance(), 50)
-        assert_equal(self.nodes[1].getbalance(), 50)
-        assert_equal(self.nodes[2].getbalance(), 50)
-        assert_equal(self.nodes[3].getbalance(), 0)
+        assert_equal(self.nodes[0].getbalance()['bitcoin'], 50)
+        assert_equal(self.nodes[1].getbalance()['bitcoin'], 50)
+        assert_equal(self.nodes[2].getbalance()['bitcoin'], 50)
+        assert_equal(self.nodes[3].getbalance()['bitcoin'], 0)
 
         self.log.info("Creating transactions")
         # Five rounds of sending each other transactions.
@@ -137,10 +137,10 @@ def run_test(self):
         self.nodes[3].generate(101)
         self.sync_all()
 
-        balance0 = self.nodes[0].getbalance()
-        balance1 = self.nodes[1].getbalance()
-        balance2 = self.nodes[2].getbalance()
-        balance3 = self.nodes[3].getbalance()
+        balance0 = self.nodes[0].getbalance()['bitcoin']
+        balance1 = self.nodes[1].getbalance()['bitcoin']
+        balance2 = self.nodes[2].getbalance()['bitcoin']
+        balance3 = self.nodes[3].getbalance()['bitcoin']
         total = balance0 + balance1 + balance2 + balance3
 
         # At this point, there are 214 blocks (103 for setup, then 10 rounds, then 101.)
@@ -167,9 +167,9 @@ def run_test(self):
         self.start_three()
         sync_blocks(self.nodes)
 
-        assert_equal(self.nodes[0].getbalance(), balance0)
-        assert_equal(self.nodes[1].getbalance(), balance1)
-        assert_equal(self.nodes[2].getbalance(), balance2)
+        assert_equal(self.nodes[0].getbalance()['bitcoin'], balance0)
+        assert_equal(self.nodes[1].getbalance()['bitcoin'], balance1)
+        assert_equal(self.nodes[2].getbalance()['bitcoin'], balance2)
 
         self.log.info("Restoring using dumped wallet")
         self.stop_three()
@@ -181,9 +181,9 @@ def run_test(self):
 
         self.start_three()
 
-        assert_equal(self.nodes[0].getbalance(), 0)
-        assert_equal(self.nodes[1].getbalance(), 0)
-        assert_equal(self.nodes[2].getbalance(), 0)
+        assert_equal(self.nodes[0].getbalance()['bitcoin'], 0)
+        assert_equal(self.nodes[1].getbalance()['bitcoin'], 0)
+        assert_equal(self.nodes[2].getbalance()['bitcoin'], 0)
 
         self.nodes[0].importwallet(os.path.join(self.nodes[0].datadir, 'wallet.dump'))
         self.nodes[1].importwallet(os.path.join(self.nodes[1].datadir, 'wallet.dump'))
@@ -191,9 +191,9 @@ def run_test(self):
 
         sync_blocks(self.nodes)
 
-        assert_equal(self.nodes[0].getbalance(), balance0)
-        assert_equal(self.nodes[1].getbalance(), balance1)
-        assert_equal(self.nodes[2].getbalance(), balance2)
+        assert_equal(self.nodes[0].getbalance()['bitcoin'], balance0)
+        assert_equal(self.nodes[1].getbalance()['bitcoin'], balance1)
+        assert_equal(self.nodes[2].getbalance()['bitcoin'], balance2)
 
         # Backup to source wallet file must fail
         sourcePaths = [
diff --git a/test/functional/wallet_basic.py b/test/functional/wallet_basic.py
index 4079d054914b6..8044caa7d4d8d 100755
--- a/test/functional/wallet_basic.py
+++ b/test/functional/wallet_basic.py
@@ -56,22 +56,22 @@ def run_test(self):
         self.nodes[0].generate(1)
 
         walletinfo = self.nodes[0].getwalletinfo()
-        assert_equal(walletinfo['immature_balance'], 50)
-        assert_equal(walletinfo['balance'], 0)
+        assert_equal(walletinfo['immature_balance']['bitcoin'], 50)
+        assert_equal(walletinfo['balance']['bitcoin'], 0)
 
         self.sync_all([self.nodes[0:3]])
         self.nodes[1].generate(101)
         self.sync_all([self.nodes[0:3]])
 
-        assert_equal(self.nodes[0].getbalance(), 50)
-        assert_equal(self.nodes[1].getbalance(), 50)
-        assert_equal(self.nodes[2].getbalance(), 0)
+        assert_equal(self.nodes[0].getbalance()['bitcoin'], 50)
+        assert_equal(self.nodes[1].getbalance()['bitcoin'], 50)
+        assert_equal(self.nodes[2].getbalance()['bitcoin'], 0)
 
         # Check getbalance with different arguments
-        assert_equal(self.nodes[0].getbalance("*"), 50)
-        assert_equal(self.nodes[0].getbalance("*", 1), 50)
-        assert_equal(self.nodes[0].getbalance("*", 1, True), 50)
-        assert_equal(self.nodes[0].getbalance(minconf=1), 50)
+        assert_equal(self.nodes[0].getbalance("*")['bitcoin'], 50)
+        assert_equal(self.nodes[0].getbalance("*", 1)['bitcoin'], 50)
+        assert_equal(self.nodes[0].getbalance("*", 1, True)['bitcoin'], 50)
+        assert_equal(self.nodes[0].getbalance(minconf=1)['bitcoin'], 50)
 
         # first argument of getbalance must be excluded or set to "*"
         assert_raises_rpc_error(-32, "dummy first argument must be excluded or set to \"*\"", self.nodes[0].getbalance, "")
@@ -115,10 +115,10 @@ def run_test(self):
         txout2 = self.nodes[0].gettxout(mempool_txid, 1, True)
         # note the mempool tx will have randomly assigned indices
         # but 10 will go to node2 and the rest will go to node0
-        balance = self.nodes[0].getbalance()
+        balance = self.nodes[0].getbalance()['bitcoin']
         assert_equal(set([txout1['value'], txout2['value']]), set([10, balance]))
         walletinfo = self.nodes[0].getwalletinfo()
-        assert_equal(walletinfo['immature_balance'], 0)
+        assert_equal(walletinfo['immature_balance']['bitcoin'], 0)
 
         # Have node0 mine a block, thus it will collect its own fee.
         self.nodes[0].generate(1)
@@ -156,8 +156,8 @@ def run_test(self):
 
         # node0 should end up with 100 btc in block rewards plus fees, but
         # minus the 21 plus fees sent to node2
-        assert_equal(self.nodes[0].getbalance(), 100 - 21)
-        assert_equal(self.nodes[2].getbalance(), 21)
+        assert_equal(self.nodes[0].getbalance()['bitcoin'], 100 - 21)
+        assert_equal(self.nodes[2].getbalance()['bitcoin'], 21)
 
         # Node0 should have two unspent outputs.
         # Create a couple of transactions to send them to node2, submit them through
@@ -172,6 +172,7 @@ def run_test(self):
             outputs = {}
             inputs.append({"txid": utxo["txid"], "vout": utxo["vout"]})
             outputs[self.nodes[2].getnewaddress()] = utxo["amount"] - 3
+            outputs["fee"] = 3
             raw_tx = self.nodes[0].createrawtransaction(inputs, outputs)
             txns_to_send.append(self.nodes[0].signrawtransactionwithwallet(raw_tx))
 
@@ -183,8 +184,8 @@ def run_test(self):
         self.nodes[1].generate(1)
         self.sync_all([self.nodes[0:3]])
 
-        assert_equal(self.nodes[0].getbalance(), 0)
-        assert_equal(self.nodes[2].getbalance(), 94)
+        assert_equal(self.nodes[0].getbalance()['bitcoin'], 0)
+        assert_equal(self.nodes[2].getbalance()['bitcoin'], 94)
 
         # Verify that a spent output cannot be locked anymore
         spent_0 = {"txid": node0utxos[0]["txid"], "vout": node0utxos[0]["vout"]}
@@ -197,32 +198,32 @@ def run_test(self):
         txid = self.nodes[2].sendtoaddress(address, 10, "", "", False)
         self.nodes[2].generate(1)
         self.sync_all([self.nodes[0:3]])
-        node_2_bal = self.check_fee_amount(self.nodes[2].getbalance(), Decimal('84'), fee_per_byte, self.get_vsize(self.nodes[2].getrawtransaction(txid)))
-        assert_equal(self.nodes[0].getbalance(), Decimal('10'))
+        node_2_bal = self.check_fee_amount(self.nodes[2].getbalance()['bitcoin'], Decimal('84'), fee_per_byte, self.get_vsize(self.nodes[2].getrawtransaction(txid)))
+        assert_equal(self.nodes[0].getbalance()['bitcoin'], Decimal('10'))
 
         # Send 10 BTC with subtract fee from amount
         txid = self.nodes[2].sendtoaddress(address, 10, "", "", True)
         self.nodes[2].generate(1)
         self.sync_all([self.nodes[0:3]])
         node_2_bal -= Decimal('10')
-        assert_equal(self.nodes[2].getbalance(), node_2_bal)
-        node_0_bal = self.check_fee_amount(self.nodes[0].getbalance(), Decimal('20'), fee_per_byte, self.get_vsize(self.nodes[2].getrawtransaction(txid)))
+        assert_equal(self.nodes[2].getbalance()['bitcoin'], node_2_bal)
+        node_0_bal = self.check_fee_amount(self.nodes[0].getbalance()['bitcoin'], Decimal('20'), fee_per_byte, self.get_vsize(self.nodes[2].getrawtransaction(txid)))
 
         # Sendmany 10 BTC
         txid = self.nodes[2].sendmany('', {address: 10}, 0, "", [])
         self.nodes[2].generate(1)
         self.sync_all([self.nodes[0:3]])
         node_0_bal += Decimal('10')
-        node_2_bal = self.check_fee_amount(self.nodes[2].getbalance(), node_2_bal - Decimal('10'), fee_per_byte, self.get_vsize(self.nodes[2].getrawtransaction(txid)))
-        assert_equal(self.nodes[0].getbalance(), node_0_bal)
+        node_2_bal = self.check_fee_amount(self.nodes[2].getbalance()['bitcoin'], node_2_bal - Decimal('10'), fee_per_byte, self.get_vsize(self.nodes[2].getrawtransaction(txid)))
+        assert_equal(self.nodes[0].getbalance()['bitcoin'], node_0_bal)
 
         # Sendmany 10 BTC with subtract fee from amount
         txid = self.nodes[2].sendmany('', {address: 10}, 0, "", [address])
         self.nodes[2].generate(1)
         self.sync_all([self.nodes[0:3]])
         node_2_bal -= Decimal('10')
-        assert_equal(self.nodes[2].getbalance(), node_2_bal)
-        node_0_bal = self.check_fee_amount(self.nodes[0].getbalance(), node_0_bal + Decimal('10'), fee_per_byte, self.get_vsize(self.nodes[2].getrawtransaction(txid)))
+        assert_equal(self.nodes[2].getbalance()['bitcoin'], node_2_bal)
+        node_0_bal = self.check_fee_amount(self.nodes[0].getbalance()['bitcoin'], node_0_bal + Decimal('10'), fee_per_byte, self.get_vsize(self.nodes[2].getrawtransaction(txid)))
 
         # Test ResendWalletTransactions:
         # Create a couple of transactions, then start up a fourth
@@ -243,8 +244,8 @@ def run_test(self):
         assert(txid1 in self.nodes[3].getrawmempool())
 
         # Exercise balance rpcs
-        assert_equal(self.nodes[0].getwalletinfo()["unconfirmed_balance"], 1)
-        assert_equal(self.nodes[0].getunconfirmedbalance(), 1)
+        assert_equal(self.nodes[0].getwalletinfo()["unconfirmed_balance"]['bitcoin'], 1)
+        assert_equal(self.nodes[0].getunconfirmedbalance()['bitcoin'], 1)
 
         # check if we can list zero value tx as available coins
         # 1. create raw_tx
@@ -259,19 +260,21 @@ def run_test(self):
         signed_raw_tx = self.nodes[1].signrawtransactionwithwallet(raw_tx)
         decoded_raw_tx = self.nodes[1].decoderawtransaction(signed_raw_tx['hex'])
         zero_value_txid = decoded_raw_tx['txid']
-        self.nodes[1].sendrawtransaction(signed_raw_tx['hex'])
+        # ELEMENTS: this test doesn't make sense
+        #self.nodes[1].sendrawtransaction(signed_raw_tx['hex'])
 
         self.sync_all()
         self.nodes[1].generate(1)  # mine a block
         self.sync_all()
 
         unspent_txs = self.nodes[0].listunspent()  # zero value tx must be in listunspents output
-        found = False
+        #found = False
         for uTx in unspent_txs:
             if uTx['txid'] == zero_value_txid:
-                found = True
+                #found = True
                 assert_equal(uTx['amount'], Decimal('0'))
-        assert(found)
+        # ELEMENTS: this test doesn't make sense
+        #assert(found)
 
         # do some -walletbroadcast tests
         self.stop_nodes()
@@ -287,7 +290,7 @@ def run_test(self):
         tx_obj_not_broadcast = self.nodes[0].gettransaction(txid_not_broadcast)
         self.nodes[1].generate(1)  # mine a block, tx should not be in there
         self.sync_all([self.nodes[0:3]])
-        assert_equal(self.nodes[2].getbalance(), node_2_bal)  # should not be changed because tx was not broadcasted
+        assert_equal(self.nodes[2].getbalance()['bitcoin'], node_2_bal)  # should not be changed because tx was not broadcasted
 
         # now broadcast from another node, mine a block, sync, and check the balance
         self.nodes[1].sendrawtransaction(tx_obj_not_broadcast['hex'])
@@ -295,7 +298,7 @@ def run_test(self):
         self.sync_all([self.nodes[0:3]])
         node_2_bal += 2
         tx_obj_not_broadcast = self.nodes[0].gettransaction(txid_not_broadcast)
-        assert_equal(self.nodes[2].getbalance(), node_2_bal)
+        assert_equal(self.nodes[2].getbalance()['bitcoin'], node_2_bal)
 
         # create another tx
         self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 2)
@@ -315,21 +318,21 @@ def run_test(self):
         node_2_bal += 2
 
         # tx should be added to balance because after restarting the nodes tx should be broadcast
-        assert_equal(self.nodes[2].getbalance(), node_2_bal)
+        assert_equal(self.nodes[2].getbalance()['bitcoin'], node_2_bal)
 
         # send a tx with value in a string (PR#6380 +)
         txid = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), "2")
         tx_obj = self.nodes[0].gettransaction(txid)
-        assert_equal(tx_obj['amount'], Decimal('-2'))
+        assert_equal(tx_obj['amount']['bitcoin'], Decimal('-2'))
 
         txid = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), "0.0001")
         tx_obj = self.nodes[0].gettransaction(txid)
-        assert_equal(tx_obj['amount'], Decimal('-0.0001'))
+        assert_equal(tx_obj['amount']['bitcoin'], Decimal('-0.0001'))
 
         # check if JSON parser can handle scientific notation in strings
         txid = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), "1e-4")
         tx_obj = self.nodes[0].gettransaction(txid)
-        assert_equal(tx_obj['amount'], Decimal('-0.0001'))
+        assert_equal(tx_obj['amount']['bitcoin'], Decimal('-0.0001'))
 
         # This will raise an exception because the amount type is wrong
         assert_raises_rpc_error(-3, "Invalid amount", self.nodes[0].sendtoaddress, self.nodes[2].getnewaddress(), "1f-4")
@@ -339,7 +342,7 @@ def run_test(self):
 
         # Import address and private key to check correct behavior of spendable unspents
         # 1. Send some coins to generate new UTXO
-        address_to_import = self.nodes[2].getnewaddress()
+        address_to_import = self.nodes[2].getaddressinfo(self.nodes[2].getnewaddress())["confidential"]
         txid = self.nodes[0].sendtoaddress(address_to_import, 1)
         self.nodes[0].generate(1)
         self.sync_all([self.nodes[0:3]])
@@ -348,11 +351,14 @@ def run_test(self):
         self.nodes[1].importaddress(address_to_import)
 
         # 3. Validate that the imported address is watch-only on node1
+        # ELEMENTS: not watching without blinding key, watchonly with blinding key
+        assert(not self.nodes[1].getaddressinfo(address_to_import)["iswatchonly"])
+        self.nodes[1].importblindingkey(address_to_import, self.nodes[2].dumpblindingkey(address_to_import))
         assert(self.nodes[1].getaddressinfo(address_to_import)["iswatchonly"])
 
         # 4. Check that the unspents after import are not spendable
         assert_array_result(self.nodes[1].listunspent(),
-                            {"address": address_to_import},
+                            {"address": self.nodes[1].getaddressinfo(address_to_import)["unconfidential"]},
                             {"spendable": False})
 
         # 5. Import private key of the previously imported address on node1
@@ -361,7 +367,7 @@ def run_test(self):
 
         # 6. Check that the unspents are now spendable on node1
         assert_array_result(self.nodes[1].listunspent(),
-                            {"address": address_to_import},
+                            {"address": self.nodes[1].getaddressinfo(address_to_import)["unconfidential"]},
                             {"spendable": True})
 
         # Mine a block from node0 to an address from node1
@@ -377,7 +383,7 @@ def run_test(self):
         self.sync_all([self.nodes[0:3]])
         blocks = self.nodes[0].generate(2)
         self.sync_all([self.nodes[0:3]])
-        balance_nodes = [self.nodes[i].getbalance() for i in range(3)]
+        balance_nodes = [self.nodes[i].getbalance()['bitcoin'] for i in range(3)]
         block_count = self.nodes[0].getblockcount()
 
         # Check modes:
@@ -413,7 +419,7 @@ def run_test(self):
             if m == '-reindex':
                 # reindex will leave rpc warm up "early"; Wait for it to finish
                 wait_until(lambda: [block_count] * 3 == [self.nodes[i].getblockcount() for i in range(3)])
-            assert_equal(balance_nodes, [self.nodes[i].getbalance() for i in range(3)])
+            assert_equal(balance_nodes, [self.nodes[i].getbalance()['bitcoin'] for i in range(3)])
 
         # Exercise listsinceblock with the last two blocks
         coinbase_tx_1 = self.nodes[0].listsinceblock(blocks[0])
@@ -426,11 +432,11 @@ def run_test(self):
 
         # Get all non-zero utxos together
         chain_addrs = [self.nodes[0].getnewaddress(), self.nodes[0].getnewaddress()]
-        singletxid = self.nodes[0].sendtoaddress(chain_addrs[0], self.nodes[0].getbalance(), "", "", True)
+        singletxid = self.nodes[0].sendtoaddress(chain_addrs[0], self.nodes[0].getbalance()['bitcoin'], "", "", True)
         self.nodes[0].generate(1)
-        node0_balance = self.nodes[0].getbalance()
+        node0_balance = self.nodes[0].getbalance()['bitcoin']
         # Split into two chains
-        rawtx = self.nodes[0].createrawtransaction([{"txid": singletxid, "vout": 0}], {chain_addrs[0]: node0_balance / 2 - Decimal('0.01'), chain_addrs[1]: node0_balance / 2 - Decimal('0.01')})
+        rawtx = self.nodes[0].createrawtransaction([{"txid": singletxid, "vout": 0}], {chain_addrs[0]: node0_balance / 2 - Decimal('0.01'), chain_addrs[1]: node0_balance / 2 - Decimal('0.01'), "fee": Decimal('0.02')})
         signedtx = self.nodes[0].signrawtransactionwithwallet(rawtx)
         singletxid = self.nodes[0].sendrawtransaction(signedtx["hex"])
         self.nodes[0].generate(1)
@@ -466,7 +472,7 @@ def run_test(self):
             timeout -= 0.5
         assert_equal(len(self.nodes[0].getrawmempool()), chainlimit * 2)
 
-        node0_balance = self.nodes[0].getbalance()
+        node0_balance = self.nodes[0].getbalance()['bitcoin']
         # With walletrejectlongchains we will not create the tx and store it in our wallet.
         assert_raises_rpc_error(-4, "Transaction has too long of a mempool chain", self.nodes[0].sendtoaddress, sending_addr, node0_balance - Decimal('0.01'))
 
diff --git a/test/functional/wallet_bumpfee.py b/test/functional/wallet_bumpfee.py
index 00bfd84768eaa..0c3758bf35f01 100755
--- a/test/functional/wallet_bumpfee.py
+++ b/test/functional/wallet_bumpfee.py
@@ -62,7 +62,7 @@ def run_test(self):
         self.sync_all()
         peer_node.generate(1)
         self.sync_all()
-        assert_equal(rbf_node.getbalance(), Decimal("0.025"))
+        assert_equal(rbf_node.getbalance()['bitcoin'], Decimal("0.025"))
 
         self.log.info("Running tests")
         dest_address = peer_node.getnewaddress()
@@ -89,7 +89,7 @@ def test_simple_bumpfee_succeeds(rbf_node, peer_node, dest_address):
     assert rbfid in rbf_node.getrawmempool() and rbfid in peer_node.getrawmempool()
     bumped_tx = rbf_node.bumpfee(rbfid)
     assert_equal(bumped_tx["errors"], [])
-    assert bumped_tx["fee"] - abs(rbftx["fee"]) > 0
+    assert bumped_tx["fee"] - abs(rbftx["fee"]['bitcoin']) > 0
     # check that bumped_tx propagates, original tx was evicted and has a wallet conflict
     sync_mempools((rbf_node, peer_node))
     assert bumped_tx["txid"] in rbf_node.getrawmempool()
@@ -125,7 +125,8 @@ def test_segwit_bumpfee_succeeds(rbf_node, dest_address):
         'vout': 0,
         "sequence": BIP125_SEQUENCE_NUMBER
     }], {dest_address: Decimal("0.0005"),
-         rbf_node.getrawchangeaddress(): Decimal("0.0003")})
+         rbf_node.getrawchangeaddress(): Decimal("0.0003"),
+         "fee": "0.0001"})
     rbfsigned = rbf_node.signrawtransactionwithwallet(rbfraw)
     rbfid = rbf_node.sendrawtransaction(rbfsigned["hex"])
     assert rbfid in rbf_node.getrawmempool()
@@ -154,7 +155,7 @@ def test_notmine_bumpfee_fails(rbf_node, peer_node, dest_address):
         "sequence": BIP125_SEQUENCE_NUMBER
     } for utxo in utxos]
     output_val = sum(utxo["amount"] for utxo in utxos) - Decimal("0.001")
-    rawtx = rbf_node.createrawtransaction(inputs, {dest_address: output_val})
+    rawtx = rbf_node.createrawtransaction(inputs, {dest_address: output_val, "fee": "0.001"})
     signedtx = rbf_node.signrawtransactionwithwallet(rawtx)
     signedtx = peer_node.signrawtransactionwithwallet(signedtx["hex"])
     rbfid = rbf_node.sendrawtransaction(signedtx["hex"])
@@ -166,7 +167,8 @@ def test_bumpfee_with_descendant_fails(rbf_node, rbf_node_address, dest_address)
     # cannot bump fee if the transaction has a descendant
     # parent is send-to-self, so we don't have to check which output is change when creating the child tx
     parent_id = spend_one_input(rbf_node, rbf_node_address)
-    tx = rbf_node.createrawtransaction([{"txid": parent_id, "vout": 0}], {dest_address: 0.00020000})
+    input_val = rbf_node.getrawtransaction(parent_id, 1)["vout"][0]["value"]
+    tx = rbf_node.createrawtransaction([{"txid": parent_id, "vout": 0}], {dest_address: "0.0002", "fee": input_val-Decimal("0.0002")})
     tx = rbf_node.signrawtransactionwithwallet(tx)
     rbf_node.sendrawtransaction(tx["hex"])
     assert_raises_rpc_error(-8, "Transaction has descendants in the wallet", rbf_node.bumpfee, parent_id)
@@ -192,8 +194,8 @@ def test_dust_to_fee(rbf_node, dest_address):
     bumped_tx = rbf_node.bumpfee(rbfid, {"totalFee": 50000-1800})
     full_bumped_tx = rbf_node.getrawtransaction(bumped_tx["txid"], 1)
     assert_equal(bumped_tx["fee"], Decimal("0.00050000"))
-    assert_equal(len(fulltx["vout"]), 2)
-    assert_equal(len(full_bumped_tx["vout"]), 1)  #change output is eliminated
+    assert_equal(len(fulltx["vout"]), 3)
+    assert_equal(len(full_bumped_tx["vout"]), 2)  #change output is eliminated
 
 
 def test_settxfee(rbf_node, dest_address):
@@ -261,13 +263,16 @@ def test_unconfirmed_not_spendable(rbf_node, rbf_node_address):
 
     # check that the main output from the rbf tx is spendable after confirmed
     rbf_node.generate(1)
+    rbf_node_address_unconfidential = rbf_node.getaddressinfo(rbf_node_address)["unconfidential"]
     assert_equal(
         sum(1 for t in rbf_node.listunspent(minconf=0, include_unsafe=False)
-            if t["txid"] == rbfid and t["address"] == rbf_node_address and t["spendable"]), 1)
+            if t["txid"] == rbfid and t["address"] == rbf_node_address_unconfidential and t["spendable"]), 1)
 
 
 def test_bumpfee_metadata(rbf_node, dest_address):
-    rbfid = rbf_node.sendtoaddress(dest_address, Decimal("0.00100000"), "comment value", "to value")
+    assert(rbf_node.getbalance()["bitcoin"] < 49)
+    rbf_node.generatetoaddress(101, rbf_node.getnewaddress())
+    rbfid = rbf_node.sendtoaddress(dest_address, 49, "comment value", "to value")
     bumped_tx = rbf_node.bumpfee(rbfid)
     bumped_wtx = rbf_node.gettransaction(bumped_tx["txid"])
     assert_equal(bumped_wtx["comment"], "comment value")
@@ -286,7 +291,8 @@ def spend_one_input(node, dest_address):
         sequence=BIP125_SEQUENCE_NUMBER, **next(u for u in node.listunspent() if u["amount"] == Decimal("0.00100000")))
     rawtx = node.createrawtransaction(
         [tx_input], {dest_address: Decimal("0.00050000"),
-                     node.getrawchangeaddress(): Decimal("0.00049000")})
+                     node.getrawchangeaddress(): Decimal("0.00049000"),
+                     "fee": Decimal("0.00001")})
     signedtx = node.signrawtransactionwithwallet(rawtx)
     txid = node.sendrawtransaction(signedtx["hex"])
     return txid
diff --git a/test/functional/wallet_dump.py b/test/functional/wallet_dump.py
index b1db1e4ab97c7..07a58a5700fa8 100755
--- a/test/functional/wallet_dump.py
+++ b/test/functional/wallet_dump.py
@@ -59,13 +59,13 @@ def read_dump(file_name, addrs, script_addrs, hd_master_addr_old):
 
                 # count key types
                 for addrObj in addrs:
-                    if addrObj['address'] == addr.split(",")[0] and addrObj['hdkeypath'] == keypath and keytype == "label=":
+                    if addrObj['unconfidential'] == addr.split(",")[0] and addrObj['hdkeypath'] == keypath and keytype == "label=":
                         # a labeled entry in the wallet should contain both a native address
                         # and the p2sh-p2wpkh address that was added at wallet setup
                         if len(addr.split(",")) == 2:
                             addr_list = addr.split(",")
                             # the entry should be of the first key in the wallet
-                            assert_equal(addrs[0]['address'], addr_list[0])
+                            assert_equal(addrs[0]['unconfidential'], addr_list[0])
                             witness_addr_ret = addr_list[1]
                         found_addr += 1
                         break
diff --git a/test/functional/wallet_groups.py b/test/functional/wallet_groups.py
index 9d61483868819..81bfe6c7e1f78 100755
--- a/test/functional/wallet_groups.py
+++ b/test/functional/wallet_groups.py
@@ -50,9 +50,9 @@ def run_test(self):
         tx1 = self.nodes[1].getrawtransaction(txid1, True)
         # txid1 should have 1 input and 2 outputs
         assert_equal(1, len(tx1["vin"]))
-        assert_equal(2, len(tx1["vout"]))
+        assert_equal(2+1, len(tx1["vout"]))
         # one output should be 0.2, the other should be ~0.3
-        v = [vout["value"] for vout in tx1["vout"]]
+        v = [vout["value"] for vout in tx1["vout"] if vout["scriptPubKey"]["type"] != "fee"]
         v.sort()
         assert_approx(v[0], 0.2)
         assert_approx(v[1], 0.3, 0.0001)
@@ -61,25 +61,26 @@ def run_test(self):
         tx2 = self.nodes[2].getrawtransaction(txid2, True)
         # txid2 should have 2 inputs and 2 outputs
         assert_equal(2, len(tx2["vin"]))
-        assert_equal(2, len(tx2["vout"]))
+        assert_equal(2+1, len(tx2["vout"]))
         # one output should be 0.2, the other should be ~1.3
-        v = [vout["value"] for vout in tx2["vout"]]
+        v = [vout["value"] for vout in tx2["vout"] if vout["scriptPubKey"]["type"] != "fee"]
         v.sort()
         assert_approx(v[0], 0.2)
         assert_approx(v[1], 1.3, 0.0001)
 
         # Empty out node2's wallet
-        self.nodes[2].sendtoaddress(address=self.nodes[0].getnewaddress(), amount=self.nodes[2].getbalance(), subtractfeefromamount=True)
+        self.nodes[2].sendtoaddress(address=self.nodes[0].getnewaddress(), amount=self.nodes[2].getbalance()['bitcoin'], subtractfeefromamount=True)
         self.sync_all()
         self.nodes[0].generate(1)
 
         # Fill node2's wallet with 10000 outputs corresponding to the same
         # scriptPubKey
         for i in range(5):
-            raw_tx = self.nodes[0].createrawtransaction([{"txid":"0"*64, "vout":0}], [{addr2[0]: 0.05}])
+            raw_tx = self.nodes[0].createrawtransaction([{"txid":"0"*64, "vout":0}], [{addr2[0]: 0.10}])
             tx = FromHex(CTransaction(), raw_tx)
             tx.vin = []
-            tx.vout = [tx.vout[0]] * 2000
+            # ELEMENTS: lower number because outputs are bigger (otherwise tx gets too large)
+            tx.vout = [tx.vout[0]] * 1000
             funded_tx = self.nodes[0].fundrawtransaction(ToHex(tx))
             signed_tx = self.nodes[0].signrawtransactionwithwallet(funded_tx['hex'])
             self.nodes[0].sendrawtransaction(signed_tx['hex'])
diff --git a/test/functional/wallet_hd.py b/test/functional/wallet_hd.py
index ecc09dbfd1cc8..6d0f73d3b1b9d 100755
--- a/test/functional/wallet_hd.py
+++ b/test/functional/wallet_hd.py
@@ -11,7 +11,7 @@
 from test_framework.util import (
     assert_equal,
     connect_nodes_bi,
-    assert_raises_rpc_error
+    assert_raises_rpc_error,
 )
 
 
@@ -71,7 +71,7 @@ def run_test(self):
         assert_equal(change_addrV["hdkeypath"], "m/0'/1'/1'") #second internal child key
 
         self.sync_all()
-        assert_equal(self.nodes[1].getbalance(), NUM_HD_ADDS + 1)
+        assert_equal(self.nodes[1].getbalance()['bitcoin'], NUM_HD_ADDS + 1)
 
         self.log.info("Restore backup ...")
         self.stop_node(1)
@@ -97,7 +97,7 @@ def run_test(self):
         # Needs rescan
         self.stop_node(1)
         self.start_node(1, extra_args=self.extra_args[1] + ['-rescan'])
-        assert_equal(self.nodes[1].getbalance(), NUM_HD_ADDS + 1)
+        assert_equal(self.nodes[1].getbalance()['bitcoin'], NUM_HD_ADDS + 1)
 
         # Try a RPC based rescan
         self.stop_node(1)
@@ -108,20 +108,22 @@ def run_test(self):
         connect_nodes_bi(self.nodes, 0, 1)
         self.sync_all()
         # Wallet automatically scans blocks older than key on startup
-        assert_equal(self.nodes[1].getbalance(), NUM_HD_ADDS + 1)
+        assert_equal(self.nodes[1].getbalance()['bitcoin'], NUM_HD_ADDS + 1)
         out = self.nodes[1].rescanblockchain(0, 1)
         assert_equal(out['start_height'], 0)
         assert_equal(out['stop_height'], 1)
         out = self.nodes[1].rescanblockchain()
         assert_equal(out['start_height'], 0)
         assert_equal(out['stop_height'], self.nodes[1].getblockcount())
-        assert_equal(self.nodes[1].getbalance(), NUM_HD_ADDS + 1)
+        assert_equal(self.nodes[1].getbalance()['bitcoin'], NUM_HD_ADDS + 1)
 
         # send a tx and make sure its using the internal chain for the changeoutput
         txid = self.nodes[1].sendtoaddress(self.nodes[0].getnewaddress(), 1)
         outs = self.nodes[1].decoderawtransaction(self.nodes[1].gettransaction(txid)['hex'])['vout']
         keypath = ""
         for out in outs:
+            if out["scriptPubKey"]["type"] == "fee":
+                continue
             if out['value'] != 1:
                 keypath = self.nodes[1].getaddressinfo(out['scriptPubKey']['addresses'][0])['hdkeypath']
 
diff --git a/test/functional/wallet_import_rescan.py b/test/functional/wallet_import_rescan.py
index f043a544fcb35..5382f9e5d8c86 100755
--- a/test/functional/wallet_import_rescan.py
+++ b/test/functional/wallet_import_rescan.py
@@ -72,10 +72,11 @@ def check(self, txid=None, amount=None, confirmations=None):
         if self.expected_txs:
             assert_equal(len(addresses[0]["txids"]), self.expected_txs)
 
+        unconfidential_address = self.node.getaddressinfo(self.address["address"])["unconfidential"]
         if txid is not None:
             address, = [ad for ad in addresses if txid in ad["txids"]]
-            assert_equal(address["address"], self.address["address"])
-            assert_equal(address["amount"], self.expected_balance)
+            assert(address["address"] == self.address["address"] or address["address"] == unconfidential_address)
+            assert_equal(address["amount"], {"bitcoin": self.expected_balance})
             assert_equal(address["confirmations"], confirmations)
             # Verify the transaction is correctly marked watchonly depending on
             # whether the transaction pays to an imported public key or
diff --git a/test/functional/wallet_importmulti.py b/test/functional/wallet_importmulti.py
index f78ff19791886..e7d49537dd20a 100755
--- a/test/functional/wallet_importmulti.py
+++ b/test/functional/wallet_importmulti.py
@@ -56,6 +56,8 @@ def run_test (self):
                 "address": address['address']
             },
             "timestamp": "now",
+            # ELEMENTS: Also import blinding key
+            "blinding_privkey": self.nodes[0].dumpblindingkey(address["confidential"]),
         }])
         assert_equal(result[0]['success'], True)
         address_assert = self.nodes[1].getaddressinfo(address['address'])
@@ -82,7 +84,9 @@ def run_test (self):
         result = self.nodes[1].importmulti([{
             "scriptPubKey": address['scriptPubKey'],
             "timestamp": "now",
-            "internal": True
+            "internal": True,
+            # ELEMENTS: Also import blinding key
+            "blinding_privkey": self.nodes[0].dumpblindingkey(address["confidential"]),
         }])
         assert_equal(result[0]['success'], True)
         address_assert = self.nodes[1].getaddressinfo(address['address'])
@@ -97,6 +101,8 @@ def run_test (self):
         result = self.nodes[1].importmulti([{
             "scriptPubKey": nonstandardScriptPubKey,
             "timestamp": "now",
+            # ELEMENTS: Also import blinding key
+            "blinding_privkey": self.nodes[0].dumpblindingkey(address["confidential"]),
         }])
         assert_equal(result[0]['success'], False)
         assert_equal(result[0]['error']['code'], -8)
@@ -115,7 +121,9 @@ def run_test (self):
                 "address": address['address']
             },
             "timestamp": "now",
-            "pubkeys": [ address['pubkey'] ]
+            "pubkeys": [ address['pubkey'] ],
+            # ELEMENTS: Also import blinding key
+            "blinding_privkey": self.nodes[0].dumpblindingkey(address["confidential"]),
         }])
         assert_equal(result[0]['success'], True)
         address_assert = self.nodes[1].getaddressinfo(address['address'])
@@ -131,7 +139,9 @@ def run_test (self):
             "scriptPubKey": address['scriptPubKey'],
             "timestamp": "now",
             "pubkeys": [ address['pubkey'] ],
-            "internal": True
+            "internal": True,
+            # ELEMENTS: Also import blinding key
+            "blinding_privkey": self.nodes[0].dumpblindingkey(address["confidential"]),
         }]
         result = self.nodes[1].importmulti(request)
         assert_equal(result[0]['success'], True)
@@ -165,7 +175,9 @@ def run_test (self):
                 "address": address['address']
             },
             "timestamp": "now",
-            "keys": [ self.nodes[0].dumpprivkey(address['address']) ]
+            "keys": [ self.nodes[0].dumpprivkey(address['address']) ],
+            # ELEMENTS: Also import blinding key
+            "blinding_privkey": self.nodes[0].dumpblindingkey(address["confidential"]),
         }])
         assert_equal(result[0]['success'], True)
         address_assert = self.nodes[1].getaddressinfo(address['address'])
@@ -179,7 +191,9 @@ def run_test (self):
                 "address": address['address']
             },
             "timestamp": "now",
-            "keys": [ self.nodes[0].dumpprivkey(address['address']) ]
+            "keys": [ self.nodes[0].dumpprivkey(address['address']) ],
+            # ELEMENTS: Also import blinding key
+            "blinding_privkey": self.nodes[0].dumpblindingkey(address["confidential"]),
         }])
         assert_equal(result[0]['success'], False)
         assert_equal(result[0]['error']['code'], -4)
@@ -194,7 +208,9 @@ def run_test (self):
             },
             "timestamp": "now",
             "keys": [ self.nodes[0].dumpprivkey(address['address']) ],
-            "watchonly": True
+            "watchonly": True,
+            # ELEMENTS: Also import blinding key
+            "blinding_privkey": self.nodes[0].dumpblindingkey(address["confidential"]),
         }])
         assert_equal(result[0]['success'], False)
         assert_equal(result[0]['error']['code'], -8)
@@ -211,7 +227,9 @@ def run_test (self):
             "scriptPubKey": address['scriptPubKey'],
             "timestamp": "now",
             "keys": [ self.nodes[0].dumpprivkey(address['address']) ],
-            "internal": True
+            "internal": True,
+            # ELEMENTS: Also import blinding key
+            "blinding_privkey": self.nodes[0].dumpblindingkey(address["confidential"]),
         }])
         assert_equal(result[0]['success'], True)
         address_assert = self.nodes[1].getaddressinfo(address['address'])
diff --git a/test/functional/wallet_importprunedfunds.py b/test/functional/wallet_importprunedfunds.py
index 26b181db339b5..1d79ff5bec18e 100755
--- a/test/functional/wallet_importprunedfunds.py
+++ b/test/functional/wallet_importprunedfunds.py
@@ -15,6 +15,7 @@ class ImportPrunedFundsTest(BitcoinTestFramework):
     def set_test_params(self):
         self.setup_clean_chain = True
         self.num_nodes = 2
+        self.extra_args = [["-blindedaddresses=1"]] * self.num_nodes
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
@@ -29,8 +30,10 @@ def run_test(self):
         address1 = self.nodes[0].getnewaddress()
         # pubkey
         address2 = self.nodes[0].getnewaddress()
+        address2_blindingkey = self.nodes[0].dumpblindingkey(address2)
         # privkey
         address3 = self.nodes[0].getnewaddress()
+        address3_blindingkey = self.nodes[0].dumpblindingkey(address3)
         address3_privkey = self.nodes[0].dumpprivkey(address3)  # Using privkey
 
         # Check only one address
@@ -76,19 +79,21 @@ def run_test(self):
         # Import with no affiliated address
         assert_raises_rpc_error(-5, "No addresses", self.nodes[1].importprunedfunds, rawtxn1, proof1)
 
-        balance1 = self.nodes[1].getbalance()
+        balance1 = self.nodes[1].getbalance()['bitcoin']
         assert_equal(balance1, Decimal(0))
 
         # Import with affiliated address with no rescan
         self.nodes[1].importaddress(address=address2, rescan=False)
+        self.nodes[1].importblindingkey(address2, address2_blindingkey)
         self.nodes[1].importprunedfunds(rawtxn2, proof2)
         assert [tx for tx in self.nodes[1].listtransactions(include_watchonly=True) if tx['txid'] == txnid2]
 
         # Import with private key with no rescan
         self.nodes[1].importprivkey(privkey=address3_privkey, rescan=False)
+        self.nodes[1].importblindingkey(address3, address3_blindingkey)
         self.nodes[1].importprunedfunds(rawtxn3, proof3)
         assert [tx for tx in self.nodes[1].listtransactions() if tx['txid'] == txnid3]
-        balance3 = self.nodes[1].getbalance()
+        balance3 = self.nodes[1].getbalance()['bitcoin']
         assert_equal(balance3, Decimal('0.025'))
 
         # Addresses Test - after import
diff --git a/test/functional/wallet_keypool_topup.py b/test/functional/wallet_keypool_topup.py
index 561b69b5fb67b..24638bea9dc3e 100755
--- a/test/functional/wallet_keypool_topup.py
+++ b/test/functional/wallet_keypool_topup.py
@@ -62,7 +62,7 @@ def run_test(self):
         self.sync_all()
 
         self.log.info("Verify keypool is restored and balance is correct")
-        assert_equal(self.nodes[1].getbalance(), 15)
+        assert_equal(self.nodes[1].getbalance()['bitcoin'], 15)
         assert_equal(self.nodes[1].listtransactions()[0]['category'], "receive")
         # Check that we have marked all keys up to the used keypool key as used
         assert_equal(self.nodes[1].getaddressinfo(self.nodes[1].getnewaddress())['hdkeypath'], "m/0'/0'/110'")
diff --git a/test/functional/wallet_labels.py b/test/functional/wallet_labels.py
index 8d7c77bb96483..8f25d0e2d9ce2 100755
--- a/test/functional/wallet_labels.py
+++ b/test/functional/wallet_labels.py
@@ -31,7 +31,7 @@ def run_test(self):
         # the same address, so we call twice to get two addresses w/50 each
         node.generate(1)
         node.generate(101)
-        assert_equal(node.getbalance(), 100)
+        assert_equal(node.getbalance()['bitcoin'], 100)
 
         # there should be 2 address groups
         # each with 1 address with a balance of 50 Bitcoins
@@ -88,8 +88,8 @@ def run_test(self):
         node.generate(1)
         for label in labels:
             assert_equal(
-                node.getreceivedbyaddress(label.addresses[0]), amount_to_send)
-            assert_equal(node.getreceivedbylabel(label.name), amount_to_send)
+                node.getreceivedbyaddress(label.addresses[0])['bitcoin'], amount_to_send)
+            assert_equal(node.getreceivedbylabel(label.name)['bitcoin'], amount_to_send)
 
         for i, label in enumerate(labels):
             to_label = labels[(i + 1) % len(labels)]
@@ -99,7 +99,7 @@ def run_test(self):
             address = node.getnewaddress(label.name)
             label.add_receive_address(address)
             label.verify(node)
-            assert_equal(node.getreceivedbylabel(label.name), 2)
+            assert_equal(node.getreceivedbylabel(label.name)['bitcoin'], 2)
             label.verify(node)
         node.generate(101)
 
diff --git a/test/functional/wallet_listreceivedby.py b/test/functional/wallet_listreceivedby.py
index 3485c4470f6b2..8880e5eaccab1 100755
--- a/test/functional/wallet_listreceivedby.py
+++ b/test/functional/wallet_listreceivedby.py
@@ -48,11 +48,11 @@ def run_test(self):
         self.sync_all()
         assert_array_result(self.nodes[1].listreceivedbyaddress(),
                             {"address": addr},
-                            {"address": addr, "label": "", "amount": Decimal("0.1"), "confirmations": 10, "txids": [txid, ]})
+                            {"address": addr, "label": "", "amount": {"bitcoin": Decimal("0.1")}, "confirmations": 10, "txids": [txid, ]})
         # With min confidence < 10
         assert_array_result(self.nodes[1].listreceivedbyaddress(5),
                             {"address": addr},
-                            {"address": addr, "label": "", "amount": Decimal("0.1"), "confirmations": 10, "txids": [txid, ]})
+                            {"address": addr, "label": "", "amount": {"bitcoin": Decimal("0.1")}, "confirmations": 10, "txids": [txid, ]})
         # With min confidence > 10, should not find Tx
         assert_array_result(self.nodes[1].listreceivedbyaddress(11), {"address": addr}, {}, True)
 
@@ -60,11 +60,11 @@ def run_test(self):
         empty_addr = self.nodes[1].getnewaddress()
         assert_array_result(self.nodes[1].listreceivedbyaddress(0, True),
                             {"address": empty_addr},
-                            {"address": empty_addr, "label": "", "amount": 0, "confirmations": 0, "txids": []})
+                            {"address": empty_addr, "label": "", "amount": {"bitcoin": 0}, "confirmations": 0, "txids": []})
 
         # Test Address filtering
         # Only on addr
-        expected = {"address": addr, "label": "", "amount": Decimal("0.1"), "confirmations": 10, "txids": [txid, ]}
+        expected = {"address": addr, "label": "", "amount": {"bitcoin": Decimal("0.1")}, "confirmations": 10, "txids": [txid, ]}
         res = self.nodes[1].listreceivedbyaddress(minconf=0, include_empty=True, include_watchonly=True, address_filter=addr)
         assert_array_result(res, {"address": addr}, expected)
         assert_equal(len(res), 1)
@@ -78,12 +78,12 @@ def run_test(self):
         self.nodes[0].generate(1)
         self.sync_all()
         # Same test as above should still pass
-        expected = {"address": addr, "label": "", "amount": Decimal("0.1"), "confirmations": 11, "txids": [txid, ]}
+        expected = {"address": addr, "label": "", "amount": {"bitcoin": Decimal("0.1")}, "confirmations": 11, "txids": [txid, ]}
         res = self.nodes[1].listreceivedbyaddress(0, True, True, addr)
         assert_array_result(res, {"address": addr}, expected)
         assert_equal(len(res), 1)
         # Same test as above but with other_addr should still pass
-        expected = {"address": other_addr, "label": "", "amount": Decimal("0.1"), "confirmations": 1, "txids": [txid2, ]}
+        expected = {"address": other_addr, "label": "", "amount": {"bitcoin": Decimal("0.1")}, "confirmations": 1, "txids": [txid2, ]}
         res = self.nodes[1].listreceivedbyaddress(0, True, True, other_addr)
         assert_array_result(res, {"address": other_addr}, expected)
         assert_equal(len(res), 1)
@@ -105,17 +105,17 @@ def run_test(self):
 
         # Check balance is 0 because of 0 confirmations
         balance = self.nodes[1].getreceivedbyaddress(addr)
-        assert_equal(balance, Decimal("0.0"))
+        assert_equal(balance, {"bitcoin": Decimal("0.0")})
 
         # Check balance is 0.1
         balance = self.nodes[1].getreceivedbyaddress(addr, 0)
-        assert_equal(balance, Decimal("0.1"))
+        assert_equal(balance, {"bitcoin": Decimal("0.1")})
 
         # Bury Tx under 10 block so it will be returned by the default getreceivedbyaddress
         self.nodes[1].generate(10)
         self.sync_all()
         balance = self.nodes[1].getreceivedbyaddress(addr)
-        assert_equal(balance, Decimal("0.1"))
+        assert_equal(balance, {"bitcoin": Decimal("0.1")})
 
         # Trying to getreceivedby for an address the wallet doesn't own should return an error
         assert_raises_rpc_error(-4, "Address not found in wallet", self.nodes[0].getreceivedbyaddress, addr)
@@ -146,11 +146,11 @@ def run_test(self):
         # listreceivedbylabel should return updated received list
         assert_array_result(self.nodes[1].listreceivedbylabel(),
                             {"label": label},
-                            {"label": received_by_label_json["label"], "amount": (received_by_label_json["amount"] + Decimal("0.1"))})
+                            {"label": received_by_label_json["label"], "amount": {"bitcoin": (received_by_label_json["amount"]['bitcoin'] + Decimal("0.1"))}})
 
         # getreceivedbylabel should return updated receive total
         balance = self.nodes[1].getreceivedbylabel(label)
-        assert_equal(balance, balance_by_label + Decimal("0.1"))
+        assert_equal(balance, {"bitcoin": balance_by_label['bitcoin'] + Decimal("0.1")})
 
         # Create a new label named "mynewlabel" that has a 0 balance
         address = self.nodes[1].getnewaddress()
@@ -158,11 +158,11 @@ def run_test(self):
         received_by_label_json = [r for r in self.nodes[1].listreceivedbylabel(0, True) if r["label"] == "mynewlabel"][0]
 
         # Test includeempty of listreceivedbylabel
-        assert_equal(received_by_label_json["amount"], Decimal("0.0"))
+        assert_equal(received_by_label_json["amount"], {"bitcoin": Decimal("0.0")})
 
         # Test getreceivedbylabel for 0 amount labels
         balance = self.nodes[1].getreceivedbylabel("mynewlabel")
-        assert_equal(balance, Decimal("0.0"))
+        assert_equal(balance, {"bitcoin": Decimal("0.0")})
 
 if __name__ == '__main__':
     ReceivedByTest().main()
diff --git a/test/functional/wallet_listsinceblock.py b/test/functional/wallet_listsinceblock.py
index 53e671cd3b0ac..91cab9a89d117 100755
--- a/test/functional/wallet_listsinceblock.py
+++ b/test/functional/wallet_listsinceblock.py
@@ -155,6 +155,7 @@ def test_double_spend(self):
         recipient_dict = {
             self.nodes[0].getnewaddress(): 1,
             self.nodes[1].getnewaddress(): change,
+            "fee": "0.0003",
         }
         utxo_dicts = [{
             'txid': utxo['txid'],
@@ -168,6 +169,7 @@ def test_double_spend(self):
         recipient_dict2 = {
             self.nodes[3].getnewaddress(): 1,
             self.nodes[2].getnewaddress(): change,
+            "fee": "0.0003",
         }
         self.nodes[2].sendrawtransaction(
             self.nodes[2].signrawtransactionwithwallet(
@@ -230,6 +232,7 @@ def test_double_send(self):
         recipient_dict = {
             self.nodes[0].getnewaddress(): 1,
             self.nodes[2].getnewaddress(): change,
+            "fee": "0.0003"
         }
         utxo_dicts = [{
             'txid': utxo['txid'],
diff --git a/test/functional/wallet_listtransactions.py b/test/functional/wallet_listtransactions.py
index 5a17395abdb82..a6fa04dfa026d 100755
--- a/test/functional/wallet_listtransactions.py
+++ b/test/functional/wallet_listtransactions.py
@@ -139,6 +139,7 @@ def get_unconfirmed_utxo_entry(node, txid_to_match):
         # Create tx2 using createrawtransaction
         inputs = [{"txid": utxo_to_use["txid"], "vout": utxo_to_use["vout"]}]
         outputs = {self.nodes[0].getnewaddress(): 0.999}
+        outputs["fee"] = utxo_to_use["amount"] - Decimal('0.999')
         tx2 = self.nodes[1].createrawtransaction(inputs, outputs)
         tx2_signed = self.nodes[1].signrawtransactionwithwallet(tx2)["hex"]
         txid_2 = self.nodes[1].sendrawtransaction(tx2_signed)
@@ -153,6 +154,7 @@ def get_unconfirmed_utxo_entry(node, txid_to_match):
         utxo_to_use = get_unconfirmed_utxo_entry(self.nodes[0], txid_2)
         inputs = [{"txid": txid_2, "vout": utxo_to_use["vout"]}]
         outputs = {self.nodes[1].getnewaddress(): 0.998}
+        outputs["fee"] = utxo_to_use["amount"] - Decimal('0.998')
         tx3 = self.nodes[0].createrawtransaction(inputs, outputs)
         tx3_modified = tx_from_hex(tx3)
         tx3_modified.vin[0].nSequence = 0
@@ -170,6 +172,7 @@ def get_unconfirmed_utxo_entry(node, txid_to_match):
         utxo_to_use = get_unconfirmed_utxo_entry(self.nodes[1], txid_3)
         inputs = [{"txid": txid_3, "vout": utxo_to_use["vout"]}]
         outputs = {self.nodes[0].getnewaddress(): 0.997}
+        outputs["fee"] = utxo_to_use["amount"] - Decimal('0.997')
         tx4 = self.nodes[1].createrawtransaction(inputs, outputs)
         tx4_signed = self.nodes[1].signrawtransactionwithwallet(tx4)["hex"]
         txid_4 = self.nodes[1].sendrawtransaction(tx4_signed)
@@ -181,7 +184,8 @@ def get_unconfirmed_utxo_entry(node, txid_to_match):
 
         # Replace tx3, and check that tx4 becomes unknown
         tx3_b = tx3_modified
-        tx3_b.vout[0].nValue -= int(Decimal("0.004") * COIN)  # bump the fee
+        tx3_b.vout[0].nValue.setToAmount(tx3_b.vout[0].nValue.getAmount() - int(0.004*COIN))  # bump the fee
+        tx3_b.vout[1].nValue.setToAmount(tx3_b.vout[1].nValue.getAmount() + int(0.004*COIN))  # bump the fee
         tx3_b = bytes_to_hex_str(tx3_b.serialize())
         tx3_b_signed = self.nodes[0].signrawtransactionwithwallet(tx3_b)['hex']
         txid_3b = self.nodes[0].sendrawtransaction(tx3_b_signed, True)
diff --git a/test/functional/wallet_multiwallet.py b/test/functional/wallet_multiwallet.py
index dc0a935f853ea..3a3a9274fdc1b 100755
--- a/test/functional/wallet_multiwallet.py
+++ b/test/functional/wallet_multiwallet.py
@@ -129,7 +129,7 @@ def wallet_file(name):
         assert_equal(set(node.listwallets()), {"w4", "w5"})
         w5 = wallet("w5")
         w5_info = w5.getwalletinfo()
-        assert_equal(w5_info['immature_balance'], 50)
+        assert_equal(w5_info['immature_balance'], {"bitcoin": 50})
 
         competing_wallet_dir = os.path.join(self.options.tmpdir, 'competing_walletdir')
         os.mkdir(competing_wallet_dir)
@@ -146,7 +146,7 @@ def wallet_file(name):
         wallets[0].generate(1)
         for wallet_name, wallet in zip(wallet_names, wallets):
             info = wallet.getwalletinfo()
-            assert_equal(info['immature_balance'], 50 if wallet is wallets[0] else 0)
+            assert_equal(info['immature_balance']['bitcoin'], 50 if wallet is wallets[0] else 0)
             assert_equal(info['walletname'], wallet_name)
 
         # accessing invalid wallet fails
@@ -157,18 +157,18 @@ def wallet_file(name):
 
         w1, w2, w3, w4, *_ = wallets
         w1.generate(101)
-        assert_equal(w1.getbalance(), 100)
-        assert_equal(w2.getbalance(), 0)
-        assert_equal(w3.getbalance(), 0)
-        assert_equal(w4.getbalance(), 0)
+        assert_equal(w1.getbalance()['bitcoin'], 100)
+        assert_equal(w2.getbalance()['bitcoin'], 0)
+        assert_equal(w3.getbalance()['bitcoin'], 0)
+        assert_equal(w4.getbalance()['bitcoin'], 0)
 
         w1.sendtoaddress(w2.getnewaddress(), 1)
         w1.sendtoaddress(w3.getnewaddress(), 2)
         w1.sendtoaddress(w4.getnewaddress(), 3)
         w1.generate(1)
-        assert_equal(w2.getbalance(), 1)
-        assert_equal(w3.getbalance(), 2)
-        assert_equal(w4.getbalance(), 3)
+        assert_equal(w2.getbalance()['bitcoin'], 1)
+        assert_equal(w3.getbalance()['bitcoin'], 2)
+        assert_equal(w4.getbalance()['bitcoin'], 3)
 
         batch = w1.batch([w1.getblockchaininfo.get_request(), w1.getwalletinfo.get_request()])
         assert_equal(batch[0]["result"]["chain"], self.chain)
diff --git a/test/functional/wallet_txn_clone.py b/test/functional/wallet_txn_clone.py
index 583dc48f66101..f0b23cbcfd559 100755
--- a/test/functional/wallet_txn_clone.py
+++ b/test/functional/wallet_txn_clone.py
@@ -42,7 +42,7 @@ def run_test(self):
         # All nodes should start with 1,250 BTC:
         starting_balance = 1250
         for i in range(4):
-            assert_equal(self.nodes[i].getbalance(), starting_balance)
+            assert_equal(self.nodes[i].getbalance()['bitcoin'], starting_balance)
             self.nodes[i].getnewaddress()  # bug workaround, coins generated assigned to first getnewaddress!
 
         self.nodes[0].settxfee(.001)
@@ -55,8 +55,8 @@ def run_test(self):
         node0_txid2 = self.nodes[0].sendtoaddress(node0_address2, 29)
         node0_tx2 = self.nodes[0].gettransaction(node0_txid2)
 
-        assert_equal(self.nodes[0].getbalance(),
-                     starting_balance + node0_tx1["fee"] + node0_tx2["fee"])
+        assert_equal(self.nodes[0].getbalance()['bitcoin'],
+                     starting_balance + node0_tx1["fee"]['bitcoin'] + node0_tx2["fee"]['bitcoin'])
 
         # Coins are sent to node1_address
         node1_address = self.nodes[1].getnewaddress()
@@ -70,13 +70,15 @@ def run_test(self):
         clone_inputs = [{"txid": rawtx1["vin"][0]["txid"], "vout": rawtx1["vin"][0]["vout"]}]
         clone_outputs = {rawtx1["vout"][0]["scriptPubKey"]["addresses"][0]: rawtx1["vout"][0]["value"],
                          rawtx1["vout"][1]["scriptPubKey"]["addresses"][0]: rawtx1["vout"][1]["value"]}
+        assert_equal(rawtx1["vout"][2]["scriptPubKey"]["type"], "fee")
+        clone_outputs["fee"] = rawtx1["vout"][2]["value"]
         clone_locktime = rawtx1["locktime"]
         clone_raw = self.nodes[0].createrawtransaction(clone_inputs, clone_outputs, clone_locktime)
 
         # createrawtransaction randomizes the order of its outputs, so swap them if necessary.
         clone_tx = CTransaction()
         clone_tx.deserialize(io.BytesIO(bytes.fromhex(clone_raw)))
-        if (rawtx1["vout"][0]["value"] == 40 and clone_tx.vout[0].nValue != 40*COIN or rawtx1["vout"][0]["value"] != 40 and clone_tx.vout[0].nValue == 40*COIN):
+        if (rawtx1["vout"][0]["value"] == 40 and clone_tx.vout[0].nValue.getAmount() != 40*COIN or rawtx1["vout"][0]["value"] != 40 and clone_tx.vout[0].nValue.getAmount() == 40*COIN):
             (clone_tx.vout[0], clone_tx.vout[1]) = (clone_tx.vout[1], clone_tx.vout[0])
 
         # Use a different signature hash type to sign.  This creates an equivalent but malleated clone.
@@ -94,12 +96,12 @@ def run_test(self):
 
         # Node0's balance should be starting balance, plus 50BTC for another
         # matured block, minus tx1 and tx2 amounts, and minus transaction fees:
-        expected = starting_balance + node0_tx1["fee"] + node0_tx2["fee"]
+        expected = starting_balance + node0_tx1["fee"]['bitcoin'] + node0_tx2["fee"]['bitcoin']
         if self.options.mine_block:
             expected += 50
-        expected += tx1["amount"] + tx1["fee"]
-        expected += tx2["amount"] + tx2["fee"]
-        assert_equal(self.nodes[0].getbalance(), expected)
+        expected += tx1["amount"]['bitcoin'] + tx1["fee"]['bitcoin']
+        expected += tx2["amount"]['bitcoin'] + tx2["fee"]['bitcoin']
+        assert_equal(self.nodes[0].getbalance()['bitcoin'], expected)
 
         if self.options.mine_block:
             assert_equal(tx1["confirmations"], 1)
@@ -140,7 +142,7 @@ def run_test(self):
         expected += 100
         if (self.options.mine_block):
             expected -= 50
-        assert_equal(self.nodes[0].getbalance(), expected)
+        assert_equal(self.nodes[0].getbalance()['bitcoin'], expected)
 
 if __name__ == '__main__':
     TxnMallTest().main()
diff --git a/test/functional/wallet_txn_doublespend.py b/test/functional/wallet_txn_doublespend.py
index f114d5ab68889..941bc849bd7c2 100755
--- a/test/functional/wallet_txn_doublespend.py
+++ b/test/functional/wallet_txn_doublespend.py
@@ -35,7 +35,7 @@ def run_test(self):
         # All nodes should start with 1,250 BTC:
         starting_balance = 1250
         for i in range(4):
-            assert_equal(self.nodes[i].getbalance(), starting_balance)
+            assert_equal(self.nodes[i].getbalance(), {"bitcoin": starting_balance})
             self.nodes[i].getnewaddress("")  # bug workaround, coins generated assigned to first getnewaddress!
 
         # Assign coins to foo and bar addresses:
@@ -48,7 +48,7 @@ def run_test(self):
         fund_bar_tx = self.nodes[0].gettransaction(fund_bar_txid)
 
         assert_equal(self.nodes[0].getbalance(),
-                     starting_balance + fund_foo_tx["fee"] + fund_bar_tx["fee"])
+                {"bitcoin": starting_balance + fund_foo_tx["fee"]['bitcoin'] + fund_bar_tx["fee"]['bitcoin']})
 
         # Coins are sent to node1_address
         node1_address = self.nodes[1].getnewaddress()
@@ -67,6 +67,7 @@ def run_test(self):
         outputs = {}
         outputs[node1_address] = 1240
         outputs[change_address] = 1248 - 1240 + doublespend_fee
+        outputs["fee"] = (1219+29) - (1240+1248 - 1240 + doublespend_fee)
         rawtx = self.nodes[0].createrawtransaction(inputs, outputs)
         doublespend = self.nodes[0].signrawtransactionwithwallet(rawtx)
         assert_equal(doublespend["complete"], True)
@@ -85,18 +86,18 @@ def run_test(self):
 
         # Node0's balance should be starting balance, plus 50BTC for another
         # matured block, minus 40, minus 20, and minus transaction fees:
-        expected = starting_balance + fund_foo_tx["fee"] + fund_bar_tx["fee"]
+        expected = starting_balance + fund_foo_tx["fee"]['bitcoin'] + fund_bar_tx["fee"]['bitcoin']
         if self.options.mine_block:
             expected += 50
-        expected += tx1["amount"] + tx1["fee"]
-        expected += tx2["amount"] + tx2["fee"]
-        assert_equal(self.nodes[0].getbalance(), expected)
+        expected += tx1["amount"]['bitcoin'] + tx1["fee"]['bitcoin']
+        expected += tx2["amount"]['bitcoin'] + tx2["fee"]['bitcoin']
+        assert_equal(self.nodes[0].getbalance(), {"bitcoin": expected})
 
         if self.options.mine_block:
             assert_equal(tx1["confirmations"], 1)
             assert_equal(tx2["confirmations"], 1)
             # Node1's balance should be both transaction amounts:
-            assert_equal(self.nodes[1].getbalance(), starting_balance - tx1["amount"] - tx2["amount"])
+            assert_equal(self.nodes[1].getbalance(), {"bitcoin": starting_balance - tx1["amount"]['bitcoin'] - tx2["amount"]['bitcoin']})
         else:
             assert_equal(tx1["confirmations"], 0)
             assert_equal(tx2["confirmations"], 0)
@@ -125,11 +126,11 @@ def run_test(self):
         # Node0's total balance should be starting balance, plus 100BTC for
         # two more matured blocks, minus 1240 for the double-spend, plus fees (which are
         # negative):
-        expected = starting_balance + 100 - 1240 + fund_foo_tx["fee"] + fund_bar_tx["fee"] + doublespend_fee
-        assert_equal(self.nodes[0].getbalance(), expected)
+        expected = starting_balance + 100 - 1240 + fund_foo_tx["fee"]['bitcoin'] + fund_bar_tx["fee"]['bitcoin'] + doublespend_fee
+        assert_equal(self.nodes[0].getbalance()['bitcoin'], expected)
 
         # Node1's balance should be its initial balance (1250 for 25 block rewards) plus the doublespend:
-        assert_equal(self.nodes[1].getbalance(), 1250 + 1240)
+        assert_equal(self.nodes[1].getbalance()['bitcoin'], 1250 + 1240)
 
 if __name__ == '__main__':
     TxnMallTest().main()
diff --git a/test/lint/lint-circular-dependencies.sh b/test/lint/lint-circular-dependencies.sh
index 3972baed1d496..5c643751ace15 100755
--- a/test/lint/lint-circular-dependencies.sh
+++ b/test/lint/lint-circular-dependencies.sh
@@ -40,6 +40,7 @@ EXPECTED_CIRCULAR_DEPENDENCIES=(
     "qt/addressbookpage -> qt/bitcoingui -> qt/walletview -> qt/signverifymessagedialog -> qt/addressbookpage"
     "qt/guiutil -> qt/walletmodel -> qt/optionsmodel -> qt/intro -> qt/guiutil"
     "qt/addressbookpage -> qt/bitcoingui -> qt/walletview -> qt/sendcoinsdialog -> qt/sendcoinsentry -> qt/addressbookpage"
+    "wallet/coinselection -> wallet/wallet -> wallet/coinselection"
 )
 
 EXIT_CODE=0
diff --git a/test/util/data/bitcoin-util-test.json b/test/util/data/bitcoin-util-test.json
index f2213f4f2e32f..90e9bc5a2ab99 100644
--- a/test/util/data/bitcoin-util-test.json
+++ b/test/util/data/bitcoin-util-test.json
@@ -1,110 +1,110 @@
 [
   { "exec": "./bitcoin-tx",
-    "args": ["-create", "nversion=1"],
+    "args": ["-serialization=BITCOIN", "-create", "nversion=1"],
     "output_cmp": "blanktxv1.hex",
     "description": "Creates a blank v1 transaction"
   },
   { "exec": "./bitcoin-tx",
-    "args": ["-json","-create", "nversion=1"],
+    "args": ["-serialization=BITCOIN", "-json","-create", "nversion=1"],
     "output_cmp": "blanktxv1.json",
     "description": "Creates a blank v1 transaction (output in json)"
   },
   { "exec": "./bitcoin-tx",
-    "args": ["-"],
+    "args": ["-serialization=BITCOIN", "-"],
     "input": "blanktxv2.hex",
     "output_cmp": "blanktxv2.hex",
     "description": "Creates a blank transaction when nothing is piped into bitcoin-tx"
   },
   { "exec": "./bitcoin-tx",
-    "args": ["-json","-create"],
+    "args": ["-serialization=BITCOIN", "-json","-create"],
     "output_cmp": "blanktxv2.json",
     "description": "Creates a blank transaction (output in json)"
   },
   { "exec": "./bitcoin-tx",
-    "args": ["-json","-"],
+    "args": ["-serialization=BITCOIN", "-json","-"],
     "input": "blanktxv2.hex",
     "output_cmp": "blanktxv2.json",
     "description": "Creates a blank transaction when nothing is piped into bitcoin-tx (output in json)"
   },
   { "exec": "./bitcoin-tx",
-    "args": ["-create", "nversion=1foo"],
+    "args": ["-serialization=BITCOIN", "-create", "nversion=1foo"],
     "return_code": 1,
     "error_txt": "error: Invalid TX version requested",
     "description": "Tests the check for invalid nversion value"
   },
   { "exec": "./bitcoin-tx",
-    "args": ["-", "delin=1"],
+    "args": ["-serialization=BITCOIN", "-", "delin=1"],
     "input": "tx394b54bb.hex",
     "output_cmp": "tt-delin1-out.hex",
     "description": "Deletes a single input from a transaction"
   },
   { "exec": "./bitcoin-tx",
-    "args": ["-json", "-", "delin=1"],
+    "args": ["-serialization=BITCOIN", "-json", "-", "delin=1"],
     "input": "tx394b54bb.hex",
     "output_cmp": "tt-delin1-out.json",
     "description": "Deletes a single input from a transaction (output in json)"
   },
   { "exec": "./bitcoin-tx",
-    "args": ["-", "delin=31"],
+    "args": ["-serialization=BITCOIN", "-", "delin=31"],
     "input": "tx394b54bb.hex",
     "return_code": 1,
     "error_txt": "error: Invalid TX input index '31'",
     "description": "Attempts to delete an input with a bad index from a transaction. Expected to fail."
   },
   { "exec": "./bitcoin-tx",
-    "args": ["-", "delin=1foo"],
+    "args": ["-serialization=BITCOIN", "-", "delin=1foo"],
     "input": "tx394b54bb.hex",
     "return_code": 1,
     "error_txt": "error: Invalid TX input index",
     "description": "Tests the check for an invalid input index with delin"
   },
   { "exec": "./bitcoin-tx",
-    "args": ["-", "delout=1"],
+    "args": ["-serialization=BITCOIN", "-", "delout=1"],
     "input": "tx394b54bb.hex",
     "output_cmp": "tt-delout1-out.hex",
     "description": "Deletes a single output from a transaction"
   },
   { "exec": "./bitcoin-tx",
-    "args": ["-json", "-", "delout=1"],
+    "args": ["-serialization=BITCOIN", "-json", "-", "delout=1"],
     "input": "tx394b54bb.hex",
     "output_cmp": "tt-delout1-out.json",
     "description": "Deletes a single output from a transaction (output in json)"
   },
   { "exec": "./bitcoin-tx",
-    "args": ["-", "delout=2"],
+    "args": ["-serialization=BITCOIN", "-", "delout=2"],
     "input": "tx394b54bb.hex",
     "return_code": 1,
     "error_txt": "error: Invalid TX output index '2'",
     "description": "Attempts to delete an output with a bad index from a transaction. Expected to fail."
   },
   { "exec": "./bitcoin-tx",
-    "args": ["-", "delout=1foo"],
+    "args": ["-serialization=BITCOIN", "-", "delout=1foo"],
     "input": "tx394b54bb.hex",
     "return_code": 1,
     "error_txt": "error: Invalid TX output index",
     "description": "Tests the check for an invalid output index with delout"
   },
   { "exec": "./bitcoin-tx",
-    "args": ["-", "locktime=317000"],
+    "args": ["-serialization=BITCOIN", "-", "locktime=317000"],
     "input": "tx394b54bb.hex",
     "output_cmp": "tt-locktime317000-out.hex",
     "description": "Adds an nlocktime to a transaction"
   },
   { "exec": "./bitcoin-tx",
-    "args": ["-json", "-", "locktime=317000"],
+    "args": ["-serialization=BITCOIN", "-json", "-", "locktime=317000"],
     "input": "tx394b54bb.hex",
     "output_cmp": "tt-locktime317000-out.json",
     "description": "Adds an nlocktime to a transaction (output in json)"
   },
   { "exec": "./bitcoin-tx",
-    "args": ["-create", "locktime=317000foo"],
+    "args": ["-serialization=BITCOIN", "-create", "locktime=317000foo"],
     "return_code": 1,
     "error_txt": "error: Invalid TX locktime requested",
     "description": "Tests the check for invalid locktime value"
   },
   { "exec": "./bitcoin-tx",
     "args":
-    ["-create",
+    ["-serialization=BITCOIN", "-create",
      "in=5897de6bd6027a475eadd57019d4e6872c396d0716c4875a5f1a6fcfdf385c1f:0",
      "replaceable=0foo"],
     "return_code": 1,
@@ -113,7 +113,7 @@
   },
   { "exec": "./bitcoin-tx",
     "args":
-    ["-create",
+    ["-serialization=BITCOIN", "-create",
      "in=5897de6bd6027a475eadd57019d4e6872c396d0716c4875a5f1a6fcfdf385c1f:0x"],
     "return_code": 1,
     "error_txt": "error: invalid TX input vout",
@@ -121,7 +121,7 @@
   },
   { "exec": "./bitcoin-tx",
     "args":
-    ["-create",
+    ["-serialization=BITCOIN", "-create",
      "outaddr=1"],
     "return_code": 1,
     "error_txt": "error: TX output missing or too many separators",
@@ -129,15 +129,15 @@
   },
   { "exec": "./bitcoin-tx",
     "args":
-    ["-create",
+    ["-serialization=BITCOIN", "-create",
      "outaddr=1:13tuJJDR2RgArmgfv6JScSdreahzgc4T6o:garbage"],
     "return_code": 1,
-    "error_txt": "error: TX output missing or too many separators",
-    "description": "Malformed outaddr argument (too many separators). Expected to fail."
+    "error_txt": "error: TX output asset type invalid for BITCOIN serialization",
+    "description": "Malformed outaddr argument (asset id for BITCOIN serialization). Expected to fail."
   },
   { "exec": "./bitcoin-tx",
     "args":
-    ["-create",
+    ["-serialization=BITCOIN", "-create",
      "outpubkey=0"],
     "return_code": 1,
     "error_txt": "error: TX output missing or too many separators",
@@ -145,7 +145,7 @@
   },
   { "exec": "./bitcoin-tx",
     "args":
-    ["-create",
+    ["-serialization=BITCOIN", "-create",
      "outpubkey=0:02a5613bd857b7048924264d1e70e08fb2a7e6527d32b7ab1bb993ac59964ff397:W:non53nse"],
     "return_code": 1,
     "error_txt": "error: TX output missing or too many separators",
@@ -153,7 +153,7 @@
   },
   { "exec": "./bitcoin-tx",
     "args":
-    ["-create",
+    ["-serialization=BITCOIN", "-create",
      "in=5897de6bd6027a475eadd57019d4e6872c396d0716c4875a5f1a6fcfdf385c1f:0",
      "in=bf829c6bcf84579331337659d31f89dfd138f7f7785802d5501c92333145ca7c:18",
      "in=22a6f904655d53ae2ff70e701a0bbd90aa3975c0f40bfc6cc996a9049e31cdfc:1",
@@ -164,7 +164,7 @@
   },
   { "exec": "./bitcoin-tx",
     "args":
-    ["-json",
+    ["-serialization=BITCOIN", "-json",
      "-create",
      "in=5897de6bd6027a475eadd57019d4e6872c396d0716c4875a5f1a6fcfdf385c1f:0",
      "in=bf829c6bcf84579331337659d31f89dfd138f7f7785802d5501c92333145ca7c:18",
@@ -175,68 +175,68 @@
     "description": "Creates a new transaction with three inputs and two outputs (output in json)"
   },
   { "exec": "./bitcoin-tx",
-    "args": ["-create", "outscript=0:"],
+    "args": ["-serialization=BITCOIN", "-create", "outscript=0:"],
     "output_cmp": "txcreate2.hex",
     "description": "Creates a new transaction with a single empty output script"
   },
   { "exec": "./bitcoin-tx",
-    "args": ["-json", "-create", "outscript=0:"],
+    "args": ["-serialization=BITCOIN", "-json", "-create", "outscript=0:"],
     "output_cmp": "txcreate2.json",
     "description": "Creates a new transaction with a single empty output script (output in json)"
   },
   { "exec": "./bitcoin-tx",
-    "args": ["02000000000100000000000000000000000000"],
+    "args": ["-serialization=BITCOIN", "02000000000100000000000000000000000000"],
     "output_cmp": "txcreate2.hex",
     "description": "Parses a transaction with no inputs and a single output script"
   },
   { "exec": "./bitcoin-tx",
-    "args": ["-json", "02000000000100000000000000000000000000"],
+    "args": ["-serialization=BITCOIN", "-json", "02000000000100000000000000000000000000"],
     "output_cmp": "txcreate2.json",
     "description": "Parses a transaction with no inputs and a single output script (output in json)"
   },
   { "exec": "./bitcoin-tx",
-    "args": ["-create", "outscript=0:OP_DROP", "nversion=1"],
+    "args": ["-serialization=BITCOIN", "-create", "outscript=0:OP_DROP", "nversion=1"],
     "output_cmp": "txcreatescript1.hex",
     "description": "Create a new transaction with a single output script (OP_DROP)"
   },
   { "exec": "./bitcoin-tx",
-    "args": ["-json", "-create", "outscript=0:OP_DROP", "nversion=1"],
+    "args": ["-serialization=BITCOIN", "-json", "-create", "outscript=0:OP_DROP", "nversion=1"],
     "output_cmp": "txcreatescript1.json",
     "description": "Create a new transaction with a single output script (OP_DROP) (output as json)"
   },
   { "exec": "./bitcoin-tx",
-    "args": ["-create", "outscript=0:OP_DROP:S", "nversion=1"],
+    "args": ["-serialization=BITCOIN", "-create", "outscript=0:OP_DROP:S", "nversion=1"],
     "output_cmp": "txcreatescript2.hex",
     "description": "Create a new transaction with a single output script (OP_DROP) in a P2SH"
   },
   { "exec": "./bitcoin-tx",
-    "args": ["-json", "-create", "outscript=0:OP_DROP:S", "nversion=1"],
+    "args": ["-serialization=BITCOIN", "-json", "-create", "outscript=0:OP_DROP:S", "nversion=1"],
     "output_cmp": "txcreatescript2.json",
     "description": "Create a new transaction with a single output script (OP_DROP) in a P2SH (output as json)"
   },
   { "exec": "./bitcoin-tx",
-    "args": ["-create", "outscript=0:OP_DROP:W", "nversion=1"],
+    "args": ["-serialization=BITCOIN", "-create", "outscript=0:OP_DROP:W", "nversion=1"],
     "output_cmp": "txcreatescript3.hex",
     "description": "Create a new transaction with a single output script (OP_DROP) in a P2WSH"
   },
   { "exec": "./bitcoin-tx",
-    "args": ["-json", "-create", "outscript=0:OP_DROP:W", "nversion=1"],
+    "args": ["-serialization=BITCOIN", "-json", "-create", "outscript=0:OP_DROP:W", "nversion=1"],
     "output_cmp": "txcreatescript3.json",
     "description": "Create a new transaction with a single output script (OP_DROP) in a P2WSH (output as json)"
   },
   { "exec": "./bitcoin-tx",
-    "args": ["-create", "outscript=0:OP_DROP:WS", "nversion=1"],
+    "args": ["-serialization=BITCOIN", "-create", "outscript=0:OP_DROP:WS", "nversion=1"],
     "output_cmp": "txcreatescript4.hex",
     "description": "Create a new transaction with a single output script (OP_DROP) in a P2WSH, wrapped in a P2SH"
   },
   { "exec": "./bitcoin-tx",
-    "args": ["-json", "-create", "outscript=0:OP_DROP:WS", "nversion=1"],
+    "args": ["-serialization=BITCOIN", "-json", "-create", "outscript=0:OP_DROP:WS", "nversion=1"],
     "output_cmp": "txcreatescript4.json",
     "description": "Create a new transaction with a single output script (OP_DROP) in a P2SH, wrapped in a P2SH (output as json)"
   },
   { "exec": "./bitcoin-tx",
     "args":
-    ["-create", "nversion=1",
+    ["-serialization=BITCOIN", "-create", "nversion=1",
      "in=4d49a71ec9da436f71ec4ee231d04f292a29cd316f598bb7068feccabdc59485:0",
      "set=privatekeys:[\"5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip4nEB3kEsreAnchuDf\"]",
      "set=prevtxs:[{\"txid\":\"4d49a71ec9da436f71ec4ee231d04f292a29cd316f598bb7068feccabdc59485\",\"vout\":0,\"scriptPubKey\":\"76a91491b24bf9f5288532960ac687abb035127b1d28a588ac\"}]",
@@ -247,7 +247,7 @@
   },
   { "exec": "./bitcoin-tx",
     "args":
-    ["-json",
+    ["-serialization=BITCOIN", "-json",
      "-create", "nversion=1",
      "in=4d49a71ec9da436f71ec4ee231d04f292a29cd316f598bb7068feccabdc59485:0",
      "set=privatekeys:[\"5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip4nEB3kEsreAnchuDf\"]",
@@ -259,7 +259,7 @@
   },
   { "exec": "./bitcoin-tx",
     "args":
-    ["-create",
+    ["-serialization=BITCOIN", "-create",
       "in=4d49a71ec9da436f71ec4ee231d04f292a29cd316f598bb7068feccabdc59485:0",
       "set=privatekeys:[\"5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip4nEB3kEsreAnchuDf\"]",
       "set=prevtxs:[{\"txid\":\"4d49a71ec9da436f71ec4ee231d04f292a29cd316f598bb7068feccabdc59485\",\"vout\":0,\"scriptPubKey\":\"76a91491b24bf9f5288532960ac687abb035127b1d28a588ac\"}]",
@@ -270,7 +270,7 @@
   },
   { "exec": "./bitcoin-tx",
     "args":
-    ["-create",
+    ["-serialization=BITCOIN", "-create",
       "in=4d49a71ec9da436f71ec4ee231d04f292a29cd316f598bb7068feccabdc59485:0",
       "set=privatekeys:[\"5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip4nEB3kEsreAnchuDf\"]",
       "set=prevtxs:[{\"txid\":\"4d49a71ec9da436f71ec4ee231d04f292a29cd316f598bb7068feccabdc59485\",\"vout\":\"0foo\",\"scriptPubKey\":\"76a91491b24bf9f5288532960ac687abb035127b1d28a588ac\"}]",
@@ -282,50 +282,50 @@
   },
   { "exec": "./bitcoin-tx",
     "args":
-    ["-create", "outpubkey=0:02a5613bd857b7048924264d1e70e08fb2a7e6527d32b7ab1bb993ac59964ff397", "nversion=1"],
+    ["-serialization=BITCOIN", "-create", "outpubkey=0:02a5613bd857b7048924264d1e70e08fb2a7e6527d32b7ab1bb993ac59964ff397", "nversion=1"],
     "output_cmp": "txcreateoutpubkey1.hex",
     "description": "Creates a new transaction with a single pay-to-pubkey output"
   },
   { "exec": "./bitcoin-tx",
     "args":
-    ["-json", "-create", "outpubkey=0:02a5613bd857b7048924264d1e70e08fb2a7e6527d32b7ab1bb993ac59964ff397", "nversion=1"],
+    ["-serialization=BITCOIN", "-json", "-create", "outpubkey=0:02a5613bd857b7048924264d1e70e08fb2a7e6527d32b7ab1bb993ac59964ff397", "nversion=1"],
     "output_cmp": "txcreateoutpubkey1.json",
     "description": "Creates a new transaction with a single pay-to-pubkey output (output as json)"
   },
   { "exec": "./bitcoin-tx",
     "args":
-    ["-create", "outpubkey=0:02a5613bd857b7048924264d1e70e08fb2a7e6527d32b7ab1bb993ac59964ff397:W", "nversion=1"],
+    ["-serialization=BITCOIN", "-create", "outpubkey=0:02a5613bd857b7048924264d1e70e08fb2a7e6527d32b7ab1bb993ac59964ff397:W", "nversion=1"],
     "output_cmp": "txcreateoutpubkey2.hex",
     "description": "Creates a new transaction with a single pay-to-witness-pubkey output"
   },
   { "exec": "./bitcoin-tx",
     "args":
-    ["-json", "-create", "outpubkey=0:02a5613bd857b7048924264d1e70e08fb2a7e6527d32b7ab1bb993ac59964ff397:W", "nversion=1"],
+    ["-serialization=BITCOIN", "-json", "-create", "outpubkey=0:02a5613bd857b7048924264d1e70e08fb2a7e6527d32b7ab1bb993ac59964ff397:W", "nversion=1"],
     "output_cmp": "txcreateoutpubkey2.json",
     "description": "Creates a new transaction with a single pay-to-witness-pubkey output (output as json)"
   },
   { "exec": "./bitcoin-tx",
     "args":
-    ["-create", "outpubkey=0:02a5613bd857b7048924264d1e70e08fb2a7e6527d32b7ab1bb993ac59964ff397:WS", "nversion=1"],
+    ["-serialization=BITCOIN", "-create", "outpubkey=0:02a5613bd857b7048924264d1e70e08fb2a7e6527d32b7ab1bb993ac59964ff397:WS", "nversion=1"],
     "output_cmp": "txcreateoutpubkey3.hex",
     "description": "Creates a new transaction with a single pay-to-witness-pubkey, wrapped in P2SH output"
   },
   { "exec": "./bitcoin-tx",
     "args":
-    ["-json", "-create", "outpubkey=0:02a5613bd857b7048924264d1e70e08fb2a7e6527d32b7ab1bb993ac59964ff397:WS", "nversion=1"],
+    ["-serialization=BITCOIN", "-json", "-create", "outpubkey=0:02a5613bd857b7048924264d1e70e08fb2a7e6527d32b7ab1bb993ac59964ff397:WS", "nversion=1"],
     "output_cmp": "txcreateoutpubkey3.json",
     "description": "Creates a new transaction with a single pay-to-pub-key output, wrapped in P2SH (output as json)"
   },
   { "exec": "./bitcoin-tx",
     "args":
-    ["-json", "-create", "outpubkey=0:047d1368ba7ae01c94bc32293efd70bd7e3be7aa7912d07d0b1c659c1008d179b8642f5fb90f47580feb29f045e216ff5a4716d3a0fed36da414d332046303c44a:WS", "nversion=1"],
+    ["-serialization=BITCOIN", "-json", "-create", "outpubkey=0:047d1368ba7ae01c94bc32293efd70bd7e3be7aa7912d07d0b1c659c1008d179b8642f5fb90f47580feb29f045e216ff5a4716d3a0fed36da414d332046303c44a:WS", "nversion=1"],
     "return_code": 1,
     "error_txt": "error: Uncompressed pubkeys are not useable for SegWit outputs",
     "description": "Creates a new transaction with a single pay-to-pub-key output, wrapped in P2SH (output as json)"
   },
   { "exec": "./bitcoin-tx",
     "args":
-    ["-create",
+    ["-serialization=BITCOIN", "-create",
      "in=5897de6bd6027a475eadd57019d4e6872c396d0716c4875a5f1a6fcfdf385c1f:0",
      "outdata=4:badhexdata"],
     "return_code": 1,
@@ -334,7 +334,7 @@
   },
   { "exec": "./bitcoin-tx",
     "args":
-    ["-create",
+    ["-serialization=BITCOIN", "-create",
      "in=5897de6bd6027a475eadd57019d4e6872c396d0716c4875a5f1a6fcfdf385c1f:0",
      "outdata=badhexdata"],
     "return_code": 1,
@@ -343,7 +343,7 @@
   },
   { "exec": "./bitcoin-tx",
     "args":
-    ["-create",
+    ["-serialization=BITCOIN", "-create",
      "in=5897de6bd6027a475eadd57019d4e6872c396d0716c4875a5f1a6fcfdf385c1f:0",
      "outaddr=0.18:13tuJJDR2RgArmgfv6JScSdreahzgc4T6o",
      "outdata=4:54686973204f505f52455455524e207472616e73616374696f6e206f7574707574207761732063726561746564206279206d6f646966696564206372656174657261777472616e73616374696f6e2e"],
@@ -352,7 +352,7 @@
   },
   { "exec": "./bitcoin-tx",
     "args":
-    ["-json",
+    ["-serialization=BITCOIN", "-json",
      "-create", "nversion=1",
      "in=5897de6bd6027a475eadd57019d4e6872c396d0716c4875a5f1a6fcfdf385c1f:0",
      "outaddr=0.18:13tuJJDR2RgArmgfv6JScSdreahzgc4T6o",
@@ -362,7 +362,7 @@
   },
   { "exec": "./bitcoin-tx",
     "args":
-    ["-create",
+    ["-serialization=BITCOIN", "-create",
      "in=5897de6bd6027a475eadd57019d4e6872c396d0716c4875a5f1a6fcfdf385c1f:0",
      "outaddr=0.18:13tuJJDR2RgArmgfv6JScSdreahzgc4T6o",
      "outdata=54686973204f505f52455455524e207472616e73616374696f6e206f7574707574207761732063726561746564206279206d6f646966696564206372656174657261777472616e73616374696f6e2e"],
@@ -371,7 +371,7 @@
   },
   { "exec": "./bitcoin-tx",
     "args":
-    ["-json",
+    ["-serialization=BITCOIN", "-json",
      "-create",
      "in=5897de6bd6027a475eadd57019d4e6872c396d0716c4875a5f1a6fcfdf385c1f:0",
      "outaddr=0.18:13tuJJDR2RgArmgfv6JScSdreahzgc4T6o",
@@ -381,7 +381,7 @@
   },
   { "exec": "./bitcoin-tx",
     "args":
-    ["-create",
+    ["-serialization=BITCOIN", "-create",
      "in=5897de6bd6027a475eadd57019d4e6872c396d0716c4875a5f1a6fcfdf385c1f:0:4294967293",
      "outaddr=0.18:13tuJJDR2RgArmgfv6JScSdreahzgc4T6o"],
     "output_cmp": "txcreatedata_seq0.hex",
@@ -389,7 +389,7 @@
   },
   { "exec": "./bitcoin-tx",
     "args":
-    ["-json",
+    ["-serialization=BITCOIN", "-json",
      "-create",
      "in=5897de6bd6027a475eadd57019d4e6872c396d0716c4875a5f1a6fcfdf385c1f:0:4294967293",
      "outaddr=0.18:13tuJJDR2RgArmgfv6JScSdreahzgc4T6o"],
@@ -398,68 +398,91 @@
   },
   { "exec": "./bitcoin-tx",
     "args":
-    ["01000000011f5c38dfcf6f1a5f5a87c416076d392c87e6d41970d5ad5e477a02d66bde97580000000000fdffffff0180a81201000000001976a9141fc11f39be1729bf973a7ab6a615ca4729d6457488ac00000000",
+    ["-serialization=BITCOIN", "01000000011f5c38dfcf6f1a5f5a87c416076d392c87e6d41970d5ad5e477a02d66bde97580000000000fdffffff0180a81201000000001976a9141fc11f39be1729bf973a7ab6a615ca4729d6457488ac00000000",
      "in=5897de6bd6027a475eadd57019d4e6872c396d0716c4875a5f1a6fcfdf385c1f:0:1"],
     "output_cmp": "txcreatedata_seq1.hex",
     "description": "Adds a new input with sequence number to a transaction"
   },
   { "exec": "./bitcoin-tx",
     "args":
-    ["-json",
+    ["-serialization=BITCOIN", "-json",
      "01000000011f5c38dfcf6f1a5f5a87c416076d392c87e6d41970d5ad5e477a02d66bde97580000000000fdffffff0180a81201000000001976a9141fc11f39be1729bf973a7ab6a615ca4729d6457488ac00000000",
      "in=5897de6bd6027a475eadd57019d4e6872c396d0716c4875a5f1a6fcfdf385c1f:0:1"],
     "output_cmp": "txcreatedata_seq1.json",
     "description": "Adds a new input with sequence number to a transaction (output in json)"
   },
   { "exec": "./bitcoin-tx",
-    "args": ["-create", "outmultisig=1:2:3:02a5613bd857b7048924264d1e70e08fb2a7e6527d32b7ab1bb993ac59964ff397:021ac43c7ff740014c3b33737ede99c967e4764553d1b2b83db77c83b8715fa72d:02df2089105c77f266fa11a9d33f05c735234075f2e8780824c6b709415f9fb485", "nversion=1"],
+    "args": ["-serialization=BITCOIN", "-create", "outmultisig=1:2:3:02a5613bd857b7048924264d1e70e08fb2a7e6527d32b7ab1bb993ac59964ff397:021ac43c7ff740014c3b33737ede99c967e4764553d1b2b83db77c83b8715fa72d:02df2089105c77f266fa11a9d33f05c735234075f2e8780824c6b709415f9fb485", "nversion=1"],
     "output_cmp": "txcreatemultisig1.hex",
     "description": "Creates a new transaction with a single 2-of-3 multisig output"
   },
   { "exec": "./bitcoin-tx",
-    "args": ["-json", "-create", "outmultisig=1:2:3:02a5613bd857b7048924264d1e70e08fb2a7e6527d32b7ab1bb993ac59964ff397:021ac43c7ff740014c3b33737ede99c967e4764553d1b2b83db77c83b8715fa72d:02df2089105c77f266fa11a9d33f05c735234075f2e8780824c6b709415f9fb485", "nversion=1"],
+    "args": ["-serialization=BITCOIN", "-json", "-create", "outmultisig=1:2:3:02a5613bd857b7048924264d1e70e08fb2a7e6527d32b7ab1bb993ac59964ff397:021ac43c7ff740014c3b33737ede99c967e4764553d1b2b83db77c83b8715fa72d:02df2089105c77f266fa11a9d33f05c735234075f2e8780824c6b709415f9fb485", "nversion=1"],
     "output_cmp": "txcreatemultisig1.json",
     "description": "Creates a new transaction with a single 2-of-3 multisig output (output in json)"
   },
   { "exec": "./bitcoin-tx",
-    "args": ["-create", "outmultisig=1:2:3:02a5613bd857b7048924264d1e70e08fb2a7e6527d32b7ab1bb993ac59964ff397:021ac43c7ff740014c3b33737ede99c967e4764553d1b2b83db77c83b8715fa72d:02df2089105c77f266fa11a9d33f05c735234075f2e8780824c6b709415f9fb485:S", "nversion=1"],
+    "args": ["-serialization=BITCOIN", "-create", "outmultisig=1:2:3:02a5613bd857b7048924264d1e70e08fb2a7e6527d32b7ab1bb993ac59964ff397:021ac43c7ff740014c3b33737ede99c967e4764553d1b2b83db77c83b8715fa72d:02df2089105c77f266fa11a9d33f05c735234075f2e8780824c6b709415f9fb485:S", "nversion=1"],
     "output_cmp": "txcreatemultisig2.hex",
     "description": "Creates a new transaction with a single 2-of-3 multisig in a P2SH output"
   },
   { "exec": "./bitcoin-tx",
-    "args": ["-json", "-create", "outmultisig=1:2:3:02a5613bd857b7048924264d1e70e08fb2a7e6527d32b7ab1bb993ac59964ff397:021ac43c7ff740014c3b33737ede99c967e4764553d1b2b83db77c83b8715fa72d:02df2089105c77f266fa11a9d33f05c735234075f2e8780824c6b709415f9fb485:S", "nversion=1"],
+    "args": ["-serialization=BITCOIN", "-json", "-create", "outmultisig=1:2:3:02a5613bd857b7048924264d1e70e08fb2a7e6527d32b7ab1bb993ac59964ff397:021ac43c7ff740014c3b33737ede99c967e4764553d1b2b83db77c83b8715fa72d:02df2089105c77f266fa11a9d33f05c735234075f2e8780824c6b709415f9fb485:S", "nversion=1"],
     "output_cmp": "txcreatemultisig2.json",
     "description": "Creates a new transaction with a single 2-of-3 multisig in a P2SH output (output in json)"
   },
   { "exec": "./bitcoin-tx",
-    "args": ["-create", "outmultisig=1:2:3:02a5613bd857b7048924264d1e70e08fb2a7e6527d32b7ab1bb993ac59964ff397:021ac43c7ff740014c3b33737ede99c967e4764553d1b2b83db77c83b8715fa72d:02df2089105c77f266fa11a9d33f05c735234075f2e8780824c6b709415f9fb485:W", "nversion=1"],
+    "args": ["-serialization=BITCOIN", "-create", "outmultisig=1:2:3:02a5613bd857b7048924264d1e70e08fb2a7e6527d32b7ab1bb993ac59964ff397:021ac43c7ff740014c3b33737ede99c967e4764553d1b2b83db77c83b8715fa72d:02df2089105c77f266fa11a9d33f05c735234075f2e8780824c6b709415f9fb485:W", "nversion=1"],
     "output_cmp": "txcreatemultisig3.hex",
     "description": "Creates a new transaction with a single 2-of-3 multisig in a P2WSH output"
   },
   { "exec": "./bitcoin-tx",
-    "args": ["-json", "-create", "outmultisig=1:2:3:02a5613bd857b7048924264d1e70e08fb2a7e6527d32b7ab1bb993ac59964ff397:021ac43c7ff740014c3b33737ede99c967e4764553d1b2b83db77c83b8715fa72d:02df2089105c77f266fa11a9d33f05c735234075f2e8780824c6b709415f9fb485:W", "nversion=1"],
+    "args": ["-serialization=BITCOIN", "-json", "-create", "outmultisig=1:2:3:02a5613bd857b7048924264d1e70e08fb2a7e6527d32b7ab1bb993ac59964ff397:021ac43c7ff740014c3b33737ede99c967e4764553d1b2b83db77c83b8715fa72d:02df2089105c77f266fa11a9d33f05c735234075f2e8780824c6b709415f9fb485:W", "nversion=1"],
     "output_cmp": "txcreatemultisig3.json",
     "description": "Creates a new transaction with a single 2-of-3 multisig in a P2WSH output (output in json)"
   },
   { "exec": "./bitcoin-tx",
-    "args": ["-create", "outmultisig=1:2:3:02a5613bd857b7048924264d1e70e08fb2a7e6527d32b7ab1bb993ac59964ff397:021ac43c7ff740014c3b33737ede99c967e4764553d1b2b83db77c83b8715fa72d:02df2089105c77f266fa11a9d33f05c735234075f2e8780824c6b709415f9fb485:WS", "nversion=1"],
+    "args": ["-serialization=BITCOIN", "-create", "outmultisig=1:2:3:02a5613bd857b7048924264d1e70e08fb2a7e6527d32b7ab1bb993ac59964ff397:021ac43c7ff740014c3b33737ede99c967e4764553d1b2b83db77c83b8715fa72d:02df2089105c77f266fa11a9d33f05c735234075f2e8780824c6b709415f9fb485:WS", "nversion=1"],
     "output_cmp": "txcreatemultisig4.hex",
     "description": "Creates a new transaction with a single 2-of-3 multisig in a P2WSH output, wrapped in P2SH"
   },
   { "exec": "./bitcoin-tx",
-    "args": ["-json", "-create", "outmultisig=1:2:3:02a5613bd857b7048924264d1e70e08fb2a7e6527d32b7ab1bb993ac59964ff397:021ac43c7ff740014c3b33737ede99c967e4764553d1b2b83db77c83b8715fa72d:02df2089105c77f266fa11a9d33f05c735234075f2e8780824c6b709415f9fb485:WS", "nversion=1"],
+    "args": ["-serialization=BITCOIN", "-json", "-create", "outmultisig=1:2:3:02a5613bd857b7048924264d1e70e08fb2a7e6527d32b7ab1bb993ac59964ff397:021ac43c7ff740014c3b33737ede99c967e4764553d1b2b83db77c83b8715fa72d:02df2089105c77f266fa11a9d33f05c735234075f2e8780824c6b709415f9fb485:WS", "nversion=1"],
     "output_cmp": "txcreatemultisig4.json",
     "description": "Creates a new transaction with a single 2-of-3 multisig in a P2WSH output, wrapped in P2SH (output in json)"
   },
   { "exec": "./bitcoin-tx",
-    "args": ["-json", "-create", "outmultisig=1:2:3:02a5613bd857b7048924264d1e70e08fb2a7e6527d32b7ab1bb993ac59964ff397:021ac43c7ff740014c3b33737ede99c967e4764553d1b2b83db77c83b8715fa72d:047d1368ba7ae01c94bc32293efd70bd7e3be7aa7912d07d0b1c659c1008d179b8642f5fb90f47580feb29f045e216ff5a4716d3a0fed36da414d332046303c44a:S"],
+    "args": ["-serialization=BITCOIN", "-json", "-create", "outmultisig=1:2:3:02a5613bd857b7048924264d1e70e08fb2a7e6527d32b7ab1bb993ac59964ff397:021ac43c7ff740014c3b33737ede99c967e4764553d1b2b83db77c83b8715fa72d:047d1368ba7ae01c94bc32293efd70bd7e3be7aa7912d07d0b1c659c1008d179b8642f5fb90f47580feb29f045e216ff5a4716d3a0fed36da414d332046303c44a:S"],
     "output_cmp": "txcreatemultisig5.json",
     "description": "Uncompressed pubkeys should work just fine for non-witness outputs"
   },
   { "exec": "./bitcoin-tx",
-    "args": ["-json", "-create", "outmultisig=1:2:3:02a5613bd857b7048924264d1e70e08fb2a7e6527d32b7ab1bb993ac59964ff397:021ac43c7ff740014c3b33737ede99c967e4764553d1b2b83db77c83b8715fa72d:047d1368ba7ae01c94bc32293efd70bd7e3be7aa7912d07d0b1c659c1008d179b8642f5fb90f47580feb29f045e216ff5a4716d3a0fed36da414d332046303c44a:WS"],
+    "args": ["-serialization=BITCOIN", "-json", "-create", "outmultisig=1:2:3:02a5613bd857b7048924264d1e70e08fb2a7e6527d32b7ab1bb993ac59964ff397:021ac43c7ff740014c3b33737ede99c967e4764553d1b2b83db77c83b8715fa72d:047d1368ba7ae01c94bc32293efd70bd7e3be7aa7912d07d0b1c659c1008d179b8642f5fb90f47580feb29f045e216ff5a4716d3a0fed36da414d332046303c44a:WS"],
     "return_code": 1,
     "error_txt": "error: Uncompressed pubkeys are not useable for SegWit outputs",
     "description": "Ensure adding witness outputs with uncompressed pubkeys fails"
+  },
+  { "exec": "./bitcoin-tx",
+    "args": ["-serialization=ELEMENTS", "-create", "outmultisig=1:2:3:02a5613bd857b7048924264d1e70e08fb2a7e6527d32b7ab1bb993ac59964ff397:021ac43c7ff740014c3b33737ede99c967e4764553d1b2b83db77c83b8715fa72d:02df2089105c77f266fa11a9d33f05c735234075f2e8780824c6b709415f9fb485:WS", "nversion=1"],
+    "output_cmp": "txcreatemultisig4_elements.hex",
+    "description": "Creates a new transaction with a single 2-of-3 multisig in a P2WSH output, wrapped in P2SH. Elements serialization."
+  },
+  { "exec": "./bitcoin-tx",
+    "args": ["-create", "-json", "outmultisig=1:2:3:02a5613bd857b7048924264d1e70e08fb2a7e6527d32b7ab1bb993ac59964ff397:021ac43c7ff740014c3b33737ede99c967e4764553d1b2b83db77c83b8715fa72d:02df2089105c77f266fa11a9d33f05c735234075f2e8780824c6b709415f9fb485:WS", "nversion=1"],
+    "output_cmp": "txcreatemultisig4_elements.json",
+    "description": "Creates a new transaction with a single 2-of-3 multisig in a P2WSH output, wrapped in P2SH. Elements serialization, without serialization arg. (output in json)"
+  },
+  { "exec": "./bitcoin-tx",
+    "args":
+    ["-create",
+     "outaddr=1:13tuJJDR2RgArmgfv6JScSdreahzgc4T6o:garbage"],
+    "return_code": 1,
+    "error_txt": "error: invalid TX output asset type",
+    "description": "Malformed outaddr argument (bad asset id). Expected to fail."
+  },
+  { "exec": "./bitcoin-tx",
+    "args": ["-create", "outmultisig=1:2:3:02a5613bd857b7048924264d1e70e08fb2a7e6527d32b7ab1bb993ac59964ff397:021ac43c7ff740014c3b33737ede99c967e4764553d1b2b83db77c83b8715fa72d:02df2089105c77f266fa11a9d33f05c735234075f2e8780824c6b709415f9fb485:WS", "nversion=1"],
+    "output_cmp": "txcreatemultisig4_elements.hex",
+    "description": "Creates a new transaction with a single 2-of-3 multisig in a P2WSH output, wrapped in P2SH. Elements serialization, without serialization arg."
   }
 ]
diff --git a/test/util/data/txcreatemultisig4_elements.hex b/test/util/data/txcreatemultisig4_elements.hex
new file mode 100644
index 0000000000000..2b0a5d1d1474b
--- /dev/null
+++ b/test/util/data/txcreatemultisig4_elements.hex
@@ -0,0 +1 @@
+01000000000001010000000000000000000000000000000000000000000000000000000000000000010000000005f5e1000017a9146edf12858999f0dae74f9c692e6694ee3621b2ac8700000000
diff --git a/test/util/data/txcreatemultisig4_elements.json b/test/util/data/txcreatemultisig4_elements.json
new file mode 100644
index 0000000000000..bce6edbb49922
--- /dev/null
+++ b/test/util/data/txcreatemultisig4_elements.json
@@ -0,0 +1,32 @@
+{
+    "txid": "95b2c6399f5624a7171d20ba4c7227874128e0addd9bf36a4aa9576dd8098226",
+    "hash": "95b2c6399f5624a7171d20ba4c7227874128e0addd9bf36a4aa9576dd8098226",
+    "wtxid": "95b2c6399f5624a7171d20ba4c7227874128e0addd9bf36a4aa9576dd8098226",
+    "withash": "d0d3b17552f63780c06e5558483412d8384702cd777404f52a8a9680304fe582",
+    "version": 1,
+    "size": 78,
+    "vsize": 78,
+    "weight": 312,
+    "locktime": 0,
+    "vin": [
+    ],
+    "vout": [
+        {
+            "value": 1.00000000,
+            "asset": "0000000000000000000000000000000000000000000000000000000000000000",
+            "commitmentnonce": "",
+            "commitmentnonce_fully_valid": false,
+            "n": 0,
+            "scriptPubKey": {
+                "asm": "OP_HASH160 6edf12858999f0dae74f9c692e6694ee3621b2ac OP_EQUAL",
+                "hex": "a9146edf12858999f0dae74f9c692e6694ee3621b2ac87",
+                "reqSigs": 1,
+                "type": "scripthash",
+                "addresses": [
+                    "3BoFUz1StqcNcgUTZE5cC1eFhuYFzj3fGH"
+                ]
+            }
+        }
+    ],
+    "hex": "01000000000001010000000000000000000000000000000000000000000000000000000000000000010000000005f5e1000017a9146edf12858999f0dae74f9c692e6694ee3621b2ac8700000000"
+}