diff --git a/src/core_io.h b/src/core_io.h
index a10d748217a..8d32bef6f0e 100644
--- a/src/core_io.h
+++ b/src/core_io.h
@@ -39,5 +39,6 @@ std::string SighashToStr(unsigned char sighash_type);
 void ScriptPubKeyToUniv(const CScript& scriptPubKey, UniValue& out, bool fIncludeHex);
 void ScriptToUniv(const CScript& script, UniValue& out, bool include_address);
 void TxToUniv(const CTransaction& tx, const uint256& hashBlock, UniValue& entry, bool include_hex = true, int serialize_flags = 0);
+std::string EncodePSBT(const PartiallySignedTransaction& psbt);
 
 #endif // BITCOIN_CORE_IO_H
diff --git a/src/core_write.cpp b/src/core_write.cpp
index 49be842f3b7..f34abadf064 100644
--- a/src/core_write.cpp
+++ b/src/core_write.cpp
@@ -9,6 +9,7 @@
 #include <issuance.h>
 #include <key_io.h>
 #include <script/script.h>
+#include <script/sign.h>
 #include <script/standard.h>
 #include <serialize.h>
 #include <streams.h>
@@ -327,15 +328,21 @@ void TxToUniv(const CTransaction& tx, const uint256& hashBlock, UniValue& entry,
             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));
+            if (ptxoutwit) {
+                if (ptxoutwit->vchRangeproof.size() && 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);
+                }
+
+                if (ptxoutwit->vchSurjectionproof.size()) {
+                    out.pushKV("surjectionproof", HexStr(ptxoutwit->vchSurjectionproof));
                 }
-                out.pushKV("ct-exponent", exp);
-                out.pushKV("ct-bits", mantissa);
             }
             out.pushKV("valuecommitment", txout.nValue.GetHex());
         }
@@ -366,3 +373,10 @@ void TxToUniv(const CTransaction& tx, const uint256& hashBlock, UniValue& entry,
         entry.pushKV("hex", EncodeHexTx(tx, serialize_flags)); // The hex-encoded transaction. Used the name "hex" to be consistent with the verbose output of "getrawtransaction".
     }
 }
+
+std::string EncodePSBT(const PartiallySignedTransaction& psbt)
+{
+    CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
+    ssTx << psbt;
+    return EncodeBase64((unsigned char*)ssTx.data(), ssTx.size());
+}
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
index a69db61faa9..be28a129176 100644
--- a/src/rpc/rawtransaction.cpp
+++ b/src/rpc/rawtransaction.cpp
@@ -347,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, const UniValue& assets_in)
+CMutableTransaction ConstructTransaction(const UniValue& inputs_in, const UniValue& outputs_in, const UniValue& locktime, const UniValue& rbf, const UniValue& assets_in, std::vector<CPubKey>* output_pubkeys_out)
 {
     if (inputs_in.isNull() || outputs_in.isNull())
         throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, arguments 1 and 2 must be non-null");
@@ -443,6 +443,9 @@ CMutableTransaction ConstructTransaction(const UniValue& inputs_in, const UniVal
 
             CTxOut out(asset, 0, CScript() << OP_RETURN << data);
             rawTx.vout.push_back(out);
+            if (output_pubkeys_out) {
+                output_pubkeys_out->push_back(CPubKey());
+            }
         } else if (name_ == "vdata") {
             // ELEMENTS: support multi-push OP_RETURN
             UniValue vdata = outputs[name_].get_array();
@@ -454,6 +457,9 @@ CMutableTransaction ConstructTransaction(const UniValue& inputs_in, const UniVal
 
             CTxOut out(asset, 0, datascript);
             rawTx.vout.push_back(out);
+            if (output_pubkeys_out) {
+                output_pubkeys_out->push_back(CPubKey());
+            }
         } else if (name_ == "fee") {
             // ELEMENTS: explicit fee outputs
             CAmount nAmount = AmountFromValue(outputs[name_]);
@@ -463,6 +469,9 @@ CMutableTransaction ConstructTransaction(const UniValue& inputs_in, const UniVal
             CAmount nAmount = AmountFromValue(outputs[name_]);
             CTxOut out(asset, nAmount, datascript);
             rawTx.vout.push_back(out);
+            if (output_pubkeys_out) {
+                output_pubkeys_out->push_back(CPubKey());
+            }
         } else {
             CTxDestination destination = DecodeDestination(name_);
             if (!IsValidDestination(destination)) {
@@ -477,17 +486,27 @@ CMutableTransaction ConstructTransaction(const UniValue& inputs_in, const UniVal
             CAmount nAmount = AmountFromValue(outputs[name_]);
 
             CTxOut out(asset, nAmount, scriptPubKey);
+            CPubKey blind_pub;
             if (IsBlindDestination(destination)) {
-                CPubKey blind_pub = GetDestinationBlindingKey(destination);
-                out.nNonce.vchCommitment = std::vector<unsigned char>(blind_pub.begin(), blind_pub.end());
+                blind_pub = GetDestinationBlindingKey(destination);
+                if (!output_pubkeys_out) {
+                    // Only use the pubkey-in-nonce hack if the caller is not getting the pubkeys the nice way.
+                    out.nNonce.vchCommitment = std::vector<unsigned char>(blind_pub.begin(), blind_pub.end());
+                }
             }
             rawTx.vout.push_back(out);
+            if (output_pubkeys_out) {
+                output_pubkeys_out->push_back(blind_pub);
+            }
         }
     }
 
     // Add fee output in the end.
     if (!fee_out.nValue.IsNull() && fee_out.nValue.GetAmount() > 0) {
         rawTx.vout.push_back(fee_out);
+        if (output_pubkeys_out) {
+            output_pubkeys_out->push_back(CPubKey());
+        }
     }
 
     if (!rbf.isNull() && rawTx.vin.size() > 0 && rbfOptIn != SignalsOptInRBF(rawTx)) {
@@ -799,9 +818,6 @@ static UniValue combinerawtransaction(const JSONRPCRequest& request)
         view.SetBackend(viewDummy); // switch back to avoid locking mempool for too long
     }
 
-    // Use CTransaction for the constant parts of the
-    // transaction to avoid rehashing.
-    const CTransaction txConst(mergedTx);
     // Sign what we can:
     for (unsigned int i = 0; i < mergedTx.vin.size(); i++) {
         CTxIn& txin = mergedTx.vin[i];
@@ -1270,6 +1286,123 @@ static std::string WriteHDKeypath(std::vector<uint32_t>& keypath)
     return keypath_str;
 }
 
+UniValue blindpsbt(const JSONRPCRequest& request)
+{
+    if (request.fHelp || request.params.size() < 1 || request.params.size() > 2)
+        throw std::runtime_error(
+            "blindpsbt \"psbt\" ( ignoreblindfail )\n"
+            "\nUse the blinding data from the PSBT inputs to generate the blinding data for the PSBT outputs.\n"
+
+            "\nArguments:\n"
+            "1. \"psbt\"            (string, required) The PSBT base64 string\n"
+            "2. ignoreblindfail   (bool, optional, default=true) Return a transaction even when a blinding attempt fails due to number of blinded inputs/outputs.\n"
+
+            "\nResult:\n"
+            "  \"psbt\"          (string) The base64-encoded partially signed transaction\n"
+            "\nExamples:\n"
+            + HelpExampleCli("blindpsbt", "\"psbt\" ignoreblindfail")
+        );
+
+    RPCTypeCheck(request.params, {UniValue::VSTR, UniValue::VBOOL}, true);
+
+    // Unserialize the transactions
+    PartiallySignedTransaction psbtx;
+    std::string error;
+    if (!DecodePSBT(psbtx, request.params[0].get_str(), error)) {
+        throw JSONRPCError(RPC_DESERIALIZATION_ERROR, strprintf("TX decode failed %s", error));
+    }
+
+    bool fIgnoreBlindFail = true;
+    if (!request.params[1].isNull()) {
+        fIgnoreBlindFail = request.params[1].get_bool();
+    }
+
+    // TODO(gwillen): Refactor out significant duplicated code between here and rawblindrawtransaction.
+
+    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;
+
+    int n_blinded_ins = 0;
+
+    // TODO(gwillen): If blinding is not possible due to missing input data, we should bail here with a useful error message.
+    for (const auto& input : psbtx.inputs) {
+        input_blinds.push_back(input.value_blinding_factor);
+        input_asset_blinds.push_back(input.asset_blinding_factor);
+        input_assets.push_back(input.asset);
+        input_amounts.push_back(input.value ? *input.value : CAmount(-1));
+
+        if (!input_blinds.back().IsNull()) {
+            n_blinded_ins++;
+        }
+    }
+
+    for (auto& output : psbtx.outputs) {
+        output_pubkeys.push_back(output.blinding_pubkey);
+    }
+
+    // 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;
+        }
+    }
+
+    CMutableTransaction& tx = *psbtx.tx;
+
+    // TODO(gwillen): Replace all this with the 'bonus output' scheme to use an OP_RETURN to balance blinders, with a rangeproof exponent of -1 (public).
+    if (num_pubkeys == 0 && n_blinded_ins == 0) {
+        // Vacuous, just return the transaction
+        return EncodePSBT(psbtx);
+    } 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) {
+            // Remove the pubkey to signal that blinding is complete
+            psbtx.outputs[keyIndex].blinding_pubkey = CPubKey();
+            return EncodePSBT(psbtx);
+        } else {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "Unable to blind transaction: Add another output to blind in order to complete the blinding.");
+        }
+    }
+
+    CMutableTransaction tx_tmp = tx;  // We don't want to mutate the transaction in the PSBT yet, just extract blinding data
+
+    // TODO(gwillen): Make this do something better than fail silently if there are any issuances, reissuances, pegins, etc.
+    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_tmp);
+    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?");
+    }
+
+    for (size_t i = 0; i < psbtx.outputs.size(); ++i) {
+        PSBTOutput& o = psbtx.outputs[i];
+
+        o.value_commitment = tx_tmp.vout[i].nValue;
+        o.asset_commitment = tx_tmp.vout[i].nAsset;
+        o.nonce_commitment = tx_tmp.vout[i].nNonce;
+        o.value_blinding_factor = output_value_blinds[i];
+        o.asset_blinding_factor = output_asset_blinds[i];
+        o.range_proof = tx_tmp.witness.vtxoutwit[i].vchRangeproof;
+        o.surjection_proof = tx_tmp.witness.vtxoutwit[i].vchSurjectionproof;
+
+        o.blinding_pubkey = CPubKey();  // Once we're done blinding, remove the pubkeys to signal that it's complete
+    }
+
+    return EncodePSBT(psbtx);
+}
+
 UniValue decodepsbt(const JSONRPCRequest& request)
 {
     if (request.fHelp || request.params.size() != 1)
@@ -1306,34 +1439,38 @@ UniValue decodepsbt(const JSONRPCRequest& request)
             "      \"partial_signatures\" : {             (json object, optional)\n"
             "        \"pubkey\" : \"signature\",           (string) The public key and signature that corresponds to it.\n"
             "        ,...\n"
-            "      }\n"
+            "      },\n"
             "      \"sighash\" : \"type\",                  (string, optional) The sighash type to be used\n"
             "      \"redeem_script\" : {       (json object, optional)\n"
-            "          \"asm\" : \"asm\",            (string) The asm\n"
-            "          \"hex\" : \"hex\",            (string) The hex\n"
-            "          \"type\" : \"pubkeyhash\",    (string) The type, eg 'pubkeyhash'\n"
-            "        }\n"
+            "        \"asm\" : \"asm\",            (string) The asm\n"
+            "        \"hex\" : \"hex\",            (string) The hex\n"
+            "        \"type\" : \"pubkeyhash\",    (string) The type, eg 'pubkeyhash'\n"
+            "      },\n"
             "      \"witness_script\" : {       (json object, optional)\n"
-            "          \"asm\" : \"asm\",            (string) The asm\n"
-            "          \"hex\" : \"hex\",            (string) The hex\n"
-            "          \"type\" : \"pubkeyhash\",    (string) The type, eg 'pubkeyhash'\n"
-            "        }\n"
+            "        \"asm\" : \"asm\",            (string) The asm\n"
+            "        \"hex\" : \"hex\",            (string) The hex\n"
+            "        \"type\" : \"pubkeyhash\",    (string) The type, eg 'pubkeyhash'\n"
+            "      },\n"
             "      \"bip32_derivs\" : {          (json object, optional)\n"
             "        \"pubkey\" : {                     (json object, optional) The public key with the derivation path as the value.\n"
             "          \"master_fingerprint\" : \"fingerprint\"     (string) The fingerprint of the master key\n"
             "          \"path\" : \"path\",                         (string) The path\n"
             "        }\n"
             "        ,...\n"
-            "      }\n"
+            "      },\n"
             "      \"final_scriptsig\" : {       (json object, optional)\n"
-            "          \"asm\" : \"asm\",            (string) The asm\n"
-            "          \"hex\" : \"hex\",            (string) The hex\n"
-            "        }\n"
-            "       \"final_scriptwitness\": [\"hex\", ...] (array of string) hex-encoded witness data (if any)\n"
-            "      \"unknown\" : {                (json object) The unknown global fields\n"
-            "        \"key\" : \"value\"            (key-value pair) An unknown key-value pair\n"
-            "         ...\n"
+            "        \"asm\" : \"asm\",            (string) The asm\n"
+            "        \"hex\" : \"hex\",            (string) The hex\n"
             "      },\n"
+            "      \"final_scriptwitness\": [\"hex\", ...], (array of string) hex-encoded witness data (if any)\n"
+            "      \"value\": x.xxx,                      (numeric) The (unblinded) value of the input in " + CURRENCY_UNIT + "\n"
+            "      \"value_blinding_factor\": \"hex\" ,   (string) The value blinding factor from the output being spent\n"
+            "      \"asset\": \"hex\" ,                   (string) The (unblinded) asset id of the input\n"
+            "      \"asset_blinding_factor\": \"hex\" ,   (string) The asset blinding factor from the output being spent\n"
+            "      \"unknown\" : {                (json object) The unknown input fields\n"
+            "        \"key\" : \"value\"            (key-value pair) An unknown key-value pair\n"
+            "        ...\n"
+            "      }\n"
             "    }\n"
             "    ,...\n"
             "  ]\n"
@@ -1358,7 +1495,14 @@ UniValue decodepsbt(const JSONRPCRequest& request)
             "        }\n"
             "        ,...\n"
             "      ],\n"
-            "      \"unknown\" : {                (json object) The unknown global fields\n"
+            "      \"value_commitment\": \"hex\" ,        (string) The blinded value of the output\n"
+            "      \"value_blinding_factor\": \"hex\" ,   (string) The value blinding factor for the output\n"
+            "      \"asset_commitment\": \"hex\" ,        (string) The blinded asset id of the output\n"
+            "      \"asset_blinding_factor\": \"hex\" ,   (string) The asset blinding factor for the output\n"
+            "      \"nonce_commitment\": \"hex\" ,        (string) The nonce for the output\n"
+            "      \"surjection_proof\": \"hex\" ,        (string) The surjection proof for the output\n"
+            "      \"blinding_pubkey\": \"hex\" ,         (string) The blinding pubkey for the output\n"
+            "      \"unknown\" : {                (json object) The unknown output fields\n"
             "        \"key\" : \"value\"            (key-value pair) An unknown key-value pair\n"
             "         ...\n"
             "      },\n"
@@ -1478,6 +1622,26 @@ UniValue decodepsbt(const JSONRPCRequest& request)
             in.pushKV("final_scriptwitness", txinwitness);
         }
 
