diff --git a/src/rpc/client.cpp b/src/rpc/client.cpp
index 7281fe6605..0906a10b89 100644
--- a/src/rpc/client.cpp
+++ b/src/rpc/client.cpp
@@ -104,11 +104,13 @@ static const CRPCConvertParam vRPCConvertParams[] =
     { "combinerawtransaction", 0, "txs" },
     { "fundrawtransaction", 1, "options" },
     { "fundrawtransaction", 2, "iswitness" },
+    { "fundrawtransaction", 3, "solving_data" },
     { "walletcreatefundedpsbt", 0, "inputs" },
     { "walletcreatefundedpsbt", 1, "outputs" },
     { "walletcreatefundedpsbt", 2, "locktime" },
     { "walletcreatefundedpsbt", 3, "options" },
     { "walletcreatefundedpsbt", 4, "bip32derivs" },
+    { "walletcreatefundedpsbt", 5, "solving_data" },
     { "walletprocesspsbt", 1, "sign" },
     { "walletprocesspsbt", 3, "bip32derivs" },
     { "walletfillpsbtdata", 1, "bip32derivs" },
diff --git a/src/script/signingprovider.h b/src/script/signingprovider.h
index c40fecac5c..41ad500d43 100644
--- a/src/script/signingprovider.h
+++ b/src/script/signingprovider.h
@@ -8,12 +8,11 @@
 
 #include <key.h>
 #include <pubkey.h>
+#include <script/keyorigin.h>
 #include <script/script.h>
 #include <script/standard.h>
 #include <sync.h>
 
-struct KeyOriginInfo;
-
 /** An interface to be implemented by keystores that support signing. */
 class SigningProvider
 {
diff --git a/src/wallet/coincontrol.cpp b/src/wallet/coincontrol.cpp
index edd2c654cb..441d7d1e0e 100644
--- a/src/wallet/coincontrol.cpp
+++ b/src/wallet/coincontrol.cpp
@@ -20,6 +20,8 @@ void CCoinControl::SetNull()
     m_confirm_target.reset();
     m_signal_bip125_rbf.reset();
     m_fee_mode = FeeEstimateMode::UNSET;
+    m_external_txouts.clear();
+    m_external_provider = FlatSigningProvider();
     m_min_depth = DEFAULT_MIN_DEPTH;
     m_max_depth = DEFAULT_MAX_DEPTH;
 }
diff --git a/src/wallet/coincontrol.h b/src/wallet/coincontrol.h
index b04a0957eb..adbdcda1f0 100644
--- a/src/wallet/coincontrol.h
+++ b/src/wallet/coincontrol.h
@@ -6,10 +6,12 @@
 #define BITCOIN_WALLET_COINCONTROL_H
 
 #include <asset.h>
+#include <chainparams.h>
 #include <optional.h>
 #include <outputtype.h>
 #include <policy/feerate.h>
 #include <policy/fees.h>
+#include <primitives/bitcoin/transaction.h>
 #include <primitives/transaction.h>
 #include <script/standard.h>
 
@@ -45,6 +47,8 @@ public:
     bool m_avoid_address_reuse;
     //! Fee estimation mode to control arguments to estimateSmartFee
     FeeEstimateMode m_fee_mode;
+    //! SigningProvider that has pubkeys and scripts to do spend size estimation for external inputs
+    FlatSigningProvider m_external_provider;
     //! Minimum chain depth value for coin availability
     int m_min_depth = DEFAULT_MIN_DEPTH;
     //! Maximum chain depth value for coin availability
@@ -67,11 +71,42 @@ public:
         return (setSelected.count(output) > 0);
     }
 
+    bool IsExternalSelected(const COutPoint& output) const
+    {
+        return (m_external_txouts.count(output) > 0);
+    }
+
+    bool GetExternalOutput(const COutPoint& outpoint, CTxOut& txout) const
+    {
+        const auto ext_it = m_external_txouts.find(outpoint);
+        if (ext_it == m_external_txouts.end()) {
+            return false;
+        }
+        txout = ext_it->second;
+        return true;
+    }
+
     void Select(const COutPoint& output)
     {
         setSelected.insert(output);
     }
 
+    void SelectExternal(const COutPoint& outpoint, const CTxOut& txout)
+    {
+        setSelected.insert(outpoint);
+        m_external_txouts.emplace(outpoint, txout);
+    }
+
+    void Select(const COutPoint& outpoint, const Sidechain::Bitcoin::CTxOut& txout_in)
+    {
+        setSelected.insert(outpoint);
+        CTxOut txout;
+        txout.scriptPubKey = txout_in.scriptPubKey;
+        txout.nValue.SetToAmount(txout_in.nValue);
+        txout.nAsset.SetToAsset(Params().GetConsensus().pegged_asset);
+        m_external_txouts.emplace(outpoint, txout);
+    }
+
     void UnSelect(const COutPoint& output)
     {
         setSelected.erase(output);
@@ -89,6 +124,7 @@ public:
 
 private:
     std::set<COutPoint> setSelected;
+    std::map<COutPoint, CTxOut> m_external_txouts;
 };
 
 #endif // BITCOIN_WALLET_COINCONTROL_H
diff --git a/src/wallet/coinselection.h b/src/wallet/coinselection.h
index 0fee6ada96..ebee172223 100644
--- a/src/wallet/coinselection.h
+++ b/src/wallet/coinselection.h
@@ -6,7 +6,9 @@
 #define BITCOIN_WALLET_COINSELECTION_H
 
 #include <amount.h>
