diff --git a/src/cashaddrenc.cpp b/src/cashaddrenc.cpp
index fd29c42c3..9ea0e50ed 100644
--- a/src/cashaddrenc.cpp
+++ b/src/cashaddrenc.cpp
@@ -1,180 +1,178 @@
 // Copyright (c) 2017-2019 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 #include <cashaddrenc.h>
 
 #include <cashaddr.h>
 #include <chainparams.h>
 #include <pubkey.h>
 #include <script/script.h>
 #include <util/strencodings.h>
 
 #include <boost/variant/static_visitor.hpp>
 
 #include <algorithm>
 
 namespace {
 
 // Convert the data part to a 5 bit representation.
 template <class T>
 std::vector<uint8_t> PackAddrData(const T &id, uint8_t type) {
     uint8_t version_byte(type << 3);
     size_t size = id.size();
     uint8_t encoded_size = 0;
     switch (size * 8) {
         case 160:
             encoded_size = 0;
             break;
         case 192:
             encoded_size = 1;
             break;
         case 224:
             encoded_size = 2;
             break;
         case 256:
             encoded_size = 3;
             break;
         case 320:
             encoded_size = 4;
             break;
         case 384:
             encoded_size = 5;
             break;
         case 448:
             encoded_size = 6;
             break;
         case 512:
             encoded_size = 7;
             break;
         default:
             throw std::runtime_error(
                 "Error packing cashaddr: invalid address length");
     }
     version_byte |= encoded_size;
     std::vector<uint8_t> data = {version_byte};
     data.insert(data.end(), std::begin(id), std::end(id));
 
     std::vector<uint8_t> converted;
     // Reserve the number of bytes required for a 5-bit packed version of a
     // hash, with version byte.  Add half a byte(4) so integer math provides
     // the next multiple-of-5 that would fit all the data.
     converted.reserve(((size + 1) * 8 + 4) / 5);
     ConvertBits<8, 5, true>([&](uint8_t c) { converted.push_back(c); },
                             std::begin(data), std::end(data));
 
     return converted;
 }
 
 // Implements encoding of CTxDestination using cashaddr.
 class CashAddrEncoder : public boost::static_visitor<std::string> {
 public:
     explicit CashAddrEncoder(const CChainParams &p) : params(p) {}
 
     std::string operator()(const PKHash &id) const {
         std::vector<uint8_t> data = PackAddrData(id, PUBKEY_TYPE);
         return cashaddr::Encode(params.CashAddrPrefix(), data);
     }
 
     std::string operator()(const ScriptHash &id) const {
         std::vector<uint8_t> data = PackAddrData(id, SCRIPT_TYPE);
         return cashaddr::Encode(params.CashAddrPrefix(), data);
     }
 
     std::string operator()(const CNoDestination &) const { return ""; }
 
 private:
     const CChainParams &params;
 };
 
 } // namespace
 
 std::string EncodeCashAddr(const CTxDestination &dst,
                            const CChainParams &params) {
     return boost::apply_visitor(CashAddrEncoder(params), dst);
 }
 
 std::string EncodeCashAddr(const std::string &prefix,
                            const CashAddrContent &content) {
     std::vector<uint8_t> data = PackAddrData(content.hash, content.type);
     return cashaddr::Encode(prefix, data);
 }
 
 CTxDestination DecodeCashAddr(const std::string &addr,
                               const CChainParams &params) {
     CashAddrContent content =
         DecodeCashAddrContent(addr, params.CashAddrPrefix());
     if (content.hash.size() == 0) {
         return CNoDestination{};
     }
 
     return DecodeCashAddrDestination(content);
 }
 
 CashAddrContent DecodeCashAddrContent(const std::string &addr,
                                       const std::string &expectedPrefix) {
-    std::string prefix;
-    std::vector<uint8_t> payload;
-    std::tie(prefix, payload) = cashaddr::Decode(addr, expectedPrefix);
+    auto [prefix, payload] = cashaddr::Decode(addr, expectedPrefix);
 
     if (prefix != expectedPrefix) {
         return {};
     }
 
     if (payload.empty()) {
         return {};
     }
 
     std::vector<uint8_t> data;
     data.reserve(payload.size() * 5 / 8);
     if (!ConvertBits<5, 8, false>([&](uint8_t c) { data.push_back(c); },
                                   begin(payload), end(payload))) {
         return {};
     }
 
     // Decode type and size from the version.
     uint8_t version = data[0];
     if (version & 0x80) {
         // First bit is reserved.
         return {};
     }
 
     auto type = CashAddrType((version >> 3) & 0x1f);
     uint32_t hash_size = 20 + 4 * (version & 0x03);
     if (version & 0x04) {
         hash_size *= 2;
     }
 
     // Check that we decoded the exact number of bytes we expected.
     if (data.size() != hash_size + 1) {
         return {};
     }
 
     // Pop the version.
     data.erase(data.begin());
     return {type, std::move(data)};
 }
 
 CTxDestination DecodeCashAddrDestination(const CashAddrContent &content) {
     if (content.hash.size() != 20) {
         // Only 20 bytes hash are supported now.
         return CNoDestination{};
     }
 
     uint160 hash;
     std::copy(begin(content.hash), end(content.hash), hash.begin());
 
     switch (content.type) {
         case PUBKEY_TYPE:
             return PKHash(hash);
         case SCRIPT_TYPE:
             return ScriptHash(hash);
         default:
             return CNoDestination{};
     }
 }
 
 // PackCashAddrContent allows for testing PackAddrData in unittests due to
 // template definitions.
 std::vector<uint8_t> PackCashAddrContent(const CashAddrContent &content) {
     return PackAddrData(content.hash, content.type);
 }