+        // Value
+        if (input.value) {
+            in.pushKV("value", ValueFromAmount(*input.value));
+        }
+
+        // Value blinder
+        if (!input.value_blinding_factor.IsNull()) {
+            in.pushKV("value_blinding_factor", input.value_blinding_factor.GetHex());
+        }
+
+        // Asset
+        if (!input.asset.IsNull()) {
+            in.pushKV("asset", input.asset.id.GetHex());
+        }
+
+        // Asset blinder
+        if (!input.asset_blinding_factor.IsNull()) {
+            in.pushKV("asset_blinding_factor", input.asset_blinding_factor.GetHex());
+        }
+
         // Unknown data
         if (input.unknown.size() > 0) {
             UniValue unknowns(UniValue::VOBJ);
@@ -1521,6 +1685,43 @@ UniValue decodepsbt(const JSONRPCRequest& request)
             out.pushKV("bip32_derivs", keypaths);
         }
 
+        // Value commitment
+        if (!output.value_commitment.IsNull()) {
+            out.pushKV("value_commitment", output.value_commitment.GetHex());
+        }
+
+        // Value blinder
+        if (!output.value_blinding_factor.IsNull()) {
+            out.pushKV("value_blinding_factor", output.value_blinding_factor.GetHex());
+        }
+
+        // Asset commitment
+        if (!output.asset_commitment.IsNull()) {
+            out.pushKV("asset_commitment", output.asset_commitment.GetHex());
+        }
+
+        // Asset blinder
+        if (!output.asset_blinding_factor.IsNull()) {
+            out.pushKV("asset_blinding_factor", output.asset_blinding_factor.GetHex());
+        }
+
+        // Nonce commitment
+        if (!output.nonce_commitment.IsNull()) {
+            out.pushKV("nonce_commitment", output.nonce_commitment.GetHex());
+        }
+
+        // Range proof omitted due to size
+
+        // Surjection proof
+        if (!output.surjection_proof.empty()) {
+            out.pushKV("surjection_proof", HexStr(output.surjection_proof));
+        }
+
+        // Blinding pubkey
+        if (output.blinding_pubkey.IsValid()) {
+            out.pushKV("blinding_pubkey", HexStr(output.blinding_pubkey));
+        }
+
         // Unknown data
         if (output.unknown.size() > 0) {
             UniValue unknowns(UniValue::VOBJ);
@@ -1584,10 +1785,7 @@ UniValue combinepsbt(const JSONRPCRequest& request)
         throw JSONRPCError(RPC_INVALID_PARAMETER, "Merged PSBT is inconsistent");
     }
 
-    UniValue result(UniValue::VOBJ);
-    CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
-    ssTx << merged_psbt;
-    return EncodeBase64((unsigned char*)ssTx.data(), ssTx.size());
+    return EncodePSBT(merged_psbt);
 }
 
 UniValue finalizepsbt(const JSONRPCRequest& request)
@@ -1628,14 +1826,13 @@ UniValue finalizepsbt(const JSONRPCRequest& request)
     // Get all of the previous transactions
     bool complete = true;
     for (unsigned int i = 0; i < psbtx.tx->vin.size(); ++i) {
-        PSBTInput& input = psbtx.inputs.at(i);
-
-        complete &= SignPSBTInput(DUMMY_SIGNING_PROVIDER, *psbtx.tx, input, i, 1);
+        complete &= SignPSBTInput(DUMMY_SIGNING_PROVIDER, psbtx, i, 1);
     }
 
     UniValue result(UniValue::VOBJ);
     CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
     bool extract = request.params[1].isNull() || (!request.params[1].isNull() && request.params[1].get_bool());
+
     if (complete && extract) {
         CMutableTransaction mtx(*psbtx.tx);
         mtx.witness.vtxinwit.resize(mtx.vin.size());
@@ -1643,6 +1840,29 @@ UniValue finalizepsbt(const JSONRPCRequest& request)
             mtx.vin[i].scriptSig = psbtx.inputs[i].final_script_sig;
             mtx.witness.vtxinwit[i].scriptWitness = psbtx.inputs[i].final_script_witness;
         }
+
+        mtx.witness.vtxoutwit.resize(mtx.vout.size());
+        for (unsigned int i = 0; i < mtx.vout.size(); ++i) {
+            PSBTOutput& output = psbtx.outputs.at(i);
+            CTxOut& out = mtx.vout[i];
+            CTxOutWitness& outwit = mtx.witness.vtxoutwit[i];
+
+            if (!output.value_commitment.IsNull()) {
+                out.nValue = output.value_commitment;
+            }
+            if (!output.asset_commitment.IsNull()) {
+                out.nAsset = output.asset_commitment;
+            }
+            if (!output.nonce_commitment.IsNull()) {
+                out.nNonce = output.nonce_commitment;
+            }
+            if (!output.range_proof.empty()) {
+                outwit.vchRangeproof = output.range_proof;
+            }
+            if (!output.surjection_proof.empty()) {
+                outwit.vchSurjectionproof = output.surjection_proof;
+            }
+        }
         ssTx << mtx;
         result.pushKV("hex", HexStr(ssTx.begin(), ssTx.end()));
     } else {
@@ -1650,7 +1870,6 @@ UniValue finalizepsbt(const JSONRPCRequest& request)
         result.pushKV("psbt", EncodeBase64((unsigned char*)ssTx.data(), ssTx.size()));
     }
     result.pushKV("complete", complete);
-
     return result;
 }
 
@@ -1706,7 +1925,8 @@ UniValue createpsbt(const JSONRPCRequest& request)
         }, true
     );
 
-    CMutableTransaction rawTx = ConstructTransaction(request.params[0], request.params[1], request.params[2], request.params[3], request.params[4]);
+    std::vector<CPubKey> output_pubkeys;
+    CMutableTransaction rawTx = ConstructTransaction(request.params[0], request.params[1], request.params[2], request.params[3], request.params[4], &output_pubkeys);
 
     // Make a blank psbt
     PartiallySignedTransaction psbtx;
@@ -1716,6 +1936,7 @@ UniValue createpsbt(const JSONRPCRequest& request)
     }
     for (unsigned int i = 0; i < rawTx.vout.size(); ++i) {
         psbtx.outputs.push_back(PSBTOutput());
+        psbtx.outputs[i].blinding_pubkey = output_pubkeys[i];
     }
 
     // Serialize the PSBT
@@ -2280,6 +2501,7 @@ static const CRPCCommand commands[] =
     { "rawtransactions",    "testmempoolaccept",            &testmempoolaccept,         {"rawtxs","allowhighfees"} },
     { "rawtransactions",    "decodepsbt",                   &decodepsbt,                {"psbt"} },
     { "rawtransactions",    "combinepsbt",                  &combinepsbt,               {"txs"} },
+    { "rawtransactions",    "blindpsbt",                    &blindpsbt,                 {"psbt","ignoreblindfail"} },
     { "rawtransactions",    "finalizepsbt",                 &finalizepsbt,              {"psbt", "extract"} },
     { "rawtransactions",    "createpsbt",                   &createpsbt,                {"inputs","outputs","locktime","replaceable"} },
     { "rawtransactions",    "converttopsbt",                &converttopsbt,             {"hexstring","permitsigdata","iswitness"} },