+#include <chainparams.h>
 #include <primitives/transaction.h>
+#include <primitives/bitcoin/transaction.h>
 #include <random.h>
 
 //! target minimum change amount
@@ -26,6 +28,41 @@ public:
         m_input_bytes = input_bytes;
     }
 
+    CInputCoin(const COutPoint& outpoint_in, const CTxOut& txout_in)
+    {
+        outpoint = outpoint_in;
+        txout = txout_in;
+        if (txout.nValue.IsExplicit()) {
+            effective_value = txout_in.nValue.GetAmount();
+            value = txout.nValue.GetAmount();
+            asset = txout.nAsset.GetAsset();
+        } else {
+            effective_value = 0;
+        }
+    }
+
+    CInputCoin(const COutPoint& outpoint_in, const CTxOut& txout_in, int input_bytes) : CInputCoin(outpoint_in, txout_in)
+    {
+        m_input_bytes = input_bytes;
+    }
+
+    CInputCoin(const COutPoint& outpoint_in, const Sidechain::Bitcoin::CTxOut& txout_in)
+    {
+        outpoint = outpoint_in;
+        effective_value = txout_in.nValue;
+        txout.SetNull();
+        txout.scriptPubKey = txout_in.scriptPubKey;
+        txout.nValue.SetToAmount(txout_in.nValue);
+        txout.nAsset.SetToAsset(Params().GetConsensus().pegged_asset);
+        asset = Params().GetConsensus().pegged_asset;
+        value = txout_in.nValue;
+    }
+
+    CInputCoin(const COutPoint& outpoint_in, const Sidechain::Bitcoin::CTxOut& txout_in, int input_bytes) : CInputCoin(outpoint_in, txout_in)
+    {
+        m_input_bytes = input_bytes;
+    }
+
     COutPoint outpoint;
     CTxOut txout;
     CAmount effective_value;
diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
index 157ce2d7e3..6e866a7af0 100644
--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@@ -3275,7 +3275,7 @@ static UniValue listunspent(const JSONRPCRequest& request)
     return results;
 }
 
-void FundTransaction(CWallet* const pwallet, CMutableTransaction& tx, CAmount& fee_out, int& change_position, UniValue options)
+void FundTransaction(CWallet* const pwallet, CMutableTransaction& tx, CAmount& fee_out, int& change_position, UniValue options, const UniValue& solving_data)
 {
     // Make sure the results are valid at least up to the most recent block
     // the user could have gotten from another RPC command prior to now
@@ -3395,6 +3395,41 @@ void FundTransaction(CWallet* const pwallet, CMutableTransaction& tx, CAmount& f
         coinControl.fAllowWatchOnly = ParseIncludeWatchonly(NullUniValue, *pwallet);
     }
 
+    if (!solving_data.isNull()) {
+        if (solving_data.exists("pubkeys")) {
+            UniValue pubkey_strs = solving_data["pubkeys"].get_array();
+            for (unsigned int i = 0; i < pubkey_strs.size(); ++i) {
+                std::vector<unsigned char> data(ParseHex(pubkey_strs[i].get_str()));
+                CPubKey pubkey(data.begin(), data.end());
+                if (!pubkey.IsFullyValid()) {
+                    throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strprintf("%s is not a valid public key", pubkey_strs[i].get_str()));
+                }
+                coinControl.m_external_provider.pubkeys.emplace(pubkey.GetID(), pubkey);
+                // Add witnes script for pubkeys
+                CScript wit_script = GetScriptForDestination(WitnessV0KeyHash(pubkey.GetID()));
+                coinControl.m_external_provider.scripts.emplace(CScriptID(wit_script), wit_script);
+            }
+        }
+
+        if (solving_data.exists("scripts")) {
+            UniValue script_strs = solving_data["scripts"].get_array();
+            for (unsigned int i = 0; i < script_strs.size(); ++i) {
+                CScript script = ParseScript(script_strs[i].get_str());
+                coinControl.m_external_provider.scripts.emplace(CScriptID(script), script);
+            }
+        }
+
+        if (solving_data.exists("descriptors")) {
+            UniValue desc_strs = solving_data["descriptors"].get_array();
+            for (unsigned int i = 0; i < desc_strs.size(); ++i) {
+                FlatSigningProvider desc_out;
+                std::string error;
+                std::unique_ptr<Descriptor> desc = Parse(desc_strs[i].get_str(), desc_out, error, true);
+                coinControl.m_external_provider = Merge(coinControl.m_external_provider, desc_out);
+            }
+        }
+    }
+
     if (tx.vout.size() == 0)
         throw JSONRPCError(RPC_INVALID_PARAMETER, "TX must have at least one output");
 
@@ -3412,6 +3447,42 @@ void FundTransaction(CWallet* const pwallet, CMutableTransaction& tx, CAmount& f
         setSubtractFeeFromOutputs.insert(pos);
     }
 