diff --git a/src/test/cashaddr_tests.cpp b/src/test/cashaddr_tests.cpp
index be338a5da..f8c002219 100644
--- a/src/test/cashaddr_tests.cpp
+++ b/src/test/cashaddr_tests.cpp
@@ -1,97 +1,93 @@
 // Copyright (c) 2017 Pieter Wuille
 // Copyright (c) 2017-2019 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <cashaddr.h>
 
 #include <test/util/setup_common.h>
 #include <test/util/str.h>
 
 #include <boost/test/unit_test.hpp>
 
 static std::pair<std::string, std::vector<uint8_t>>
 CashAddrDecode(const std::string &str) {
     return cashaddr::Decode(str, "");
 }
 
 BOOST_FIXTURE_TEST_SUITE(cashaddr_tests, BasicTestingSetup)
 
 BOOST_AUTO_TEST_CASE(cashaddr_testvectors_valid) {
     static const std::string CASES[] = {
         "prefix:x64nx6hz",
         "PREFIX:X64NX6HZ",
         "p:gpf8m4h7",
         "bitcoincash:qpzry9x8gf2tvdw0s3jn54khce6mua7lcw20ayyn",
         "bchtest:testnetaddress4d6njnut",
         "bchreg:555555555555555555555555555555555555555555555udxmlmrz",
     };
 
     for (const std::string &str : CASES) {
-        auto ret = CashAddrDecode(str);
-        BOOST_CHECK_MESSAGE(!ret.first.empty(), str);
-        std::string recode = cashaddr::Encode(ret.first, ret.second);
+        auto [prefix, payload] = CashAddrDecode(str);
+        BOOST_CHECK_MESSAGE(!prefix.empty(), str);
+        std::string recode = cashaddr::Encode(prefix, payload);
         BOOST_CHECK_MESSAGE(!recode.empty(), str);
         BOOST_CHECK_MESSAGE(CaseInsensitiveEqual(str, recode), str);
     }
 }
 
 BOOST_AUTO_TEST_CASE(cashaddr_testvectors_invalid) {
     static const std::string CASES[] = {
         "prefix:x32nx6hz",
         "prEfix:x64nx6hz",
         "prefix:x64nx6Hz",
         "pref1x:6m8cxv73",
         "prefix:",
         ":u9wsx07j",
         "bchreg:555555555555555555x55555555555555555555555555udxmlmrz",
         "bchreg:555555555555555555555555555555551555555555555udxmlmrz",
         "pre:fix:x32nx6hz",
         "prefixx64nx6hz",
     };
 
     for (const std::string &str : CASES) {
-        auto ret = CashAddrDecode(str);
-        BOOST_CHECK_MESSAGE(ret.first.empty(), str);
+        auto [prefix, payload] = CashAddrDecode(str);
+        BOOST_CHECK_MESSAGE(prefix.empty(), str);
     }
 }
 
 BOOST_AUTO_TEST_CASE(cashaddr_rawencode) {
-    typedef std::pair<std::string, std::vector<uint8_t>> raw;
+    std::string prefix = "helloworld";
+    std::vector<uint8_t> payload = {0x1f, 0x0d};
 
-    raw toEncode;
-    toEncode.first = "helloworld";
-    toEncode.second = {0x1f, 0x0d};
+    std::string encoded = cashaddr::Encode(prefix, payload);
+    auto [decoded_prefix, decoded_payload] = CashAddrDecode(encoded);
 
-    std::string encoded = cashaddr::Encode(toEncode.first, toEncode.second);
-    raw decoded = CashAddrDecode(encoded);
-
-    BOOST_CHECK_EQUAL(toEncode.first, decoded.first);
-    BOOST_CHECK_EQUAL_COLLECTIONS(begin(toEncode.second), end(toEncode.second),
-                                  begin(decoded.second), end(decoded.second));
+    BOOST_CHECK_EQUAL(prefix, decoded_prefix);
+    BOOST_CHECK_EQUAL_COLLECTIONS(begin(payload), end(payload),
+                                  begin(decoded_payload), end(decoded_payload));
 }
 
 BOOST_AUTO_TEST_CASE(cashaddr_testvectors_noprefix) {
     static const std::pair<std::string, std::string> CASES[] = {
         {"bitcoincash", "qpzry9x8gf2tvdw0s3jn54khce6mua7lcw20ayyn"},
         {"prefix", "x64nx6hz"},
         {"PREFIX", "X64NX6HZ"},
         {"p", "gpf8m4h7"},
         {"bitcoincash", "qpzry9x8gf2tvdw0s3jn54khce6mua7lcw20ayyn"},
         {"bchtest", "testnetaddress4d6njnut"},
         {"bchreg", "555555555555555555555555555555555555555555555udxmlmrz"},
     };
 
-    for (const std::pair<std::string, std::string> &c : CASES) {
-        std::string prefix = c.first;
-        std::string payload = c.second;
+    for (const auto &[prefix, payload] : CASES) {
         std::string addr = prefix + ":" + payload;
-        auto ret = cashaddr::Decode(payload, prefix);
-        BOOST_CHECK_MESSAGE(CaseInsensitiveEqual(ret.first, prefix), addr);
-        std::string recode = cashaddr::Encode(ret.first, ret.second);
+        auto [decoded_prefix, decoded_payload] =
+            cashaddr::Decode(payload, prefix);
+        BOOST_CHECK_MESSAGE(CaseInsensitiveEqual(decoded_prefix, prefix), addr);
+        std::string recode = cashaddr::Encode(decoded_prefix, decoded_payload);
         BOOST_CHECK_MESSAGE(!recode.empty(), addr);
         BOOST_CHECK_MESSAGE(CaseInsensitiveEqual(addr, recode), addr);
     }
 }
 
 BOOST_AUTO_TEST_SUITE_END()