diff --git a/src/rpc/rawtransaction.h b/src/rpc/rawtransaction.h
index 7a433bb9351..9e7d7852c15 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, const UniValue& assets_in);
+CMutableTransaction ConstructTransaction(const UniValue& inputs_in, const UniValue& outputs_in, const UniValue& locktime, const UniValue& rbf, const UniValue& assets_in, std::vector<CPubKey>* output_pubkeys_out = nullptr);
 
 #endif // BITCOIN_RPC_RAWTRANSACTION_H
diff --git a/src/script/sign.cpp b/src/script/sign.cpp
index 4c872357536..d4609545114 100644
--- a/src/script/sign.cpp
+++ b/src/script/sign.cpp
@@ -5,6 +5,7 @@
 
 #include <script/sign.h>
 
+#include <confidential_validation.h>
 #include <key.h>
 #include <policy/policy.h>
 #include <primitives/transaction.h>
@@ -241,10 +242,15 @@ bool ProduceSignature(const SigningProvider& provider, const BaseSignatureCreato
     return sigdata.complete;
 }
 
-bool SignPSBTInput(const SigningProvider& provider, const CMutableTransaction& tx, PSBTInput& input, int index, int sighash)
+bool SignPSBTInput(const SigningProvider& provider, PartiallySignedTransaction& psbt, int index, int sighash)
 {
+    fprintf(stderr, "signpsbtinput called!\n");
+    const CMutableTransaction& tx = *psbt.tx;
+    PSBTInput& input = psbt.inputs[index];
+
     // if this input has a final scriptsig or scriptwitness, don't do anything with it
     if (!input.final_script_sig.empty() || !input.final_script_witness.IsNull()) {
+        fprintf(stderr, "already signed, though\n");
         return true;
     }
 
@@ -252,16 +258,15 @@ bool SignPSBTInput(const SigningProvider& provider, const CMutableTransaction& t
     SignatureData sigdata;
     input.FillSignatureData(sigdata);
 
-    // Get UTXO
+    // Get UTXO for this input
     bool require_witness_sig = false;
     CTxOut utxo;
+
     if (input.non_witness_utxo) {
         // If we're taking our information from a non-witness UTXO, verify that it matches the prevout.
         if (input.non_witness_utxo->GetHash() != tx.vin[index].prevout.hash) return false;
-        // If both witness and non-witness UTXO are provided, verify that they match. This check shouldn't
-        // matter, as the PSBT deserializer enforces only one of both is provided, and the only way both
-        // can be present is when they're added simultaneously by FillPSBT (in which case they always match).
-        // Still, check in order to not rely on callers to enforce this.
+        // If both witness and non-witness UTXO are provided, verify that they match. This should not
+        //   actually be possible.
         if (!input.witness_utxo.IsNull() && input.non_witness_utxo->vout[tx.vin[index].prevout.n] != input.witness_utxo) return false;
         utxo = input.non_witness_utxo->vout[tx.vin[index].prevout.n];
     } else if (!input.witness_utxo.IsNull()) {
@@ -275,20 +280,24 @@ bool SignPSBTInput(const SigningProvider& provider, const CMutableTransaction& t
         return false;
     }
 
+    fprintf(stderr, "gathering utxos\n");
+
     MutableTransactionSignatureCreator creator(&tx, index, utxo.nValue, sighash);
     sigdata.witness = false;
+    fprintf(stderr, "about to produce signature\n");
     bool sig_complete = ProduceSignature(provider, creator, utxo.scriptPubKey, sigdata);
+    fprintf(stderr, "sig complete: %d\n", sig_complete);
     // Verify that a witness signature was produced in case one was required.
-    if (require_witness_sig && !sigdata.witness) return false;
+    if (require_witness_sig && !sigdata.witness) {
+    fprintf(stderr, "oh no, witness problem\n");
+        return false;
+    }
     input.FromSignatureData(sigdata);
 
-    // If both UTXO types are present, drop the unnecessary one.
-    if (input.non_witness_utxo && !input.witness_utxo.IsNull()) {
-        if (sigdata.witness) {
-            input.non_witness_utxo = nullptr;
-        } else {
-            input.witness_utxo.SetNull();
-        }
+    // If we have a witness signature, use the smaller witness UTXO.
+    if (sigdata.witness) {
+        input.witness_utxo = utxo;
+        input.non_witness_utxo = nullptr;
     }
 
     return sig_complete;
@@ -614,6 +623,11 @@ void PSBTInput::Merge(const PSBTInput& input)
     if (witness_script.empty() && !input.witness_script.empty()) witness_script = input.witness_script;
     if (final_script_sig.empty() && !input.final_script_sig.empty()) final_script_sig = input.final_script_sig;
     if (final_script_witness.IsNull() && !input.final_script_witness.IsNull()) final_script_witness = input.final_script_witness;
+
+    if (!value && input.value) value = input.value;
+    if (value_blinding_factor.IsNull() && !input.value_blinding_factor.IsNull()) value_blinding_factor = input.value_blinding_factor;
+    if (asset.IsNull() && !input.asset.IsNull()) asset = input.asset;
+    if (asset_blinding_factor.IsNull() && !input.asset_blinding_factor.IsNull()) asset_blinding_factor = input.asset_blinding_factor;
 }
 
 bool PSBTInput::IsSane() const
@@ -666,6 +680,15 @@ void PSBTOutput::Merge(const PSBTOutput& output)
 
     if (redeem_script.empty() && !output.redeem_script.empty()) redeem_script = output.redeem_script;
     if (witness_script.empty() && !output.witness_script.empty()) witness_script = output.witness_script;
+
+    if (!blinding_pubkey.IsValid() && output.blinding_pubkey.IsValid()) blinding_pubkey = output.blinding_pubkey;
+    if (value_commitment.IsNull() && !output.value_commitment.IsNull()) value_commitment = output.value_commitment;
+    if (value_blinding_factor.IsNull() && !output.value_blinding_factor.IsNull()) value_blinding_factor = output.value_blinding_factor;
+    if (asset_commitment.IsNull() && !output.asset_commitment.IsNull()) asset_commitment = output.asset_commitment;
+    if (asset_blinding_factor.IsNull() && !output.asset_blinding_factor.IsNull()) asset_blinding_factor = output.asset_blinding_factor;
+    if (nonce_commitment.IsNull() && !output.nonce_commitment.IsNull()) nonce_commitment = output.nonce_commitment;
+    if (range_proof.empty() && !output.range_proof.empty()) range_proof = output.range_proof;
+    if (surjection_proof.empty() && !output.surjection_proof.empty()) surjection_proof = output.surjection_proof;
 }
 
 bool HidingSigningProvider::GetCScript(const CScriptID& scriptid, CScript& script) const
diff --git a/src/script/sign.h b/src/script/sign.h
index e829f437fb4..e9145c73ca7 100644
--- a/src/script/sign.h
+++ b/src/script/sign.h
@@ -47,7 +47,9 @@ class HidingSigningProvider : public SigningProvider
     const SigningProvider* m_provider;
 
 public:
-    HidingSigningProvider(const SigningProvider* provider, bool hide_secret, bool hide_origin) : m_hide_secret(hide_secret), m_hide_origin(hide_origin), m_provider(provider) {}
+    HidingSigningProvider(const SigningProvider* provider, bool hide_secret, bool hide_origin) : m_hide_secret(hide_secret), m_hide_origin(hide_origin), m_provider(provider) {
+        fprintf(stderr, "HidingSigningProvider constructed with m_hide_secret = %d\n", m_hide_secret);
+    }
     bool GetCScript(const CScriptID& scriptid, CScript& script) const override;
     bool GetPubKey(const CKeyID& keyid, CPubKey& pubkey) const override;
     bool GetKey(const CKeyID& keyid, CKey& key) const override;
@@ -132,11 +134,24 @@ static constexpr uint8_t PSBT_IN_WITNESSSCRIPT = 0x05;
 static constexpr uint8_t PSBT_IN_BIP32_DERIVATION = 0x06;
 static constexpr uint8_t PSBT_IN_SCRIPTSIG = 0x07;
 static constexpr uint8_t PSBT_IN_SCRIPTWITNESS = 0x08;
+static constexpr uint8_t PSBT_IN_VALUE = 0x09;
+static constexpr uint8_t PSBT_IN_VALUE_BLINDER = 0x0a;
+static constexpr uint8_t PSBT_IN_ASSET = 0x0b;
+static constexpr uint8_t PSBT_IN_ASSET_BLINDER = 0x0c;
 
 // Output types
 static constexpr uint8_t PSBT_OUT_REDEEMSCRIPT = 0x00;
 static constexpr uint8_t PSBT_OUT_WITNESSSCRIPT = 0x01;
 static constexpr uint8_t PSBT_OUT_BIP32_DERIVATION = 0x02;
+static constexpr uint8_t PSBT_OUT_VALUE_COMMITMENT = 0x03;
+static constexpr uint8_t PSBT_OUT_VALUE_BLINDER = 0x04;
+static constexpr uint8_t PSBT_OUT_ASSET_COMMITMENT = 0x05;
+static constexpr uint8_t PSBT_OUT_ASSET_BLINDER = 0x06;
+static constexpr uint8_t PSBT_OUT_RANGE_PROOF = 0x07;
+static constexpr uint8_t PSBT_OUT_SURJECTION_PROOF = 0x08;
+static constexpr uint8_t PSBT_OUT_BLINDING_PUBKEY = 0x09;
+static constexpr uint8_t PSBT_OUT_NONCE_COMMITMENT = 0x0a;
+
 
 // The separator is 0x00. Reading this in means that the unserializer can interpret it
 // as a 0 length key which indicates that this is the separator. The separator has no value.
@@ -227,6 +242,11 @@ struct PSBTInput
     std::map<std::vector<unsigned char>, std::vector<unsigned char>> unknown;
     int sighash_type = 0;
 
+    boost::optional<CAmount> value;
+    uint256 value_blinding_factor;
+    CAsset asset;
+    uint256 asset_blinding_factor;
+
     bool IsNull() const;
     void FillSignatureData(SignatureData& sigdata) const;
     void FromSignatureData(const SignatureData& sigdata);
@@ -276,6 +296,34 @@ struct PSBTInput
             SerializeHDKeypaths(s, hd_keypaths, PSBT_IN_BIP32_DERIVATION);
         }
 
+        // Write the Confidental Assets blinding data
+        fprintf(stderr, "XXX: maybe encoding CA data\n");
+        if (value) {
+            fprintf(stderr, "XXX: serializing value\n");
+            SerializeToVector(s, PSBT_IN_VALUE);
+            SerializeToVector(s, *value);
+        } else {
+            fprintf(stderr, "XXX: no value\n");
+        }
+
+        if (!value_blinding_factor.IsNull()) {
+            fprintf(stderr, "XXX: serializing value bf\n");
+            SerializeToVector(s, PSBT_IN_VALUE_BLINDER);
+            SerializeToVector(s, value_blinding_factor);
+        }
+
+        if (!asset.IsNull()) {
+            fprintf(stderr, "XXX: serializing asset\n");
+            SerializeToVector(s, PSBT_IN_ASSET);
+            SerializeToVector(s, asset);
+        }
+
+        if (!asset_blinding_factor.IsNull()) {
+            fprintf(stderr, "XXX: serializing asset bf\n");
+            SerializeToVector(s, PSBT_IN_ASSET_BLINDER);
+            SerializeToVector(s, asset_blinding_factor);
+        }
+
         // Write script sig
         if (!final_script_sig.empty()) {
             SerializeToVector(s, PSBT_IN_SCRIPTSIG);
@@ -410,8 +458,51 @@ struct PSBTInput
                     UnserializeFromVector(s, final_script_witness.stack);
                     break;
                 }
+                case PSBT_IN_VALUE:
+                {
+                    if (value != boost::none) {
+                        throw std::ios_base::failure("Duplicate Key, input value already provided");
+                    } else if (key.size() != 1) {
+                        throw std::ios_base::failure("Final value key is more than one byte type");
+                    }
+                    CAmount amt;
+                    UnserializeFromVector(s, amt);
+                    value = amt;
+                    break;
+                }
+                case PSBT_IN_VALUE_BLINDER:
+                {
+                    if (!value_blinding_factor.IsNull()) {
+                        throw std::ios_base::failure("Duplicate Key, input value_blinding_factor already provided");
+                    } else if (key.size() != 1) {
+                        throw std::ios_base::failure("Final value_blinding_factor key is more than one byte type");
+                    }
+                    UnserializeFromVector(s, value_blinding_factor);
+                    break;
+                }
+                case PSBT_IN_ASSET:
+                {
+                    if (!asset.IsNull()) {
+                        throw std::ios_base::failure("Duplicate Key, input asset already provided");
+                    } else if (key.size() != 1) {
+                        throw std::ios_base::failure("Final asset key is more than one byte type");
+                    }
+                    UnserializeFromVector(s, asset);
+                    break;
+                }
+                case PSBT_IN_ASSET_BLINDER:
+                {
+                    if (!asset_blinding_factor.IsNull()) {
+                        throw std::ios_base::failure("Duplicate Key, input asset_blinding_factor already provided");
+                    } else if (key.size() != 1) {
+                        throw std::ios_base::failure("Final asset_blinding_factor key is more than one byte type");
+                    }
+                    UnserializeFromVector(s, asset_blinding_factor);
+                    break;
+                }
                 // Unknown stuff
                 default:
+                    fprintf(stderr, "XXX unserializing unknown type\n");
                     if (unknown.count(key) > 0) {
                         throw std::ios_base::failure("Duplicate Key, key for unknown value already provided");
                     }
@@ -436,6 +527,16 @@ struct PSBTOutput
     CScript redeem_script;
     CScript witness_script;
     std::map<CPubKey, KeyOriginInfo> hd_keypaths;
+
+    CPubKey blinding_pubkey;
+    CConfidentialValue value_commitment;
+    uint256 value_blinding_factor;
+    CConfidentialAsset asset_commitment;
+    uint256 asset_blinding_factor;
+    CConfidentialNonce nonce_commitment;
+    std::vector<unsigned char> range_proof;
+    std::vector<unsigned char> surjection_proof;
+
     std::map<std::vector<unsigned char>, std::vector<unsigned char>> unknown;
 
     bool IsNull() const;
@@ -462,6 +563,49 @@ struct PSBTOutput
         // Write any hd keypaths
         SerializeHDKeypaths(s, hd_keypaths, PSBT_OUT_BIP32_DERIVATION);
 
+        // Write the Confidental Assets blinding data
+        if (!value_commitment.IsNull()) {
+            SerializeToVector(s, PSBT_OUT_VALUE_COMMITMENT);
+            SerializeToVector(s, value_commitment);
+        }
+
+        if (!value_blinding_factor.IsNull()) {
+            SerializeToVector(s, PSBT_OUT_VALUE_BLINDER);
+            SerializeToVector(s, value_blinding_factor);
+        }
+
+        // XXX: If g_con_elementsmode is false, something strange and unexpected happens here.
+        if (!asset_commitment.IsNull()) {
+            SerializeToVector(s, PSBT_OUT_ASSET_COMMITMENT);
+            SerializeToVector(s, asset_commitment);
+        }
+
+        if (!asset_blinding_factor.IsNull()) {
+            SerializeToVector(s, PSBT_OUT_ASSET_BLINDER);
+            SerializeToVector(s, asset_blinding_factor);
+        }
+
+        if (!nonce_commitment.IsNull()) {
+            SerializeToVector(s, PSBT_OUT_NONCE_COMMITMENT);
+            SerializeToVector(s, nonce_commitment);
+        }
+
+        if (!range_proof.empty()) {
+            SerializeToVector(s, PSBT_OUT_RANGE_PROOF);
+            s << range_proof;
+        }
+
+        if (!surjection_proof.empty()) {
+            SerializeToVector(s, PSBT_OUT_SURJECTION_PROOF);
+            s << surjection_proof;
+        }
+
+        if (blinding_pubkey.IsValid()) {
+            fprintf(stderr, "serialized a pubkey\n"); // XXX
+            SerializeToVector(s, PSBT_OUT_BLINDING_PUBKEY);
+            s << blinding_pubkey;
+        }
+
         // Write unknown things
         for (auto& entry : unknown) {
             s << entry.first;
@@ -487,6 +631,7 @@ struct PSBTOutput
             // First byte of key is the type
             unsigned char type = key[0];
 
+            fprintf(stderr, "unserializing a PSBTOutput subobject of type %x\n", type);
             // Do stuff based on type
             switch(type) {
                 case PSBT_OUT_REDEEMSCRIPT:
@@ -514,6 +659,86 @@ struct PSBTOutput
                     DeserializeHDKeypaths(s, key, hd_keypaths);
                     break;
                 }
+                case PSBT_OUT_VALUE_COMMITMENT:
+                {
+                    if (!value_commitment.IsNull()) {
+                        throw std::ios_base::failure("Duplicate Key, output value_commitment already provided");
+                    } else if (key.size() != 1) {
+                        throw std::ios_base::failure("Output value_commitment key is more than one byte type");
+                    }
+                    UnserializeFromVector(s, value_commitment);
+                    break;
+                }
+                case PSBT_OUT_VALUE_BLINDER:
+                {
+                    if (!value_blinding_factor.IsNull()) {
+                        throw std::ios_base::failure("Duplicate Key, output value_blinding_factor already provided");
+                    } else if (key.size() != 1) {
+                        throw std::ios_base::failure("Output value_blinding_factor key is more than one byte type");
+                    }
+                    UnserializeFromVector(s, value_blinding_factor);
+                    break;
+                }
+                case PSBT_OUT_ASSET_COMMITMENT:
+                {
+                    if (!asset_commitment.IsNull()) {
+                        throw std::ios_base::failure("Duplicate Key, output asset_commitment already provided");
+                    } else if (key.size() != 1) {
+                        throw std::ios_base::failure("Output asset_commitment key is more than one byte type");
+                    }
+                    UnserializeFromVector(s, asset_commitment);
+                    break;
+                }
+                case PSBT_OUT_ASSET_BLINDER:
+                {
+                    if (!asset_blinding_factor.IsNull()) {
+                        throw std::ios_base::failure("Duplicate Key, output asset_blinding_factor already provided");
+                    } else if (key.size() != 1) {
+                        throw std::ios_base::failure("Output asset_blinding_factor key is more than one byte type");
+                    }
+                    UnserializeFromVector(s, asset_blinding_factor);
+                    break;
+                }
+                case PSBT_OUT_NONCE_COMMITMENT:
+                {
+                    if (!nonce_commitment.IsNull()) {
+                        throw std::ios_base::failure("Duplicate Key, output nonce_commitment already provided");
+                    } else if (key.size() != 1) {
+                        throw std::ios_base::failure("Output nonce_commitment key is more than one byte type");
+                    }
+                    UnserializeFromVector(s, nonce_commitment);
+                    break;
+                }
+                case PSBT_OUT_RANGE_PROOF:
+                {
+                    if (!range_proof.empty()) {
+                        throw std::ios_base::failure("Duplicate Key, output range_proof already provided");
+                    } else if (key.size() != 1) {
+                        throw std::ios_base::failure("Output range_proof key is more than one byte type");
+                    }
+                    s >> range_proof;
+                    break;
+                }
+                case PSBT_OUT_SURJECTION_PROOF:
+                {
+                    if (!surjection_proof.empty()) {
+                        throw std::ios_base::failure("Duplicate Key, output surjection_proof already provided");
+                    } else if (key.size() != 1) {
+                        throw std::ios_base::failure("Output surjection_proof key is more than one byte type");
+                    }
+                    s >> surjection_proof;
+                    break;
+                }
+                case PSBT_OUT_BLINDING_PUBKEY:
+                {
+                    if (blinding_pubkey.IsValid()) {
+                        throw std::ios_base::failure("Duplicate Key, output blinding_pubkey already provided");
+                    } else if (key.size() != 1) {
+                        throw std::ios_base::failure("Output blinding_pubkey key is more than one byte type");
+                    }
+                    s >> blinding_pubkey;
+                    break;
+                }
                 // Unknown stuff
                 default: {
                     if (unknown.count(key) > 0) {
@@ -594,6 +819,7 @@ struct PartiallySignedTransaction
 
     template <typename Stream>
     inline void Unserialize(Stream& s) {
+        fprintf(stderr, "unserializing a psbt\n");
         // Read the magic bytes
         uint8_t magic[5];
         s >> magic;
@@ -614,6 +840,7 @@ struct PartiallySignedTransaction
             // First byte of key is the type
             unsigned char type = key[0];
 
+            fprintf(stderr, "unserializing a PSBT subobject of type %x\n", type);
             // Do stuff based on type
             switch(type) {
                 case PSBT_GLOBAL_UNSIGNED_TX:
@@ -626,7 +853,9 @@ struct PartiallySignedTransaction
                     CMutableTransaction mtx;
                     // Set the stream to serialize with non-witness since this should always be non-witness
                     OverrideStream<Stream> os(&s, s.GetType(), s.GetVersion() | SERIALIZE_TRANSACTION_NO_WITNESS);
+                    fprintf(stderr, "XXX trying usv cmt...\n");
                     UnserializeFromVector(os, mtx);
+                    fprintf(stderr, "XXX succeeded usv cmt!\n");
                     tx = std::move(mtx);
                     // Make sure that all scriptSigs and witnesses are empty
                     for (const CTxIn& txin : tx->vin) {
@@ -707,7 +936,7 @@ bool SignSignature(const SigningProvider &provider, const CScript& fromPubKey, C
 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. */
-bool SignPSBTInput(const SigningProvider& provider, const CMutableTransaction& tx, PSBTInput& input, int index, int sighash = SIGHASH_ALL);
+bool SignPSBTInput(const SigningProvider& provider, PartiallySignedTransaction& psbt, int index, int sighash = SIGHASH_ALL);
 
 /** Extract signature data from a transaction input, and insert it. */
 SignatureData DataFromTransaction(const CMutableTransaction& tx, unsigned int nIn, const CTxOut& txout);
diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
index 23b11c69b8e..f2a385ff06b 100644
--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@@ -89,7 +89,9 @@ std::string HelpRequiringPassphrase(CWallet * const pwallet)
 
 bool EnsureWalletIsAvailable(CWallet * const pwallet, bool avoidException)
 {
+    fprintf(stderr, "ensuring wallet is available (pwallet is %p)\n", pwallet);
     if (pwallet) return true;
+    fprintf(stderr, "and yet we are still here \n");
     if (avoidException) return false;
     if (!HasWallets()) {
         throw JSONRPCError(
@@ -4235,50 +4237,278 @@ void AddKeypathToMap(const CWallet* pwallet, const CKeyID& keyID, std::map<CPubK
     hd_keypaths.emplace(vchPubKey, std::move(info));
 }
 
-bool FillPSBT(const CWallet* pwallet, PartiallySignedTransaction& psbtx, const CTransaction* txConst, int sighash_type, bool sign, bool bip32derivs)
+void FillPSBTInputsData(const CWallet* pwallet, PartiallySignedTransaction& psbtx, bool bip32derivs)
 {
     LOCK(pwallet->cs_wallet);
+    CMutableTransaction& tx = *psbtx.tx;
+
     // Get all of the previous transactions
-    bool complete = true;
-    for (unsigned int i = 0; i < txConst->vin.size(); ++i) {
-        const CTxIn& txin = txConst->vin[i];
+    for (unsigned int i = 0; i < tx.vin.size(); ++i) {
+        const CTxIn& txin = tx.vin[i];
         PSBTInput& input = psbtx.inputs.at(i);
 
-        // If we don't know about this input, skip it and let someone else deal with it
+        // Skip if it's already signed, don't mess with it.
+        if (!input.final_script_sig.empty() || !input.final_script_witness.IsNull()) {
+            continue;
+        }
+
         const uint256& txhash = txin.prevout.hash;
         const auto it = pwallet->mapWallet.find(txhash);
         if (it != pwallet->mapWallet.end()) {
             const CWalletTx& wtx = it->second;
-            CTxOut utxo = wtx.tx->vout[txin.prevout.n];
-            // Update both UTXOs from the wallet.
-            input.non_witness_utxo = wtx.tx;
-            input.witness_utxo = utxo;
+            // If we have no utxo, use the one from the wallet.
+            if (!input.non_witness_utxo && input.witness_utxo.IsNull()) {
+                // We only need the non_witness_utxo, which is a superset of the witness_utxo.
+                //   The signing code will switch to the smaller witness_utxo if this is ok.
+                input.non_witness_utxo = wtx.tx;
+            }
+
+            fprintf(stderr, "XXX trying to fill blinding data\n");
+            CAmount val_tmp;
+            wtx.GetNonIssuanceBlindingData(txin.prevout.n, nullptr, &val_tmp, &input.value_blinding_factor, &input.asset, &input.asset_blinding_factor);
+            if (val_tmp != -1) {
+                input.value = val_tmp;
+            }
+        }
+
+        // Get key origin info for input, if bip32derivs is true. Does not actually sign anything.
+        SignPSBTInput(HidingSigningProvider(pwallet, true /* don't sign */, !bip32derivs), psbtx, i, 1 /* SIGHASH_ALL, ignored */);
+    }
+}
+
+bool SignPSBT(const CWallet* pwallet, PartiallySignedTransaction& psbtx, int sighash_type, bool sign, bool imbalance_ok)
+{
+    fprintf(stderr, "signpsbt\n");
+
+    // Check that the transaction is not still in need of blinding
+    for (const PSBTOutput& o : psbtx.outputs) {
+        if (o.blinding_pubkey.IsValid()) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "PSBT must be blinded before signing; call blindpsbt.");
+        }
+    }
+
+    // Save the original transaction since we need to munge it temporarily, which would violate the PSBT rules
+    CTransaction oldtx = *psbtx.tx;
+
+    LOCK(pwallet->cs_wallet);
+    CMutableTransaction& tx = *psbtx.tx;
+    tx.witness.vtxoutwit.resize(tx.vout.size());
+
+    // Stuff in auxilliary CA blinding data, if we have it
+    for (unsigned int i = 0; i < tx.vout.size(); ++i) {
+        PSBTOutput& output = psbtx.outputs.at(i);
+        CTxOut& out = tx.vout[i];
+
+        if (!output.value_commitment.IsNull()) {
+            fprintf(stderr, "did a value_commitment\n"); // XXX
+            out.nValue = output.value_commitment;
+        }
+        if (!output.asset_commitment.IsNull()) {
+            fprintf(stderr, "did a asset_commitment\n"); // XXX
+            out.nAsset = output.asset_commitment;
+        }
+        if (!output.nonce_commitment.IsNull()) {
+            fprintf(stderr, "did a nonce commitment\n"); // XXX
+            out.nNonce = output.nonce_commitment;
+        }
+
+        // The signature can't depend on witness contents, so these are technically not necessary to sign.
+        // HOWEVER, as long as we're checking that values balance before signing, they are required.
+        CTxOutWitness& outwit = tx.witness.vtxoutwit[i];
+        if (!output.range_proof.empty()) {
+            fprintf(stderr, "did a rangeproof\n"); // XXX
+            outwit.vchRangeproof = output.range_proof;
+        }
+        if (!output.surjection_proof.empty()) {
+            fprintf(stderr, "did a surj proof\n"); // XXX
+            outwit.vchSurjectionproof = output.surjection_proof;
+        }
+    }
+
+    // This is a convenience/usability check -- it's not invalid to sign an unbalanced transaction, but it's easy to shoot yourself in the foot.
+    if (!imbalance_ok) {
+        // Get UTXOs for all inputs, to check that amounts balance before signing.
+        std::vector<CTxOut> inputs_utxos;
+        for (size_t i = 0; i < psbtx.inputs.size(); ++i) {
+            PSBTInput& inp = psbtx.inputs[i];
+            if (inp.non_witness_utxo) {
+                if (inp.non_witness_utxo->GetHash() != tx.vin[i].prevout.hash) {
+                    throw JSONRPCError(RPC_INVALID_PARAMETER, "UTXO transaction hash does not match transaction prevout hash.");
+                }
+                if (!inp.witness_utxo.IsNull() && inp.non_witness_utxo->vout[tx.vin[i].prevout.n] != inp.witness_utxo) {
+                    throw JSONRPCError(RPC_INVALID_PARAMETER, "PSBT witness and non-witness UTXOs both present and do not match.");
+                }
+                inputs_utxos.push_back(inp.non_witness_utxo->vout[tx.vin[i].prevout.n]);
+            } else if (!inp.witness_utxo.IsNull()) {
+                inputs_utxos.push_back(inp.witness_utxo);
+            } else {
+                throw JSONRPCError(RPC_INVALID_PARAMETER, "Not all UTXOs for transaction are available, and imbalance_ok is not set; refusing to sign.");
+            }
         }
 
+        if (!VerifyAmounts(inputs_utxos, tx, nullptr, false)) {
+            throw JSONRPCError(RPC_INVALID_PARAMETER, "Transaction amounts / blinders do not balance, and imbalance_ok is not set; refusing to sign.");
+        }
+    }
+
+    fprintf(stderr, "about to try signing %zu vins\n", tx.vin.size());
+    bool complete = true;
+    for (unsigned int i = 0; i < tx.vin.size(); ++i) {
         // Get the Sighash type
-        if (sign && input.sighash_type > 0 && input.sighash_type != sighash_type) {
+        if (sign && psbtx.inputs[i].sighash_type > 0 && psbtx.inputs[i].sighash_type != sighash_type) {
             throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Specified Sighash and sighash in PSBT do not match.");
         }
+        fprintf(stderr, "trying to sign input %d (sign=%d)\n", i, sign);
 
-        complete &= SignPSBTInput(HidingSigningProvider(pwallet, !sign, !bip32derivs), *psbtx.tx, input, i, sighash_type);
+        // Here we _only_ sign, and do not e.g. fill in key origin data.
+        complete &= SignPSBTInput(HidingSigningProvider(pwallet, !sign, true /*  no key origins */), psbtx, i, sighash_type);
     }
 
+    // Restore the saved transaction, to remove our temporary munging.
+    psbtx.tx = (CMutableTransaction)oldtx;
+    return complete;
+}
+
+void FillPSBTOutputsData(const CWallet* pwallet, PartiallySignedTransaction& psbtx, bool bip32derivs)
+{
+    LOCK(pwallet->cs_wallet);
+    const CMutableTransaction& tx = *psbtx.tx;
+
     // Fill in the bip32 keypaths and redeemscripts for the outputs so that hardware wallets can identify change
-    for (unsigned int i = 0; i < txConst->vout.size(); ++i) {
-        const CTxOut& out = txConst->vout.at(i);
+    for (unsigned int i = 0; i < tx.vout.size(); ++i) {
+        const CTxOut& out = tx.vout.at(i);
         PSBTOutput& psbt_out = psbtx.outputs.at(i);
 
         // Fill a SignatureData with output info
         SignatureData sigdata;
         psbt_out.FillSignatureData(sigdata);
 
-        MutableTransactionSignatureCreator creator(psbtx.tx.get_ptr(), 0, out.nValue.GetAmount(), 1);
-        ProduceSignature(HidingSigningProvider(pwallet, true, !bip32derivs), creator, out.scriptPubKey, sigdata);
+        MutableTransactionSignatureCreator creator(&tx, 0 /* nIn, ignored */, out.nValue, 1 /* sighashtype, ignored */);
+        ProduceSignature(HidingSigningProvider(pwallet, true /* don't sign */, !bip32derivs), creator, out.scriptPubKey, sigdata);
         psbt_out.FromSignatureData(sigdata);
     }
+}
+
+void FillPSBTData(const CWallet* pwallet, PartiallySignedTransaction& psbtx, bool bip32derivs) {
+    LOCK(pwallet->cs_wallet);
+    FillPSBTInputsData(pwallet, psbtx, bip32derivs);
+    FillPSBTOutputsData(pwallet, psbtx, bip32derivs);
+}
+
+// This function remains for backwards compatibility. It will not succeed in Elements unless everything involved is non-blinded.
+bool FillPSBT(const CWallet* pwallet, PartiallySignedTransaction& psbtx, int sighash_type, bool sign, bool bip32derivs)
+{
+    fprintf(stderr, "fillpsbt called with sign=%d\n", sign);
+    FillPSBTInputsData(pwallet, psbtx, bip32derivs);
+    // For backwards compatibility, do not check if amounts balance before signing in this case.
+    bool complete = SignPSBT(pwallet, psbtx, sighash_type, sign, true);
+    FillPSBTOutputsData(pwallet, psbtx, bip32derivs);
     return complete;
 }
 
+UniValue walletfillpsbtdata(const JSONRPCRequest& request)
+{
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    CWallet* const pwallet = wallet.get();
+
+    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
+        return NullUniValue;
+    }
+
+    if (request.fHelp || request.params.size() < 1 || request.params.size() > 4)
+        throw std::runtime_error(
+            "walletfillpsbtdata \"psbt\" ( bip32derivs )\n"
+            "\nUpdate a PSBT with input information from our wallet\n"
+            + HelpRequiringPassphrase(pwallet) + "\n"
+
+            "\nArguments:\n"
+            "1. \"psbt\"                      (string, required) The transaction base64 string\n"
+            "2. bip32derivs                   (boolean, optional, default=false) If true, includes the BIP 32 derivation paths for public keys if we know them\n"
+
+            "\nResult:\n"
+            "{\n"
+            "  \"psbt\" : \"value\",          (string) The base64-encoded partially signed transaction\n"
+            "}\n"
+
+            "\nExamples:\n"
+            + HelpExampleCli("walletfillpsbtdata", "\"psbt\"")
+        );
+
+    RPCTypeCheck(request.params, {UniValue::VSTR, UniValue::VBOOL});
+
+    // Unserialize the transaction
+    PartiallySignedTransaction psbtx;
+    std::string error;
+    if (!DecodePSBT(psbtx, request.params[0].get_str(), error)) {
+        throw JSONRPCError(RPC_DESERIALIZATION_ERROR, strprintf("TX decode failed %s", error));
+    }
+
+    bool bip32derivs = request.params[1].isNull() ? false : request.params[1].get_bool();
+    FillPSBTData(pwallet, psbtx, bip32derivs);
+
+    UniValue result(UniValue::VOBJ);
+    result.pushKV("psbt", EncodePSBT(psbtx));
+    return result;
+}
+
+UniValue walletsignpsbt(const JSONRPCRequest& request)
+{
+    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
+    CWallet* const pwallet = wallet.get();
+
+    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
+        return NullUniValue;
+    }
+
+    if (request.fHelp || request.params.size() < 1 || request.params.size() > 4)
+        throw std::runtime_error(
+            "walletsignpsbt \"psbt\" ( \"sighashtype\" imbalance_ok )\n"
+            "\nSign all PSBT inputs that we can sign for.\n"
+            "This legacy RPC will fail if any inputs or outputs are blinded. Use walletfillpsbtdata, blindpsbt, and walletsignpsbt instead.\n"
+            + HelpRequiringPassphrase(pwallet) + "\n"
+
+            "\nArguments:\n"
+            "1. \"psbt\"                      (string, required) The transaction base64 string\n"
+            "2. \"sighashtype\"            (string, optional, default=ALL) The signature hash type to sign with if not specified by the PSBT. Must be one of\n"
+            "       \"ALL\"\n"
+            "       \"NONE\"\n"
+            "       \"SINGLE\"\n"
+            "       \"ALL|ANYONECANPAY\"\n"
+            "       \"NONE|ANYONECANPAY\"\n"
+            "       \"SINGLE|ANYONECANPAY\"\n"
+            "3. imbalance_ok                  (boolean, optional, default=false) Sign even if the transaction amounts do not balance\n"
+            "\nResult:\n"
+            "{\n"
+            "  \"psbt\" : \"value\",          (string) The base64-encoded partially signed transaction\n"
+            "  \"complete\" : true|false,   (boolean) If the transaction has a complete set of signatures\n"
+            "}\n"
+
+            "\nExamples:\n"
+            + HelpExampleCli("walletprocesspsbt", "\"psbt\"")
+        );
+
+    RPCTypeCheck(request.params, {UniValue::VSTR, UniValue::VSTR, UniValue::VBOOL});
+
+    // Unserialize the transaction
+    PartiallySignedTransaction psbtx;
+    std::string error;
+    if (!DecodePSBT(psbtx, request.params[0].get_str(), error)) {
+        throw JSONRPCError(RPC_DESERIALIZATION_ERROR, strprintf("TX decode failed %s", error));
+    }
+
+    // Get the sighash type
+    int nHashType = ParseSighashString(request.params[1]);
+    bool imbalance_ok = request.params[2].isNull() ? false : request.params[2].get_bool();
+
+    bool complete = SignPSBT(pwallet, psbtx, nHashType, true, imbalance_ok);
+
+    UniValue result(UniValue::VOBJ);
+    result.pushKV("psbt", EncodePSBT(psbtx));
+    result.pushKV("complete", complete);
+
+    return result;
+}
+
 UniValue walletprocesspsbt(const JSONRPCRequest& request)
 {
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
@@ -4330,14 +4560,10 @@ UniValue walletprocesspsbt(const JSONRPCRequest& request)
     // Get the sighash type
     int nHashType = ParseSighashString(request.params[2]);
 
-    // Use CTransaction for the constant parts of the
-    // transaction to avoid rehashing.
-    const CTransaction txConst(*psbtx.tx);
-
     // Fill transaction with our data and also sign
     bool sign = request.params[1].isNull() ? true : request.params[1].get_bool();
     bool bip32derivs = request.params[3].isNull() ? false : request.params[3].get_bool();
-    bool complete = FillPSBT(pwallet, psbtx, &txConst, nHashType, sign, bip32derivs);
+    bool complete = FillPSBT(pwallet, psbtx, nHashType, sign, bip32derivs);
 
     UniValue result(UniValue::VOBJ);
     CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
@@ -4443,13 +4669,9 @@ UniValue walletcreatefundedpsbt(const JSONRPCRequest& request)
         psbtx.outputs.push_back(PSBTOutput());
     }
 
-    // Use CTransaction for the constant parts of the
-    // transaction to avoid rehashing.
-    const CTransaction txConst(*psbtx.tx);
-
     // Fill transaction with out data but don't sign
     bool bip32derivs = request.params[4].isNull() ? false : request.params[4].get_bool();
-    FillPSBT(pwallet, psbtx, &txConst, 1, false, bip32derivs);
+    FillPSBT(pwallet, psbtx, 1, false, bip32derivs);
 
     // Serialize the PSBT
     CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
@@ -4482,8 +4704,12 @@ static CSecp256k1Init instance_of_csecp256k1;
 
 UniValue getpeginaddress(const JSONRPCRequest& request)
 {
+    fprintf(stderr, "gpi strmethod = %s\n", request.strMethod.c_str());
+    fprintf(stderr, "gpi params = %s\n", request.params.write().c_str());
+    fprintf(stderr, "gpi URI = %s\n", request.URI.c_str());
     std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
     CWallet* const pwallet = wallet.get();
+    fprintf(stderr, "gpi pwallet = %p\n", pwallet);
 
     if (!EnsureWalletIsAvailable(pwallet, request.fHelp))
         return NullUniValue;
@@ -6281,6 +6507,8 @@ static const CRPCCommand commands[] =
     { "wallet",             "walletpassphrase",                 &walletpassphrase,              {"passphrase","timeout"} },
     { "wallet",             "walletpassphrasechange",           &walletpassphrasechange,        {"oldpassphrase","newpassphrase"} },
     { "wallet",             "walletprocesspsbt",                &walletprocesspsbt,             {"psbt","sign","sighashtype","bip32derivs"} },
+    { "wallet",             "walletfillpsbtdata",               &walletfillpsbtdata,            {"psbt","bip32derivs"} },
+    { "wallet",             "walletsignpsbt",                   &walletsignpsbt,                {"psbt","sighashtype","imbalance_ok"} },
     // ELEMENTS:
     { "wallet",             "getpeginaddress",                  &getpeginaddress,               {} },
     { "wallet",             "claimpegin",                       &claimpegin,                    {"bitcoin_tx", "txoutproof", "claim_script"} },
diff --git a/src/wallet/rpcwallet.h b/src/wallet/rpcwallet.h
index 9b9a159b86a..457b0a91224 100644
--- a/src/wallet/rpcwallet.h
+++ b/src/wallet/rpcwallet.h
@@ -30,5 +30,8 @@ bool EnsureWalletIsAvailable(CWallet *, bool avoidException);
 
 UniValue getaddressinfo(const JSONRPCRequest& request);
 UniValue signrawtransactionwithwallet(const JSONRPCRequest& request);
-bool FillPSBT(const CWallet* pwallet, PartiallySignedTransaction& psbtx, const CTransaction* txConst, int sighash_type = 1, bool sign = true, bool bip32derivs = false);
+
+void FillPSBTData(const CWallet* pwallet, PartiallySignedTransaction& psbtx, bool bip32derivs = false);
+bool SignPSBT(const CWallet* pwallet, PartiallySignedTransaction& psbtx, int sighash_type = 1, bool sign = true, bool imbalance_ok = false);
+bool FillPSBT(const CWallet* pwallet, PartiallySignedTransaction& psbtx, int sighash_type = 1, bool sign = true, bool bip32derivs = false);
 #endif //BITCOIN_WALLET_RPCWALLET_H
diff --git a/src/wallet/test/psbt_wallet_tests.cpp b/src/wallet/test/psbt_wallet_tests.cpp
index 526f2d983fc..ced85af60b8 100644
--- a/src/wallet/test/psbt_wallet_tests.cpp
+++ b/src/wallet/test/psbt_wallet_tests.cpp
@@ -57,12 +57,8 @@ BOOST_AUTO_TEST_CASE(psbt_updater_test)
     CDataStream ssData(ParseHex("70736274ff01009a020000000258e87a21b56daf0c23be8e7070456c336f7cbaa5c8757924f545887bb2abdd750000000000ffffffff838d0427d0ec650a68aa46bb0b098aea4422c071b2ca78352a077959d07cea1d0100000000ffffffff0270aaf00800000000160014d85c2b71d0060b09c9886aeb815e50991dda124d00e1f5050000000016001400aea9a2e5f0f876a588df5546e8742d1d87008f000000000000000000"), SER_NETWORK, PROTOCOL_VERSION);
     ssData >> psbtx;
 
-    // Use CTransaction for the constant parts of the
-    // transaction to avoid rehashing.
-    const CTransaction txConst(*psbtx.tx);
-
     // Fill transaction with our data
-    FillPSBT(&m_wallet, psbtx, &txConst, 1, false, true);
+    FillPSBT(&m_wallet, psbtx, 1, false, true);
 
     // Get the final tx
     CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
diff --git a/test/functional/rpc_psbt.py b/test/functional/rpc_psbt.py
index ec52bfdcc0d..f2c0498da43 100755
--- a/test/functional/rpc_psbt.py
+++ b/test/functional/rpc_psbt.py
@@ -6,7 +6,7 @@
 """
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import assert_equal, assert_raises_rpc_error, find_output
+from test_framework.util import assert_equal, assert_raises_rpc_error #XXX , find_output
 
 import json
 import os
@@ -23,9 +23,31 @@ def set_test_params(self):
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
-    def run_test(self):
+    def get_address(self, confidential, node_num, addr_mode=None):
+        if (addr_mode):
+            addr = self.nodes[node_num].getnewaddress()
+        else:
+            addr = self.nodes[node_num].getnewaddress("", addr_mode)
+
+        if confidential:
+            addr = self.nodes[node_num].getaddressinfo(addr)['confidential']
+        else:
+            addr = self.nodes[node_num].getaddressinfo(addr)['unconfidential']
+
+        return addr
+
+    def to_unconf_addr(self, node_num, addr):
+        return self.nodes[node_num].getaddressinfo(addr)['unconfidential']
+
+    def find_output_in_tx(self, tx, amount):
+        for i in range(len(tx["vout"])):
+            if tx["vout"][i]["value"] == amount:
+                return i
+        raise RuntimeError("find_output tx %s : %s not found" % (tx, str(amount)))
+
+    def run_basic_tests(self, confidential):
         # Create and fund a raw tx for sending 10 BTC
-        psbtx1 = self.nodes[0].walletcreatefundedpsbt([], {self.nodes[2].getnewaddress():10})['psbt']
+        psbtx1 = self.nodes[0].walletcreatefundedpsbt([], {self.get_address(confidential, 2):10})['psbt']
 
         # Node 1 should not be able to add anything to it but still return the psbtx same as before
         psbtx = self.nodes[1].walletprocesspsbt(psbtx1)['psbt']
@@ -37,15 +59,21 @@ def run_test(self):
         self.nodes[0].sendrawtransaction(final_tx)
 
         # Create p2sh, p2wpkh, and p2wsh addresses
-        pubkey0 = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress())['pubkey']
-        pubkey1 = self.nodes[1].getaddressinfo(self.nodes[1].getnewaddress())['pubkey']
-        pubkey2 = self.nodes[2].getaddressinfo(self.nodes[2].getnewaddress())['pubkey']
+        pubkey0 = self.nodes[0].getaddressinfo(self.get_address(confidential, 0))['pubkey']
+        pubkey1 = self.nodes[1].getaddressinfo(self.get_address(confidential, 1))['pubkey']
+        pubkey2 = self.nodes[2].getaddressinfo(self.get_address(confidential, 2))['pubkey']
         p2sh = self.nodes[1].addmultisigaddress(2, [pubkey0, pubkey1, pubkey2], "", "legacy")['address']
+        p2sh_unconf = self.to_unconf_addr(1, p2sh)
         p2wsh = self.nodes[1].addmultisigaddress(2, [pubkey0, pubkey1, pubkey2], "", "bech32")['address']
+        p2wsh_unconf = self.to_unconf_addr(1, p2wsh)
         p2sh_p2wsh = self.nodes[1].addmultisigaddress(2, [pubkey0, pubkey1, pubkey2], "", "p2sh-segwit")['address']
-        p2wpkh = self.nodes[1].getnewaddress("", "bech32")
-        p2pkh = self.nodes[1].getnewaddress("", "legacy")
-        p2sh_p2wpkh = self.nodes[1].getnewaddress("", "p2sh-segwit")
+        p2sh_p2wsh_unconf = self.to_unconf_addr(1, p2sh_p2wsh)
+        p2wpkh = self.get_address(confidential, 1, "bech32")
+        p2wpkh_unconf = self.to_unconf_addr(1, p2wpkh)
+        p2pkh = self.get_address(confidential, 1, "legacy")
+        p2pkh_unconf = self.to_unconf_addr(1, p2pkh)
+        p2sh_p2wpkh = self.get_address(confidential, 1, "p2sh-segwit")
+        p2sh_p2wpkh_unconf = self.to_unconf_addr(1, p2sh_p2wpkh)
 
         # fund those addresses
         rawtx = self.nodes[0].createrawtransaction([], {p2sh:10, p2wsh:10, p2wpkh:10, p2sh_p2wsh:10, p2sh_p2wpkh:10, p2pkh:10})
@@ -64,27 +92,29 @@ def run_test(self):
         p2sh_p2wpkh_pos = -1
         decoded = self.nodes[0].decoderawtransaction(signed_tx)
         for out in decoded['vout']:
-            if out['scriptPubKey']['addresses'][0] == p2sh:
+            if out['scriptPubKey']['type'] == 'fee':
+                next
+            elif out['scriptPubKey']['addresses'][0] == p2sh_unconf:
                 p2sh_pos = out['n']
-            elif out['scriptPubKey']['addresses'][0] == p2wsh:
+            elif out['scriptPubKey']['addresses'][0] == p2wsh_unconf:
                 p2wsh_pos = out['n']
-            elif out['scriptPubKey']['addresses'][0] == p2wpkh:
+            elif out['scriptPubKey']['addresses'][0] == p2wpkh_unconf:
                 p2wpkh_pos = out['n']
-            elif out['scriptPubKey']['addresses'][0] == p2sh_p2wsh:
+            elif out['scriptPubKey']['addresses'][0] == p2sh_p2wsh_unconf:
                 p2sh_p2wsh_pos = out['n']
-            elif out['scriptPubKey']['addresses'][0] == p2sh_p2wpkh:
+            elif out['scriptPubKey']['addresses'][0] == p2sh_p2wpkh_unconf:
                 p2sh_p2wpkh_pos = out['n']
-            elif out['scriptPubKey']['addresses'][0] == p2pkh:
+            elif out['scriptPubKey']['addresses'][0] == p2pkh_unconf:
                 p2pkh_pos = out['n']
 
         # spend single key from node 1
-        rawtx = self.nodes[1].walletcreatefundedpsbt([{"txid":txid,"vout":p2wpkh_pos},{"txid":txid,"vout":p2sh_p2wpkh_pos},{"txid":txid,"vout":p2pkh_pos}], {self.nodes[1].getnewaddress():29.99})['psbt']
+        rawtx = self.nodes[1].walletcreatefundedpsbt([{"txid":txid,"vout":p2wpkh_pos},{"txid":txid,"vout":p2sh_p2wpkh_pos},{"txid":txid,"vout":p2pkh_pos}], {self.get_address(confidential, 1):29.99})['psbt']
         walletprocesspsbt_out = self.nodes[1].walletprocesspsbt(rawtx)
         assert_equal(walletprocesspsbt_out['complete'], True)
         self.nodes[1].sendrawtransaction(self.nodes[1].finalizepsbt(walletprocesspsbt_out['psbt'])['hex'])
 
         # partially sign multisig things with node 1
-        psbtx = self.nodes[1].walletcreatefundedpsbt([{"txid":txid,"vout":p2wsh_pos},{"txid":txid,"vout":p2sh_pos},{"txid":txid,"vout":p2sh_p2wsh_pos}], {self.nodes[1].getnewaddress():29.99})['psbt']
+        psbtx = self.nodes[1].walletcreatefundedpsbt([{"txid":txid,"vout":p2wsh_pos},{"txid":txid,"vout":p2sh_pos},{"txid":txid,"vout":p2sh_p2wsh_pos}], {self.get_address(confidential, 1):29.99})['psbt']
         walletprocesspsbt_out = self.nodes[1].walletprocesspsbt(psbtx)
         psbtx = walletprocesspsbt_out['psbt']
         assert_equal(walletprocesspsbt_out['complete'], False)
@@ -95,50 +125,67 @@ def run_test(self):
         self.nodes[2].sendrawtransaction(self.nodes[2].finalizepsbt(walletprocesspsbt_out['psbt'])['hex'])
 
         # check that walletprocesspsbt fails to decode a non-psbt
-        rawtx = self.nodes[1].createrawtransaction([{"txid":txid,"vout":p2wpkh_pos}], {self.nodes[1].getnewaddress():9.99})
+        rawtx = self.nodes[1].createrawtransaction([{"txid":txid,"vout":p2wpkh_pos}], {self.get_address(confidential, 1):9.99})
         assert_raises_rpc_error(-22, "TX decode failed", self.nodes[1].walletprocesspsbt, rawtx)
 
         # Convert a non-psbt to psbt and make sure we can decode it
-        rawtx = self.nodes[0].createrawtransaction([], {self.nodes[1].getnewaddress():10})
+        rawtx = self.nodes[0].createrawtransaction([], {self.get_address(confidential, 1):10})
         rawtx = self.nodes[0].fundrawtransaction(rawtx)
         new_psbt = self.nodes[0].converttopsbt(rawtx['hex'])
         self.nodes[0].decodepsbt(new_psbt)
 
         # Make sure that a psbt with signatures cannot be converted
         signedtx = self.nodes[0].signrawtransactionwithwallet(rawtx['hex'])
-        assert_raises_rpc_error(-22, "Inputs must not have scriptWitnesses", self.nodes[0].converttopsbt, signedtx['hex'])
+        decoded_raw = self.nodes[0].decoderawtransaction(signedtx['hex'])
+        # Can be either a scriptSig or a scriptWitness that it yells about, depending on which UTXOs are selected for the TX
+        assert_raises_rpc_error(-22, "Inputs must not have ", self.nodes[0].converttopsbt, signedtx['hex'])
 
         # Explicitly allow converting non-empty txs
         new_psbt = self.nodes[0].converttopsbt(rawtx['hex'])
         self.nodes[0].decodepsbt(new_psbt)
 
         # Create outputs to nodes 1 and 2
-        node1_addr = self.nodes[1].getnewaddress()
-        node2_addr = self.nodes[2].getnewaddress()
-        txid1 = self.nodes[0].sendtoaddress(node1_addr, 13)
-        txid2 =self.nodes[0].sendtoaddress(node2_addr, 13)
-        self.nodes[0].generate(6)
-        self.sync_all()
-        vout1 = find_output(self.nodes[1], txid1, 13)
-        vout2 = find_output(self.nodes[2], txid2, 13)
-
-        # Create a psbt spending outputs from nodes 1 and 2
-        psbt_orig = self.nodes[0].createpsbt([{"txid":txid1,  "vout":vout1}, {"txid":txid2, "vout":vout2}], {self.nodes[0].getnewaddress():25.999})
-
-        # Update psbts, should only have data for one input and not the other
-        psbt1 = self.nodes[1].walletprocesspsbt(psbt_orig)['psbt']
-        psbt1_decoded = self.nodes[0].decodepsbt(psbt1)
-        assert psbt1_decoded['inputs'][0] and not psbt1_decoded['inputs'][1]
-        psbt2 = self.nodes[2].walletprocesspsbt(psbt_orig)['psbt']
-        psbt2_decoded = self.nodes[0].decodepsbt(psbt2)
-        assert not psbt2_decoded['inputs'][0] and psbt2_decoded['inputs'][1]
-
-        # Combine, finalize, and send the psbts
-        combined = self.nodes[0].combinepsbt([psbt1, psbt2])
-        finalized = self.nodes[0].finalizepsbt(combined)['hex']
-        self.nodes[0].sendrawtransaction(finalized)
+        # We do a whole song-and-dance here (instead of calling sendtoaddress) to get access to the unblinded transaction data to find our outputs
+        node1_addr = self.get_address(confidential, 1)
+        node2_addr = self.get_address(confidential, 2)
+        rt1 = self.nodes[0].createrawtransaction([], {node1_addr:13})
+        rt1 = self.nodes[0].fundrawtransaction(rt1)
+        rt1 = self.nodes[0].signrawtransactionwithwallet(rt1['hex'])
+        txid1 = self.nodes[0].sendrawtransaction(rt1['hex'])
+        rt1 = self.nodes[0].decoderawtransaction(rt1['hex'])
+
+        rt2 = self.nodes[0].createrawtransaction([], {node2_addr:13})
+        rt2 = self.nodes[0].fundrawtransaction(rt2)
+        rt2 = self.nodes[0].signrawtransactionwithwallet(rt2['hex'])
+        txid2 = self.nodes[0].sendrawtransaction(rt2['hex'])
+        rt2 = self.nodes[0].decoderawtransaction(rt2['hex'])
+
         self.nodes[0].generate(6)
         self.sync_all()
+        vout1 = self.find_output_in_tx(rt1, 13)
+        vout2 = self.find_output_in_tx(rt2, 13)
+
+        # This test doesn't work with Confidential Assets yet.
+        if not confidential:
+            # Create a psbt spending outputs from nodes 1 and 2
+            psbt_orig = self.nodes[0].createpsbt([{"txid":txid1,  "vout":vout1}, {"txid":txid2, "vout":vout2}], [{self.get_address(confidential, 0):25.999}, {"fee":0.001}])
+
+            # Update psbts, should only have data for one input and not the other
+            psbt1 = self.nodes[1].walletprocesspsbt(psbt_orig)['psbt']
+            psbt1_decoded = self.nodes[0].decodepsbt(psbt1)
+            assert psbt1_decoded['inputs'][0] and not psbt1_decoded['inputs'][1]
+            psbt1 = self.nodes[1].walletsignpsbt(psbt1, "ALL", True)['psbt'] # Allow signing incomplete tx
+            psbt2 = self.nodes[2].walletprocesspsbt(psbt_orig)['psbt']
+            psbt2_decoded = self.nodes[0].decodepsbt(psbt2)
+            assert not psbt2_decoded['inputs'][0] and psbt2_decoded['inputs'][1]
+            psbt2 = self.nodes[2].walletsignpsbt(psbt2, "ALL", True)['psbt'] # Allow signing incomplete tx
+
+            # Combine, finalize, and send the psbts
+            combined = self.nodes[0].combinepsbt([psbt1, psbt2])
+            finalized = self.nodes[0].finalizepsbt(combined)['hex']
+            self.nodes[0].sendrawtransaction(finalized)
+            self.nodes[0].generate(6)
+            self.sync_all()
 
         # Test additional args in walletcreatepsbt
         # Make sure both pre-included and funded inputs
@@ -146,7 +193,7 @@ def run_test(self):
         # replaceable arg
         block_height = self.nodes[0].getblockcount()
         unspent = self.nodes[0].listunspent()[0]
-        psbtx_info = self.nodes[0].walletcreatefundedpsbt([{"txid":unspent["txid"], "vout":unspent["vout"]}], [{self.nodes[2].getnewaddress():unspent["amount"]+1}], block_height+2, {"replaceable":True}, False)
+        psbtx_info = self.nodes[0].walletcreatefundedpsbt([{"txid":unspent["txid"], "vout":unspent["vout"]}], [{self.get_address(confidential, 2):unspent["amount"]+1}], block_height+2, {"replaceable":True}, False)
         decoded_psbt = self.nodes[0].decodepsbt(psbtx_info["psbt"])
         for tx_in, psbt_in in zip(decoded_psbt["tx"]["vin"], decoded_psbt["inputs"]):
            assert_equal(tx_in["sequence"], MAX_BIP125_RBF_SEQUENCE)
@@ -154,7 +201,7 @@ def run_test(self):
         assert_equal(decoded_psbt["tx"]["locktime"], block_height+2)
 
         # Same construction with only locktime set
-        psbtx_info = self.nodes[0].walletcreatefundedpsbt([{"txid":unspent["txid"], "vout":unspent["vout"]}], [{self.nodes[2].getnewaddress():unspent["amount"]+1}], block_height, {}, True)
+        psbtx_info = self.nodes[0].walletcreatefundedpsbt([{"txid":unspent["txid"], "vout":unspent["vout"]}], [{self.get_address(confidential, 2):unspent["amount"]+1}], block_height, {}, True)
         decoded_psbt = self.nodes[0].decodepsbt(psbtx_info["psbt"])
         for tx_in, psbt_in in zip(decoded_psbt["tx"]["vin"], decoded_psbt["inputs"]):
             assert tx_in["sequence"] > MAX_BIP125_RBF_SEQUENCE
@@ -162,13 +209,13 @@ def run_test(self):
         assert_equal(decoded_psbt["tx"]["locktime"], block_height)
 
         # Same construction without optional arguments
-        psbtx_info = self.nodes[0].walletcreatefundedpsbt([{"txid":unspent["txid"], "vout":unspent["vout"]}], [{self.nodes[2].getnewaddress():unspent["amount"]+1}])
+        psbtx_info = self.nodes[0].walletcreatefundedpsbt([{"txid":unspent["txid"], "vout":unspent["vout"]}], [{self.get_address(confidential, 2):unspent["amount"]+1}])
         decoded_psbt = self.nodes[0].decodepsbt(psbtx_info["psbt"])
         for tx_in in decoded_psbt["tx"]["vin"]:
             assert tx_in["sequence"] > MAX_BIP125_RBF_SEQUENCE
         assert_equal(decoded_psbt["tx"]["locktime"], 0)
 
-
+    def run_bip174_tests(self):
         # BIP 174 Test Vectors
 
         # Check that unknown values are just passed through
@@ -224,6 +271,110 @@ def run_test(self):
             extracted = self.nodes[2].finalizepsbt(extractor['extract'], True)['hex']
             assert_equal(extracted, extractor['result'])
 
+    def run_ca_tests(self):
+        # Confidential Assets tests
+
+        # Start by sending some coins to a nonconf address
+        unconf_addr_0 = self.get_address(False, 0)
+        unconf_addr_1 = self.get_address(False, 0)
+        unconf_addr_4 = self.get_address(False, 0)
+        rawtx = self.nodes[0].createrawtransaction([], {unconf_addr_0:50, unconf_addr_1:50, unconf_addr_4:50})
+        rawtx = self.nodes[0].fundrawtransaction(rawtx, {"changePosition":3})  # our outputs will be 0, 1, 2
+        signed_tx = self.nodes[0].signrawtransactionwithwallet(rawtx['hex'])['hex']
+        txid_nonconf = self.nodes[0].sendrawtransaction(signed_tx)
+        self.nodes[0].generate(1)
+        self.sync_all()
+
+        # Now use PSBT to send some coins nonconf->nonconf
+        unconf_addr_2 = self.get_address(False, 1)
+        psbt = self.nodes[0].createpsbt([{"txid": txid_nonconf, "vout": 0}], [{unconf_addr_2: 49.999}, {"fee": 0.001}])
+        psbt = self.nodes[0].walletfillpsbtdata(psbt)['psbt']
+        psbt = self.nodes[0].walletsignpsbt(psbt)['psbt']
+        tx_hex = self.nodes[0].finalizepsbt(psbt)['hex']
+        txid_nonconf_2 = self.nodes[0].sendrawtransaction(tx_hex)
+        self.nodes[0].generate(1)
+        self.sync_all()
+
+        # Now send nonconf->conf
+        conf_addr = self.get_address(True, 2)
+        psbt = self.nodes[1].createpsbt([{"txid": txid_nonconf_2, "vout": 0}], [{conf_addr: 49.998}, {"fee": 0.001}])
+        psbt = self.nodes[1].walletfillpsbtdata(psbt)['psbt']
+        # Currently can't blind a transaction like this, so it fails
+        assert_raises_rpc_error(-8, "Unable to blind transaction: Add another output to blind in order to complete the blinding.", self.nodes[1].blindpsbt, psbt, False)
+        # Signing without blinding should not work either.
+        assert_raises_rpc_error(-8, "PSBT must be blinded before signing; call blindpsbt.", self.nodes[1].walletsignpsbt, psbt)
+        # If we pass "ignore_blind_fail", then it succeeds in this case without blinding.
+        psbt = self.nodes[1].blindpsbt(psbt, True)
+        psbt = self.nodes[1].walletsignpsbt(psbt)['psbt']
+        hex_tx = self.nodes[1].finalizepsbt(psbt)['hex']
+        txid_conf_1 = self.nodes[1].sendrawtransaction(hex_tx)
+        self.nodes[0].generate(1)
+        self.sync_all()
+
+        # Now send nonconf->conf (with two outputs, blinding succeeds)
+        conf_addr_1 = self.get_address(True, 2)
+        conf_addr_2 = self.get_address(True, 2)
+        psbt = self.nodes[0].createpsbt([{"txid": txid_nonconf, "vout": 1}], [{conf_addr_1: 24.999}, {conf_addr_2: 24.999}, {"fee": 0.002}])
+        psbt = self.nodes[0].walletfillpsbtdata(psbt)['psbt']
+        psbt = self.nodes[0].blindpsbt(psbt, False)
+        psbt = self.nodes[0].walletsignpsbt(psbt)['psbt']
+        hex_tx = self.nodes[0].finalizepsbt(psbt)['hex']
+        txid_conf_2 = self.nodes[0].sendrawtransaction(hex_tx)
+        self.nodes[0].generate(1)
+        self.sync_all()
+
+        # Try to send conf->nonconf: This will fail because we can't balance the blinders
+        unconf_addr_3 = self.get_address(False, 0)
+        psbt = self.nodes[2].createpsbt([{"txid": txid_conf_2, "vout": 0}], [{unconf_addr_3: 24.998}, {"fee": 0.001}])
+        psbt = self.nodes[2].walletfillpsbtdata(psbt)['psbt']
+        assert_raises_rpc_error(-8, "Unable to blind transaction: Add another output to blind in order to complete the blinding.", self.nodes[2].blindpsbt, psbt, False)
+
+        # Try to send conf->(nonconf + conf), so we have a conf output to balance blinders
+        conf_addr_3 = self.get_address(True, 0)
+        psbt = self.nodes[2].createpsbt([{"txid": txid_conf_2, "vout": 0}], [{unconf_addr_3: 10}, {conf_addr_3: 14.998}, {"fee": 0.001}])
+        psbt = self.nodes[2].walletfillpsbtdata(psbt)['psbt']
+        psbt = self.nodes[2].blindpsbt(psbt, False)
+        psbt = self.nodes[2].walletsignpsbt(psbt)['psbt']
+        hex_tx = self.nodes[2].finalizepsbt(psbt)['hex']
+        txid_conf_3 = self.nodes[2].sendrawtransaction(hex_tx)
+        self.nodes[0].generate(1)
+        self.sync_all()
+
+        # Try to send conf->conf
+        conf_addr_4 = self.get_address(True, 0)
+        psbt = self.nodes[2].createpsbt([{"txid": txid_conf_2, "vout": 1}], [{conf_addr_4: 24.998}, {"fee": 0.001}])
+        psbt = self.nodes[2].walletfillpsbtdata(psbt)['psbt']
+        psbt = self.nodes[2].blindpsbt(psbt, False)
+        psbt = self.nodes[2].walletsignpsbt(psbt)['psbt']
+        hex_tx = self.nodes[2].finalizepsbt(psbt)['hex']
+        txid_conf_4 = self.nodes[2].sendrawtransaction(hex_tx)
+        self.nodes[0].generate(1)
+        self.sync_all()
+
+        # Try to send nonconf->(nonconf + conf + conf) -- two conf to make blinders balance
+        nonconf_addr_5 = self.get_address(False, 1)
+        conf_addr_5 = self.get_address(True, 1)
+        conf_addr_6 = self.get_address(True, 2)
+        psbt = self.nodes[0].createpsbt([{"txid": txid_nonconf, "vout": 2}], [{nonconf_addr_5: 24.999}, {conf_addr_5: 14.999}, {conf_addr_6: 10}, {"fee": 0.002}])
+        psbt = self.nodes[0].walletfillpsbtdata(psbt)['psbt']
+        psbt = self.nodes[0].blindpsbt(psbt, False)
+        psbt = self.nodes[0].walletsignpsbt(psbt)['psbt']
+        hex_tx = self.nodes[0].finalizepsbt(psbt)['hex']
+        txid_conf_5 = self.nodes[0].sendrawtransaction(hex_tx)
+        self.nodes[0].generate(1)
+        self.sync_all()
+
+    def run_test(self):
+        # Run all the pre-Elements, tests first with non-confidential addresses, then again with confidential addresses
+        self.run_basic_tests(False)
+        self.run_basic_tests(True)
+
+        # BIP 174 test vectors are disabled, because they have embedded serialized CTransactions, and
+        #   the transaction serialization format changed in Elements so none of them work
+        #self.run_bip174_tests()
+
+        # Some Confidential-Assets-specific tests
+        self.run_ca_tests()
 
 if __name__ == '__main__':
     PSBTTest().main()