+    // Check any existing inputs for peg-in data and add to external txouts if so
+    // Fetch specified UTXOs from the UTXO set
+    const auto& fedpegscripts = GetValidFedpegScripts(::ChainActive().Tip(), Params().GetConsensus(), true /* nextblock_validation */);
+    std::map<COutPoint, Coin> coins;
+    for (unsigned int i = 0; i < tx.vin.size(); ++i ) {
+        const CTxIn& txin = tx.vin[i];
+        coins[txin.prevout]; // Create empty map entry keyed by prevout.
+        if (txin.m_is_pegin) {
+            std::string err;
+            if (tx.witness.vtxinwit.size() != tx.vin.size() || !IsValidPeginWitness(tx.witness.vtxinwit[i].m_pegin_witness, fedpegscripts, txin.prevout, err, false)) {
+                throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Transaction contains invalid peg-in input: %s", err));
+            }
+            CScriptWitness& pegin_witness = tx.witness.vtxinwit[i].m_pegin_witness;
+            CTxOut txout = GetPeginOutputFromWitness(pegin_witness);
+            coinControl.SelectExternal(txin.prevout, txout);
+        }
+    }
+    CCoinsView viewDummy;
+    CCoinsViewCache view(&viewDummy);
+    {
+        LOCK2(cs_main, mempool.cs);
+        CCoinsViewCache& chain_view = ::ChainstateActive().CoinsTip();
+        CCoinsViewMemPool mempool_view(&chain_view, mempool);
+        for (auto& coin : coins) {
+            if (!mempool_view.GetCoin(coin.first, coin.second)) {
+                // Either the coin is not in the CCoinsViewCache or is spent. Clear it.
+                coin.second.Clear();
+            }
+        }
+    }
+    for (const auto& coin : coins) {
+        if (!coin.second.out.IsNull()) {
+            coinControl.SelectExternal(coin.first, coin.second.out);
+        }
+    }
+
     std::string strFailReason;
 
     if (!pwallet->FundTransaction(tx, fee_out, change_position, strFailReason, lockUnspents, setSubtractFeeFromOutputs, coinControl)) {
@@ -3476,6 +3547,25 @@ static UniValue fundrawtransaction(const JSONRPCRequest& request)
                         "This boolean should reflect whether the transaction has inputs\n"
                         "(e.g. fully valid, or on-chain transactions), if known by the caller."
                     },
+                    {"solving_data", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED_NAMED_ARG, "Keys and scripts needed for producing a final transaction with a dummy signature. Used for fee estimation during coin selection.\n",
+                        {
+                            {"pubkeys", RPCArg::Type::ARR, /* default */ "empty array", "A json array of public keys.\n",
+                                {
+                                    {"pubkey", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "A public key"},
+                                },
+                            },
+                            {"scripts", RPCArg::Type::ARR, /* default */ "empty array", "A json array of scripts.\n",
+                                {
+                                    {"script", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "A script"},
+                                },
+                            },
+                            {"descriptors", RPCArg::Type::ARR, /* default */ "empty array", "A json array of descriptors.\n",
+                                {
+                                    {"descriptor", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "A descriptor"},
+                                },
+                            }
+                        }
+                    },
                 },
                 RPCResult{
                             "{\n"
@@ -3508,7 +3598,7 @@ static UniValue fundrawtransaction(const JSONRPCRequest& request)
 
     CAmount fee;
     int change_position;
-    FundTransaction(pwallet, tx, fee, change_position, request.params[1]);
+    FundTransaction(pwallet, tx, fee, change_position, request.params[1], request.params[3]);
 
     UniValue result(UniValue::VOBJ);
     result.pushKV("hex", EncodeHexTx(CTransaction(tx)));
@@ -4658,6 +4748,9 @@ UniValue walletcreatefundedpsbt(const JSONRPCRequest& request)
                                     {"txid", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The transaction id"},
                                     {"vout", RPCArg::Type::NUM, RPCArg::Optional::NO, "The output number"},
                                     {"sequence", RPCArg::Type::NUM, RPCArg::Optional::NO, "The sequence number"},
+                                    {"pegin_bitcoin_tx", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The raw bitcoin transaction (in hex) depositing bitcoin to the mainchain_address generated by getpeginaddress"},
+                                    {"pegin_txout_proof", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "A rawtxoutproof (in hex) generated by the mainchain daemon's `gettxoutproof` containing a proof of only bitcoin_tx"},
+                                    {"pegin_claim_script", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, "The witness program generated by getpeginaddress."},
                                 },
                             },
                         },
@@ -4706,6 +4799,25 @@ UniValue walletcreatefundedpsbt(const JSONRPCRequest& request)
                         },
                         "options"},
                     {"bip32derivs", RPCArg::Type::BOOL, /* default */ "false", "If true, includes the BIP 32 derivation paths for public keys if we know them"},
+                    {"solving_data", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED_NAMED_ARG, "Keys and scripts needed for producing a final transaction with a dummy signature. Used for fee estimation during coin selection.\n",
+                        {
+                            {"pubkeys", RPCArg::Type::ARR, /* default */ "empty array", "A json array of public keys.\n",
+                                {
+                                    {"pubkey", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "A public key"},
+                                },
+                            },
+                            {"scripts", RPCArg::Type::ARR, /* default */ "empty array", "A json array of scripts.\n",
+                                {
+                                    {"script", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "A script"},
+                                },
+                            },
+                            {"descriptors", RPCArg::Type::ARR, /* default */ "empty array", "A json array of descriptors.\n",
+                                {
+                                    {"descriptor", RPCArg::Type::STR_HEX, RPCArg::Optional::OMITTED, "A descriptor"},
+                                },
+                            }
+                        }
+                    },
                 },
                 RPCResult{
                             "{\n"
@@ -4740,8 +4852,8 @@ UniValue walletcreatefundedpsbt(const JSONRPCRequest& request)
     // It's hard to control the behavior of FundTransaction, so we will wait
     //   until after it's done, then extract the blinding keys from the output
     //   nonces.
-    CMutableTransaction rawTx = ConstructTransaction(request.params[0], request.params[1], request.params[2], rbf, NullUniValue /* CA: assets_in */, nullptr /* output_pubkeys_out */, false /* allow_peg_in */);
-    FundTransaction(pwallet, rawTx, fee, change_position, request.params[3]);
+    CMutableTransaction rawTx = ConstructTransaction(request.params[0], request.params[1], request.params[2], rbf, NullUniValue /* CA: assets_in */, nullptr /* output_pubkeys_out */, true /* allow_peg_in */);
+    FundTransaction(pwallet, rawTx, fee, change_position, request.params[3], request.params[5]);
 
     // Make a blank psbt
     PartiallySignedTransaction psbtx(rawTx);
@@ -4761,6 +4873,42 @@ UniValue walletcreatefundedpsbt(const JSONRPCRequest& request)
         throw JSONRPCTransactionError(err);
     }
 
+    // Add peg-in stuff if it's there
+    for (unsigned int i = 0; i < rawTx.vin.size(); ++i) {
+        if (psbtx.tx->vin[i].m_is_pegin) {
+            CScriptWitness& pegin_witness = psbtx.tx->witness.vtxinwit[i].m_pegin_witness;
+            CAmount val;
+            VectorReader vr_val(SER_NETWORK, PROTOCOL_VERSION, pegin_witness.stack[0], 0);
+            vr_val >> val;
+            psbtx.inputs[i].value = val;
+            VectorReader vr_asset(SER_NETWORK, PROTOCOL_VERSION, pegin_witness.stack[1], 0);
+            vr_asset >> psbtx.inputs[i].asset;
+            VectorReader vr_genesis(SER_NETWORK, PROTOCOL_VERSION, pegin_witness.stack[2], 0);
+            vr_genesis >> psbtx.inputs[i].genesis_hash;
+            psbtx.inputs[i].claim_script.assign(pegin_witness.stack[3].begin(), pegin_witness.stack[3].end());
+
+            VectorReader vr_tx(SER_NETWORK, PROTOCOL_VERSION, pegin_witness.stack[4], 0);
+            VectorReader vr_proof(SER_NETWORK, PROTOCOL_VERSION, pegin_witness.stack[5], 0);
+            if (Params().GetConsensus().ParentChainHasPow()) {
+                Sidechain::Bitcoin::CTransactionRef tx_btc;
+                vr_tx >> tx_btc;
+                psbtx.inputs[i].peg_in_tx = tx_btc;
+                Sidechain::Bitcoin::CMerkleBlock tx_proof;
+                vr_proof >> tx_proof;
+                psbtx.inputs[i].txout_proof = tx_proof;
+            } else {
+                CTransactionRef tx_btc;
+                vr_tx >> tx_btc;
+                psbtx.inputs[i].peg_in_tx = tx_btc;
+                CMerkleBlock tx_proof;
+                vr_proof >> tx_proof;
+                psbtx.inputs[i].txout_proof = tx_proof;
+            }
+            pegin_witness.SetNull();
+            psbtx.tx->vin[i].m_is_pegin = false;
+        }
+    }
+
     // Serialize the PSBT
     CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
     ssTx << psbtx;
@@ -6641,7 +6789,7 @@ UniValue getwalletpakinfo(const JSONRPCRequest& request);
 static const CRPCCommand commands[] =
 { //  category              name                                actor (function)                argNames
     //  --------------------- ------------------------          -----------------------         ----------
-    { "rawtransactions",    "fundrawtransaction",               &fundrawtransaction,            {"hexstring","options","iswitness"} },
+    { "rawtransactions",    "fundrawtransaction",               &fundrawtransaction,            {"hexstring","options","iswitness","solving_data"} },
     { "wallet",             "abandontransaction",               &abandontransaction,            {"txid"} },
     { "wallet",             "abortrescan",                      &abortrescan,                   {} },
     { "wallet",             "addmultisigaddress",               &addmultisigaddress,            {"nrequired","keys","label","address_type"} },
@@ -6692,7 +6840,7 @@ static const CRPCCommand commands[] =
     { "wallet",             "signmessage",                      &signmessage,                   {"address","message"} },
     { "wallet",             "signrawtransactionwithwallet",     &signrawtransactionwithwallet,  {"hexstring","prevtxs","sighashtype"} },
     { "wallet",             "unloadwallet",                     &unloadwallet,                  {"wallet_name"} },
-    { "wallet",             "walletcreatefundedpsbt",           &walletcreatefundedpsbt,        {"inputs","outputs","locktime","options","bip32derivs"} },
+    { "wallet",             "walletcreatefundedpsbt",           &walletcreatefundedpsbt,        {"inputs","outputs","locktime","options","bip32derivs","solving_data"} },
     { "wallet",             "walletlock",                       &walletlock,                    {} },
     { "wallet",             "walletpassphrase",                 &walletpassphrase,              {"passphrase","timeout"} },
     { "wallet",             "walletpassphrasechange",           &walletpassphrasechange,        {"oldpassphrase","newpassphrase"} },
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
index c65d58b8e1..f1c16971f3 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -1403,18 +1403,12 @@ int64_t CWalletTx::GetTxTime() const
 
 // Helper for producing a max-sized low-S low-R signature (eg 71 bytes)
 // or a max-sized low-S signature (e.g. 72 bytes) if use_max_sig is true
-bool CWallet::DummySignInput(CMutableTransaction& tx, const size_t nIn, const CTxOut& txout, bool use_max_sig) const
+static bool DummySignInput(const SigningProvider* provider, CMutableTransaction& tx, const size_t nIn, const CTxOut& txout, bool use_max_sig)
 {
     // Fill in dummy signatures for fee calculation.
     const CScript& scriptPubKey = txout.scriptPubKey;
     SignatureData sigdata;
 
-    const SigningProvider* provider = GetSigningProvider(scriptPubKey);
-    if (!provider) {
-        // We don't know about this scriptpbuKey;
-        return false;
-    }
-
     if (!ProduceSignature(*provider, use_max_sig ? DUMMY_MAXIMUM_SIGNATURE_CREATOR : DUMMY_SIGNATURE_CREATOR, scriptPubKey, sigdata)) {
         return false;
     }
@@ -1423,14 +1417,19 @@ bool CWallet::DummySignInput(CMutableTransaction& tx, const size_t nIn, const CT
 }
 
 // Helper for producing a bunch of max-sized low-S low-R signatures (eg 71 bytes)
-bool CWallet::DummySignTx(CMutableTransaction &txNew, const std::vector<CTxOut> &txouts, bool use_max_sig) const
+bool CWallet::DummySignTx(CMutableTransaction &txNew, const std::vector<CTxOut> &txouts, const CCoinControl* coin_control) const
 {
     // Fill in dummy signatures for fee calculation.
     int nIn = 0;
     for (const auto& txout : txouts)
     {
-        if (!DummySignInput(txNew, nIn, txout, use_max_sig)) {
-            return false;
+        const SigningProvider* provider = GetSigningProvider(txout.scriptPubKey);
+        // Use max sig if watch only inputs were used or if this particular input is an external input
+        bool use_max_sig = coin_control && (coin_control->fAllowWatchOnly || (coin_control && coin_control->IsExternalSelected(txNew.vin[nIn].prevout)));
+        if (!provider || !DummySignInput(provider, txNew, nIn, txout, use_max_sig)) {
+            if (!coin_control || !DummySignInput(&coin_control->m_external_provider, txNew, nIn, txout, use_max_sig)) {
+                return false;
+            }
         }
 
         nIn++;
@@ -1491,43 +1490,53 @@ bool CWallet::ImportScriptPubKeys(const std::string& label, const std::set<CScri
     return true;
 }
 
-int64_t CalculateMaximumSignedTxSize(const CTransaction &tx, const CWallet *wallet, bool use_max_sig)
+int64_t CalculateMaximumSignedTxSize(const CTransaction &tx, const CWallet *wallet, const CCoinControl* coin_control)
 {
     std::vector<CTxOut> txouts;
+    // Look up the inputs. The inputs are either in the wallet, or in coin_control.
     for (const CTxIn& input : tx.vin) {
         const auto mi = wallet->mapWallet.find(input.prevout.hash);
-        // Can not estimate size without knowing the input details
-        if (mi == wallet->mapWallet.end()) {
+        if (mi != wallet->mapWallet.end()) {
+            assert(input.prevout.n < mi->second.tx->vout.size());
+            txouts.emplace_back(mi->second.tx->vout[input.prevout.n]);
+        } else if (coin_control) {
+            CTxOut txout;
+            if (!coin_control->GetExternalOutput(input.prevout, txout)) {
+                return -1;
+            }
+            txouts.emplace_back(txout);
+        } else {
             return -1;
         }
-        assert(input.prevout.n < mi->second.tx->vout.size());
-        txouts.emplace_back(mi->second.tx->vout[input.prevout.n]);
     }
-    return CalculateMaximumSignedTxSize(tx, wallet, txouts, use_max_sig);
+    return CalculateMaximumSignedTxSize(tx, wallet, txouts, coin_control);
 }
 
 // txouts needs to be in the order of tx.vin
-int64_t CalculateMaximumSignedTxSize(const CTransaction &tx, const CWallet *wallet, const std::vector<CTxOut>& txouts, bool use_max_sig)
+int64_t CalculateMaximumSignedTxSize(const CTransaction &tx, const CWallet *wallet, const std::vector<CTxOut>& txouts, const CCoinControl* coin_control)
 {
     CMutableTransaction txNew(tx);
-    if (!wallet->DummySignTx(txNew, txouts, use_max_sig)) {
+    if (!wallet->DummySignTx(txNew, txouts, coin_control)) {
         return -1;
     }
     return GetVirtualTransactionSize(CTransaction(txNew));
 }
 
-int CalculateMaximumSignedInputSize(const CTxOut& txout, const CWallet* wallet, bool use_max_sig)
-{
+int CalculateMaximumSignedInputSize(const CTxOut& txout, const SigningProvider* provider, bool use_max_sig) {
     CMutableTransaction txn;
     txn.vin.push_back(CTxIn(COutPoint()));
-    if (!wallet->DummySignInput(txn, 0, txout, use_max_sig)) {
-        // This should never happen, because IsAllFromMe(ISMINE_SPENDABLE)
-        // implies that we can sign for every input.
+    if (!provider || !DummySignInput(provider, txn, 0, txout, use_max_sig)) {
         return -1;
     }
     return GetVirtualTransactionInputSize(CTransaction(txn));
 }
 
+int CalculateMaximumSignedInputSize(const CTxOut& txout, const CWallet* wallet, bool use_max_sig)
+{
+    const SigningProvider* provider = wallet->GetSigningProvider(txout.scriptPubKey);
+    return CalculateMaximumSignedInputSize(txout, provider, use_max_sig);
+}
+
 void CWalletTx::GetAmounts(std::list<COutputEntry>& listReceived,
                            std::list<COutputEntry>& listSent, CAmount& nFee, const isminefilter& filter) const
 {
@@ -2400,33 +2409,66 @@ bool CWallet::SelectCoins(const std::vector<COutput>& vAvailableCoins, const CAm
     for (const COutPoint& outpoint : vPresetInputs)
     {
         std::map<uint256, CWalletTx>::const_iterator it = mapWallet.find(outpoint.hash);
-        if (it != mapWallet.end())
-        {
+        // ELEMENTS: this code pulled from unmerged Core PR #17211
+        int input_bytes = -1;
+        CTxOut txout;
+        CInputCoin coin(outpoint, txout, 0); // dummy initialization
+        if (it != mapWallet.end()) {
             const CWalletTx& wtx = it->second;
             // Clearly invalid input, fail
             if (wtx.tx->vout.size() <= outpoint.n) {
                 return false;
             }
             // Just to calculate the marginal byte size
-            CAmount amt = wtx.GetOutputValueOut(outpoint.n);
-            if (amt < 0) {
+            if (wtx.GetOutputValueOut(outpoint.n) < 0) {
                 continue;
             }
-            CInputCoin coin(&wtx, outpoint.n, wtx.GetSpendSize(outpoint.n, false));
-            mapValueFromPresetInputs[wtx.GetOutputAsset(outpoint.n)] += amt;
-            if (coin.m_input_bytes <= 0) {
-                return false; // Not solvable, can't estimate size for fee
-            }
-            coin.effective_value = coin.value - coin_selection_params.effective_fee.GetFee(coin.m_input_bytes);
-            if (coin_selection_params.use_bnb) {
-                value_to_select[coin.asset] -= coin.effective_value;
-            } else {
-                value_to_select[coin.asset] -= coin.value;
-            }
-            setPresetCoins.insert(coin);
-        } else {
-            return false; // TODO: Allow non-wallet inputs
+            input_bytes = wtx.GetSpendSize(outpoint.n, false);
+            txout = wtx.tx->vout[outpoint.n];
+            // ELEMENTS: must assign coin from wtx if we can, so the wallet
+            //  can look up any confidential amounts/assets
+            coin = CInputCoin(&wtx, outpoint.n, input_bytes);
         }
+        if (input_bytes == -1) {
+            // The input is external. We either did not find the tx in mapWallet, or we did but couldn't compute the input size with wallet data
+            if (!coin_control.GetExternalOutput(outpoint, txout)) {
+                // Not ours, and we don't have solving data.
+                return false;
+            }
+            input_bytes = CalculateMaximumSignedInputSize(txout, &coin_control.m_external_provider, /* use_max_sig */ true);
+            // ELEMENTS: one more try to get a signed input size: for pegins,
+            //  the outpoint is provided as external data but the information
+            //  needed to spend is in the wallet (not the external provider,
+            //  as the user is expecting the wallet to remember this information
+            //  after they called getpeginaddress). So try estimating size with
+            //  the wallet rather than the external provider.
+            if (input_bytes == -1) {
+                input_bytes = CalculateMaximumSignedInputSize(txout, this, /* use_max_sig */ true);
+            }
+            if (!txout.nValue.IsExplicit() || !txout.nAsset.IsExplicit()) {
+                return false; // We can't get its value, so abort
+            }
+            coin = CInputCoin(outpoint, txout, input_bytes);
+        }
+
+        mapValueFromPresetInputs[coin.asset] += coin.value;
+        if (coin.m_input_bytes <= 0) {
+            // ELEMENTS: if we're here we can't compute the coin's effective value. At
+	    //  this point in the rebase this is only used for BnB, and our functional
+            //  tests expect the user to get a "missing data" error rather than an
+            //  "insufficient funds" error, which means we need some way to make
+            //  SelectCoins pass. So rather than "return false;" as in upstream we
+            //  just turn off bnb and keep going.
+            coin_selection_params.use_bnb = false;
+            coin.m_input_bytes = 0;
+        }
+        coin.effective_value = coin.value - coin_selection_params.effective_fee.GetFee(coin.m_input_bytes);
+        if (coin_selection_params.use_bnb) {
+            value_to_select[coin.asset] -= coin.effective_value;
+        } else {
+            value_to_select[coin.asset] -= coin.value;
+        }
+        setPresetCoins.insert(coin);
     }
 
     // remove preset inputs from vCoins
@@ -2528,7 +2570,6 @@ bool CWallet::SignTransaction(CMutableTransaction& tx)
 bool CWallet::FundTransaction(CMutableTransaction& tx, CAmount& nFeeRet, int& nChangePosInOut, std::string& strFailReason, bool lockUnspents, const std::set<int>& setSubtractFeeFromOutputs, CCoinControl coinControl)
 {
     std::vector<CRecipient> vecSend;
-    std::set<CAsset> setAssets;
 
     // Turn the txout set into a CRecipient vector.
     for (size_t idx = 0; idx < tx.vout.size(); idx++) {
@@ -2540,9 +2581,6 @@ bool CWallet::FundTransaction(CMutableTransaction& tx, CAmount& nFeeRet, int& nC
             return false;
         }
 
-        // Account for the asset in the possible change destinations.
-        setAssets.insert(txOut.nAsset.GetAsset());
-
         // Fee outputs should not be added to avoid overpayment of fees
         if (txOut.IsFee()) {
             continue;
@@ -2892,13 +2930,18 @@ bool CWallet::CreateTransaction(interfaces::Chain::Lock& locked_chain, const std
                 std::vector<COutPoint> vPresetInputs;
                 coin_control.ListSelected(vPresetInputs);
                 for (const COutPoint& presetInput : vPresetInputs) {
+                    CAsset asset;
                     std::map<uint256, CWalletTx>::const_iterator it = mapWallet.find(presetInput.hash);
-                    if (it == mapWallet.end()) {
+                    CTxOut txout;
+                    if (it != mapWallet.end()) {
+                         asset = it->second.GetOutputAsset(presetInput.n);
+                    } else if (coin_control.GetExternalOutput(presetInput, txout)) {
+                        asset = txout.nAsset.GetAsset();
+                    } else {
                         // Ignore this here, will fail more gracefully later.
                         continue;
                     }
 
-                    CAsset asset = it->second.GetOutputAsset(presetInput.n);
                     if (mapScriptChange.find(asset) != mapScriptChange.end()) {
                         // This asset already has a change script.
                         continue;
@@ -3247,9 +3290,9 @@ bool CWallet::CreateTransaction(interfaces::Chain::Lock& locked_chain, const std
                     }
                 }
 
-                nBytes = CalculateMaximumSignedTxSize(CTransaction(txNew), this, coin_control.fAllowWatchOnly);
+                nBytes = CalculateMaximumSignedTxSize(CTransaction(txNew), this, &coin_control);
                 if (nBytes < 0) {
-                    strFailReason = _("Signing transaction failed").translated;
+                    strFailReason = _("Missing solving data for estimating transaction size").translated;
                     return false;
                 }
 
diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h
index e6c36d9a69..2cb8492e8f 100644
--- a/src/wallet/wallet.h
+++ b/src/wallet/wallet.h
@@ -1045,14 +1045,13 @@ public:
      */
     void CommitTransaction(CTransactionRef tx, mapValue_t mapValue, std::vector<std::pair<std::string, std::string>> orderForm, const BlindDetails* blind_details = nullptr);
 
-    bool DummySignTx(CMutableTransaction &txNew, const std::set<CTxOut> &txouts, bool use_max_sig = false) const
+    bool DummySignTx(CMutableTransaction &txNew, const std::set<CTxOut> &txouts, const CCoinControl* coin_control = nullptr) const
     {
         std::vector<CTxOut> v_txouts(txouts.size());
         std::copy(txouts.begin(), txouts.end(), v_txouts.begin());
-        return DummySignTx(txNew, v_txouts, use_max_sig);
+        return DummySignTx(txNew, v_txouts, coin_control);
     }
-    bool DummySignTx(CMutableTransaction &txNew, const std::vector<CTxOut> &txouts, bool use_max_sig = false) const;
-    bool DummySignInput(CMutableTransaction &tx, const size_t nIn, const CTxOut &txout, bool use_max_sig = false) const;
+    bool DummySignTx(CMutableTransaction &txNew, const std::vector<CTxOut> &txouts, const CCoinControl* coin_control = nullptr) const;
 
     bool ImportScripts(const std::set<CScript> scripts, int64_t timestamp) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
     bool ImportPrivKeys(const std::map<CKeyID, CKey>& privkey_map, const int64_t timestamp) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
@@ -1354,8 +1353,6 @@ public:
 
 // Calculate the size of the transaction assuming all signatures are max size
 // Use DummySignatureCreator, which inserts 71 byte signatures everywhere.
-// NOTE: this requires that all inputs must be in mapWallet (eg the tx should
-// be IsAllFromMe).
-int64_t CalculateMaximumSignedTxSize(const CTransaction &tx, const CWallet *wallet, bool use_max_sig = false) EXCLUSIVE_LOCKS_REQUIRED(wallet->cs_wallet);
-int64_t CalculateMaximumSignedTxSize(const CTransaction &tx, const CWallet *wallet, const std::vector<CTxOut>& txouts, bool use_max_sig = false);
+int64_t CalculateMaximumSignedTxSize(const CTransaction &tx, const CWallet *wallet, const CCoinControl* coin_control = nullptr) EXCLUSIVE_LOCKS_REQUIRED(wallet->cs_wallet);
+int64_t CalculateMaximumSignedTxSize(const CTransaction &tx, const CWallet *wallet, const std::vector<CTxOut>& txouts, const CCoinControl* coin_control = nullptr);
 #endif // BITCOIN_WALLET_WALLET_H
diff --git a/test/functional/feature_fedpeg.py b/test/functional/feature_fedpeg.py
index 417b14a481..ab1c29dc15 100755
--- a/test/functional/feature_fedpeg.py
+++ b/test/functional/feature_fedpeg.py
@@ -13,7 +13,8 @@ from test_framework.util import (
     assert_raises_rpc_error,
     assert_equal,
     hex_str_to_bytes,
-    find_vout_for_address
+    find_vout_for_address,
+    assert_greater_than
 )
 from test_framework import util
 from test_framework.messages import (
@@ -317,6 +318,19 @@ class FedPegTest(BitcoinTestFramework):
         fin_psbt = sidechain.finalizepsbt(signed_psbt['psbt'])
         assert_equal(fin_psbt, signed_pegin)
 
+        # Try funding a psbt with the peg-in
+        assert_equal(sidechain.getbalance()['bitcoin'], 50)
+        out_bal = 0
+        outputs.append({sidechain.getnewaddress(): 49.999})
+        for out in outputs:
+            for val in out.values():
+                out_bal += Decimal(val)
+        assert_greater_than(out_bal, 50)
+        pegin_psbt = sidechain.walletcreatefundedpsbt([{"txid":txid1, "vout": vout, "pegin_bitcoin_tx": raw, "pegin_txout_proof": proof, "pegin_claim_script": addrs["claim_script"]}], outputs)
+        signed_psbt = sidechain.walletsignpsbt(pegin_psbt['psbt'])
+        fin_psbt = sidechain.finalizepsbt(signed_psbt['psbt'])
+        assert fin_psbt['complete']
+
         sample_pegin_struct = FromHex(CTransaction(), signed_pegin["hex"])
         # Round-trip peg-in transaction using python serialization
         assert_equal(signed_pegin["hex"], sample_pegin_struct.serialize().hex())
diff --git a/test/functional/rpc_fundrawtransaction.py b/test/functional/rpc_fundrawtransaction.py
index 46b6183dec..37dcc22f01 100755
--- a/test/functional/rpc_fundrawtransaction.py
+++ b/test/functional/rpc_fundrawtransaction.py
@@ -768,6 +768,27 @@ class RawTransactionsTest(BitcoinTestFramework):
         # The total subtracted from the outputs is equal to the fee.
         assert_equal(share[0] + share[2] + share[3], result[0]['fee'])
 
+        n0_blind_addr = self.nodes[0].getnewaddress()
+        addr_info = self.nodes[0].getaddressinfo(n0_blind_addr)
+        txid = self.nodes[2].sendtoaddress(addr_info['unconfidential'], 10)
+        self.sync_all()
+        vout = find_vout_for_address(self.nodes[0], txid, n0_blind_addr)
+        self.nodes[0].generate(1)
+        self.sync_all()
+
+        # An external input without solving data should result in an error
+        raw_tx = self.nodes[2].createrawtransaction([{"txid": txid, "vout": vout}], {addr_info['unconfidential']: 20})
+        assert_raises_rpc_error(-4, "Missing solving data for estimating transaction size", self.nodes[2].fundrawtransaction, raw_tx)
+
+        # But funding should work when the solving data is provided
+        funded_tx = self.nodes[2].fundrawtransaction(raw_tx, {}, False, {"pubkeys": [addr_info['pubkey']]})
+        signed_tx = self.nodes[2].signrawtransactionwithwallet(funded_tx['hex'])
+        assert not signed_tx['complete']
+        signed_tx = self.nodes[0].signrawtransactionwithwallet(signed_tx['hex'])
+        assert signed_tx['complete']
+        # Don't send because we didn't blind it so it's not actually valid.
+        # self.nodes[0].sendrawtransaction(signed_tx['hex'])
+
     def test_subtract_fee_with_presets(self):
         self.log.info("Test fundrawtxn subtract fee from outputs with preset inputs that are sufficient")
 
diff --git a/test/functional/rpc_psbt.py b/test/functional/rpc_psbt.py
index c8188fbc69..727eab2c53 100755
--- a/test/functional/rpc_psbt.py
+++ b/test/functional/rpc_psbt.py
@@ -559,11 +559,6 @@ class PSBTTest(BitcoinTestFramework):
         # Some Confidential-Assets-specific tests
         self.run_ca_tests()
 
-        # Check that peg-ins are disallowed for walletcreatefundedpsbt
-        assert_raises_rpc_error(-8, 'pegin_ arguments provided but this command does not support peg-ins', self.nodes[0].walletcreatefundedpsbt, [{"txid": "0000000000000000000000000000000000000000000000000000000000000000", "vout": 0, "pegin_bitcoin_tx": "00"}], [{self.nodes[0].getnewaddress(): 1}])
-        assert_raises_rpc_error(-8, 'pegin_ arguments provided but this command does not support peg-ins', self.nodes[0].walletcreatefundedpsbt, [{"txid": "0000000000000000000000000000000000000000000000000000000000000000", "vout": 0, "pegin_txout_proof": "00"}], [{self.nodes[0].getnewaddress(): 1}])
-        assert_raises_rpc_error(-8, 'pegin_ arguments provided but this command does not support peg-ins', self.nodes[0].walletcreatefundedpsbt, [{"txid": "0000000000000000000000000000000000000000000000000000000000000000", "vout": 0, "pegin_claim_script": "00"}], [{self.nodes[0].getnewaddress(): 1}])
-
         self.test_utxo_conversion()
 
         # Test that psbts with p2pkh outputs are created properly