psbt.cpp
1 // Copyright (c) 2009-present The Bitcoin Core developers 2 // Distributed under the MIT software license, see the accompanying 3 // file COPYING or http://www.opensource.org/licenses/mit-license.php. 4 5 #include <psbt.h> 6 7 #include <node/types.h> 8 #include <policy/policy.h> 9 #include <script/signingprovider.h> 10 #include <util/check.h> 11 #include <util/strencodings.h> 12 13 PartiallySignedTransaction::PartiallySignedTransaction(const CMutableTransaction& tx) : tx(tx) 14 { 15 inputs.resize(tx.vin.size()); 16 outputs.resize(tx.vout.size()); 17 } 18 19 bool PartiallySignedTransaction::IsNull() const 20 { 21 return !tx && inputs.empty() && outputs.empty() && unknown.empty(); 22 } 23 24 bool PartiallySignedTransaction::Merge(const PartiallySignedTransaction& psbt) 25 { 26 // Prohibited to merge two PSBTs over different transactions 27 if (tx->GetHash() != psbt.tx->GetHash()) { 28 return false; 29 } 30 31 for (unsigned int i = 0; i < inputs.size(); ++i) { 32 inputs[i].Merge(psbt.inputs[i]); 33 } 34 for (unsigned int i = 0; i < outputs.size(); ++i) { 35 outputs[i].Merge(psbt.outputs[i]); 36 } 37 for (auto& xpub_pair : psbt.m_xpubs) { 38 if (m_xpubs.count(xpub_pair.first) == 0) { 39 m_xpubs[xpub_pair.first] = xpub_pair.second; 40 } else { 41 m_xpubs[xpub_pair.first].insert(xpub_pair.second.begin(), xpub_pair.second.end()); 42 } 43 } 44 unknown.insert(psbt.unknown.begin(), psbt.unknown.end()); 45 46 return true; 47 } 48 49 bool PartiallySignedTransaction::AddInput(const CTxIn& txin, PSBTInput& psbtin) 50 { 51 if (std::find(tx->vin.begin(), tx->vin.end(), txin) != tx->vin.end()) { 52 return false; 53 } 54 tx->vin.push_back(txin); 55 psbtin.partial_sigs.clear(); 56 psbtin.final_script_sig.clear(); 57 psbtin.final_script_witness.SetNull(); 58 inputs.push_back(psbtin); 59 return true; 60 } 61 62 bool PartiallySignedTransaction::AddOutput(const CTxOut& txout, const PSBTOutput& psbtout) 63 { 64 tx->vout.push_back(txout); 65 outputs.push_back(psbtout); 66 return true; 67 } 68 69 bool PartiallySignedTransaction::GetInputUTXO(CTxOut& utxo, int input_index) const 70 { 71 const PSBTInput& input = inputs[input_index]; 72 uint32_t prevout_index = tx->vin[input_index].prevout.n; 73 if (input.non_witness_utxo) { 74 if (prevout_index >= input.non_witness_utxo->vout.size()) { 75 return false; 76 } 77 if (input.non_witness_utxo->GetHash() != tx->vin[input_index].prevout.hash) { 78 return false; 79 } 80 utxo = input.non_witness_utxo->vout[prevout_index]; 81 } else if (!input.witness_utxo.IsNull()) { 82 utxo = input.witness_utxo; 83 } else { 84 return false; 85 } 86 return true; 87 } 88 89 bool PSBTInput::IsNull() const 90 { 91 return !non_witness_utxo && witness_utxo.IsNull() && partial_sigs.empty() && unknown.empty() && hd_keypaths.empty() && redeem_script.empty() && witness_script.empty(); 92 } 93 94 void PSBTInput::FillSignatureData(SignatureData& sigdata) const 95 { 96 if (!final_script_sig.empty()) { 97 sigdata.scriptSig = final_script_sig; 98 sigdata.complete = true; 99 } 100 if (!final_script_witness.IsNull()) { 101 sigdata.scriptWitness = final_script_witness; 102 sigdata.complete = true; 103 } 104 if (sigdata.complete) { 105 return; 106 } 107 108 sigdata.signatures.insert(partial_sigs.begin(), partial_sigs.end()); 109 if (!redeem_script.empty()) { 110 sigdata.redeem_script = redeem_script; 111 } 112 if (!witness_script.empty()) { 113 sigdata.witness_script = witness_script; 114 } 115 for (const auto& key_pair : hd_keypaths) { 116 sigdata.misc_pubkeys.emplace(key_pair.first.GetID(), key_pair); 117 } 118 if (!m_tap_key_sig.empty()) { 119 sigdata.taproot_key_path_sig = m_tap_key_sig; 120 } 121 for (const auto& [pubkey_leaf, sig] : m_tap_script_sigs) { 122 sigdata.taproot_script_sigs.emplace(pubkey_leaf, sig); 123 } 124 if (!m_tap_internal_key.IsNull()) { 125 sigdata.tr_spenddata.internal_key = m_tap_internal_key; 126 } 127 if (!m_tap_merkle_root.IsNull()) { 128 sigdata.tr_spenddata.merkle_root = m_tap_merkle_root; 129 } 130 for (const auto& [leaf_script, control_block] : m_tap_scripts) { 131 sigdata.tr_spenddata.scripts.emplace(leaf_script, control_block); 132 } 133 for (const auto& [pubkey, leaf_origin] : m_tap_bip32_paths) { 134 sigdata.taproot_misc_pubkeys.emplace(pubkey, leaf_origin); 135 sigdata.tap_pubkeys.emplace(Hash160(pubkey), pubkey); 136 } 137 for (const auto& [hash, preimage] : ripemd160_preimages) { 138 sigdata.ripemd160_preimages.emplace(std::vector<unsigned char>(hash.begin(), hash.end()), preimage); 139 } 140 for (const auto& [hash, preimage] : sha256_preimages) { 141 sigdata.sha256_preimages.emplace(std::vector<unsigned char>(hash.begin(), hash.end()), preimage); 142 } 143 for (const auto& [hash, preimage] : hash160_preimages) { 144 sigdata.hash160_preimages.emplace(std::vector<unsigned char>(hash.begin(), hash.end()), preimage); 145 } 146 for (const auto& [hash, preimage] : hash256_preimages) { 147 sigdata.hash256_preimages.emplace(std::vector<unsigned char>(hash.begin(), hash.end()), preimage); 148 } 149 } 150 151 void PSBTInput::FromSignatureData(const SignatureData& sigdata) 152 { 153 if (sigdata.complete) { 154 partial_sigs.clear(); 155 hd_keypaths.clear(); 156 redeem_script.clear(); 157 witness_script.clear(); 158 159 if (!sigdata.scriptSig.empty()) { 160 final_script_sig = sigdata.scriptSig; 161 } 162 if (!sigdata.scriptWitness.IsNull()) { 163 final_script_witness = sigdata.scriptWitness; 164 } 165 return; 166 } 167 168 partial_sigs.insert(sigdata.signatures.begin(), sigdata.signatures.end()); 169 if (redeem_script.empty() && !sigdata.redeem_script.empty()) { 170 redeem_script = sigdata.redeem_script; 171 } 172 if (witness_script.empty() && !sigdata.witness_script.empty()) { 173 witness_script = sigdata.witness_script; 174 } 175 for (const auto& entry : sigdata.misc_pubkeys) { 176 hd_keypaths.emplace(entry.second); 177 } 178 if (!sigdata.taproot_key_path_sig.empty()) { 179 m_tap_key_sig = sigdata.taproot_key_path_sig; 180 } 181 for (const auto& [pubkey_leaf, sig] : sigdata.taproot_script_sigs) { 182 m_tap_script_sigs.emplace(pubkey_leaf, sig); 183 } 184 if (!sigdata.tr_spenddata.internal_key.IsNull()) { 185 m_tap_internal_key = sigdata.tr_spenddata.internal_key; 186 } 187 if (!sigdata.tr_spenddata.merkle_root.IsNull()) { 188 m_tap_merkle_root = sigdata.tr_spenddata.merkle_root; 189 } 190 for (const auto& [leaf_script, control_block] : sigdata.tr_spenddata.scripts) { 191 m_tap_scripts.emplace(leaf_script, control_block); 192 } 193 for (const auto& [pubkey, leaf_origin] : sigdata.taproot_misc_pubkeys) { 194 m_tap_bip32_paths.emplace(pubkey, leaf_origin); 195 } 196 } 197 198 void PSBTInput::Merge(const PSBTInput& input) 199 { 200 if (!non_witness_utxo && input.non_witness_utxo) non_witness_utxo = input.non_witness_utxo; 201 if (witness_utxo.IsNull() && !input.witness_utxo.IsNull()) { 202 witness_utxo = input.witness_utxo; 203 } 204 205 partial_sigs.insert(input.partial_sigs.begin(), input.partial_sigs.end()); 206 ripemd160_preimages.insert(input.ripemd160_preimages.begin(), input.ripemd160_preimages.end()); 207 sha256_preimages.insert(input.sha256_preimages.begin(), input.sha256_preimages.end()); 208 hash160_preimages.insert(input.hash160_preimages.begin(), input.hash160_preimages.end()); 209 hash256_preimages.insert(input.hash256_preimages.begin(), input.hash256_preimages.end()); 210 hd_keypaths.insert(input.hd_keypaths.begin(), input.hd_keypaths.end()); 211 unknown.insert(input.unknown.begin(), input.unknown.end()); 212 m_tap_script_sigs.insert(input.m_tap_script_sigs.begin(), input.m_tap_script_sigs.end()); 213 m_tap_scripts.insert(input.m_tap_scripts.begin(), input.m_tap_scripts.end()); 214 m_tap_bip32_paths.insert(input.m_tap_bip32_paths.begin(), input.m_tap_bip32_paths.end()); 215 216 if (redeem_script.empty() && !input.redeem_script.empty()) redeem_script = input.redeem_script; 217 if (witness_script.empty() && !input.witness_script.empty()) witness_script = input.witness_script; 218 if (final_script_sig.empty() && !input.final_script_sig.empty()) final_script_sig = input.final_script_sig; 219 if (final_script_witness.IsNull() && !input.final_script_witness.IsNull()) final_script_witness = input.final_script_witness; 220 if (m_tap_key_sig.empty() && !input.m_tap_key_sig.empty()) m_tap_key_sig = input.m_tap_key_sig; 221 if (m_tap_internal_key.IsNull() && !input.m_tap_internal_key.IsNull()) m_tap_internal_key = input.m_tap_internal_key; 222 if (m_tap_merkle_root.IsNull() && !input.m_tap_merkle_root.IsNull()) m_tap_merkle_root = input.m_tap_merkle_root; 223 } 224 225 void PSBTOutput::FillSignatureData(SignatureData& sigdata) const 226 { 227 if (!redeem_script.empty()) { 228 sigdata.redeem_script = redeem_script; 229 } 230 if (!witness_script.empty()) { 231 sigdata.witness_script = witness_script; 232 } 233 for (const auto& key_pair : hd_keypaths) { 234 sigdata.misc_pubkeys.emplace(key_pair.first.GetID(), key_pair); 235 } 236 if (!m_tap_tree.empty() && m_tap_internal_key.IsFullyValid()) { 237 TaprootBuilder builder; 238 for (const auto& [depth, leaf_ver, script] : m_tap_tree) { 239 builder.Add((int)depth, script, (int)leaf_ver, /*track=*/true); 240 } 241 assert(builder.IsComplete()); 242 builder.Finalize(m_tap_internal_key); 243 TaprootSpendData spenddata = builder.GetSpendData(); 244 245 sigdata.tr_spenddata.internal_key = m_tap_internal_key; 246 sigdata.tr_spenddata.Merge(spenddata); 247 } 248 for (const auto& [pubkey, leaf_origin] : m_tap_bip32_paths) { 249 sigdata.taproot_misc_pubkeys.emplace(pubkey, leaf_origin); 250 sigdata.tap_pubkeys.emplace(Hash160(pubkey), pubkey); 251 } 252 } 253 254 void PSBTOutput::FromSignatureData(const SignatureData& sigdata) 255 { 256 if (redeem_script.empty() && !sigdata.redeem_script.empty()) { 257 redeem_script = sigdata.redeem_script; 258 } 259 if (witness_script.empty() && !sigdata.witness_script.empty()) { 260 witness_script = sigdata.witness_script; 261 } 262 for (const auto& entry : sigdata.misc_pubkeys) { 263 hd_keypaths.emplace(entry.second); 264 } 265 if (!sigdata.tr_spenddata.internal_key.IsNull()) { 266 m_tap_internal_key = sigdata.tr_spenddata.internal_key; 267 } 268 if (sigdata.tr_builder.has_value() && sigdata.tr_builder->HasScripts()) { 269 m_tap_tree = sigdata.tr_builder->GetTreeTuples(); 270 } 271 for (const auto& [pubkey, leaf_origin] : sigdata.taproot_misc_pubkeys) { 272 m_tap_bip32_paths.emplace(pubkey, leaf_origin); 273 } 274 } 275 276 bool PSBTOutput::IsNull() const 277 { 278 return redeem_script.empty() && witness_script.empty() && hd_keypaths.empty() && unknown.empty(); 279 } 280 281 void PSBTOutput::Merge(const PSBTOutput& output) 282 { 283 hd_keypaths.insert(output.hd_keypaths.begin(), output.hd_keypaths.end()); 284 unknown.insert(output.unknown.begin(), output.unknown.end()); 285 m_tap_bip32_paths.insert(output.m_tap_bip32_paths.begin(), output.m_tap_bip32_paths.end()); 286 287 if (redeem_script.empty() && !output.redeem_script.empty()) redeem_script = output.redeem_script; 288 if (witness_script.empty() && !output.witness_script.empty()) witness_script = output.witness_script; 289 if (m_tap_internal_key.IsNull() && !output.m_tap_internal_key.IsNull()) m_tap_internal_key = output.m_tap_internal_key; 290 if (m_tap_tree.empty() && !output.m_tap_tree.empty()) m_tap_tree = output.m_tap_tree; 291 } 292 293 bool PSBTInputSigned(const PSBTInput& input) 294 { 295 return !input.final_script_sig.empty() || !input.final_script_witness.IsNull(); 296 } 297 298 bool PSBTInputSignedAndVerified(const PartiallySignedTransaction psbt, unsigned int input_index, const PrecomputedTransactionData* txdata) 299 { 300 CTxOut utxo; 301 assert(psbt.inputs.size() >= input_index); 302 const PSBTInput& input = psbt.inputs[input_index]; 303 304 if (input.non_witness_utxo) { 305 // If we're taking our information from a non-witness UTXO, verify that it matches the prevout. 306 COutPoint prevout = psbt.tx->vin[input_index].prevout; 307 if (prevout.n >= input.non_witness_utxo->vout.size()) { 308 return false; 309 } 310 if (input.non_witness_utxo->GetHash() != prevout.hash) { 311 return false; 312 } 313 utxo = input.non_witness_utxo->vout[prevout.n]; 314 } else if (!input.witness_utxo.IsNull()) { 315 utxo = input.witness_utxo; 316 } else { 317 return false; 318 } 319 320 if (txdata) { 321 return VerifyScript(input.final_script_sig, utxo.scriptPubKey, &input.final_script_witness, STANDARD_SCRIPT_VERIFY_FLAGS, MutableTransactionSignatureChecker{&(*psbt.tx), input_index, utxo.nValue, *txdata, MissingDataBehavior::FAIL}); 322 } else { 323 return VerifyScript(input.final_script_sig, utxo.scriptPubKey, &input.final_script_witness, STANDARD_SCRIPT_VERIFY_FLAGS, MutableTransactionSignatureChecker{&(*psbt.tx), input_index, utxo.nValue, MissingDataBehavior::FAIL}); 324 } 325 } 326 327 size_t CountPSBTUnsignedInputs(const PartiallySignedTransaction& psbt) { 328 size_t count = 0; 329 for (const auto& input : psbt.inputs) { 330 if (!PSBTInputSigned(input)) { 331 count++; 332 } 333 } 334 335 return count; 336 } 337 338 void UpdatePSBTOutput(const SigningProvider& provider, PartiallySignedTransaction& psbt, int index) 339 { 340 CMutableTransaction& tx = *Assert(psbt.tx); 341 const CTxOut& out = tx.vout.at(index); 342 PSBTOutput& psbt_out = psbt.outputs.at(index); 343 344 // Fill a SignatureData with output info 345 SignatureData sigdata; 346 psbt_out.FillSignatureData(sigdata); 347 348 // Construct a would-be spend of this output, to update sigdata with. 349 // Note that ProduceSignature is used to fill in metadata (not actual signatures), 350 // so provider does not need to provide any private keys (it can be a HidingSigningProvider). 351 MutableTransactionSignatureCreator creator(tx, /*input_idx=*/0, out.nValue, SIGHASH_ALL); 352 ProduceSignature(provider, creator, out.scriptPubKey, sigdata); 353 354 // Put redeem_script, witness_script, key paths, into PSBTOutput. 355 psbt_out.FromSignatureData(sigdata); 356 } 357 358 PrecomputedTransactionData PrecomputePSBTData(const PartiallySignedTransaction& psbt) 359 { 360 const CMutableTransaction& tx = *psbt.tx; 361 bool have_all_spent_outputs = true; 362 std::vector<CTxOut> utxos(tx.vin.size()); 363 for (size_t idx = 0; idx < tx.vin.size(); ++idx) { 364 if (!psbt.GetInputUTXO(utxos[idx], idx)) have_all_spent_outputs = false; 365 } 366 PrecomputedTransactionData txdata; 367 if (have_all_spent_outputs) { 368 txdata.Init(tx, std::move(utxos), true); 369 } else { 370 txdata.Init(tx, {}, true); 371 } 372 return txdata; 373 } 374 375 bool SignPSBTInput(const SigningProvider& provider, PartiallySignedTransaction& psbt, int index, const PrecomputedTransactionData* txdata, int sighash, SignatureData* out_sigdata, bool finalize) 376 { 377 PSBTInput& input = psbt.inputs.at(index); 378 const CMutableTransaction& tx = *psbt.tx; 379 380 if (PSBTInputSignedAndVerified(psbt, index, txdata)) { 381 return true; 382 } 383 384 // Fill SignatureData with input info 385 SignatureData sigdata; 386 input.FillSignatureData(sigdata); 387 388 // Get UTXO 389 bool require_witness_sig = false; 390 CTxOut utxo; 391 392 if (input.non_witness_utxo) { 393 // If we're taking our information from a non-witness UTXO, verify that it matches the prevout. 394 COutPoint prevout = tx.vin[index].prevout; 395 if (prevout.n >= input.non_witness_utxo->vout.size()) { 396 return false; 397 } 398 if (input.non_witness_utxo->GetHash() != prevout.hash) { 399 return false; 400 } 401 utxo = input.non_witness_utxo->vout[prevout.n]; 402 } else if (!input.witness_utxo.IsNull()) { 403 utxo = input.witness_utxo; 404 // When we're taking our information from a witness UTXO, we can't verify it is actually data from 405 // the output being spent. This is safe in case a witness signature is produced (which includes this 406 // information directly in the hash), but not for non-witness signatures. Remember that we require 407 // a witness signature in this situation. 408 require_witness_sig = true; 409 } else { 410 return false; 411 } 412 413 sigdata.witness = false; 414 bool sig_complete; 415 if (txdata == nullptr) { 416 sig_complete = ProduceSignature(provider, DUMMY_SIGNATURE_CREATOR, utxo.scriptPubKey, sigdata); 417 } else { 418 MutableTransactionSignatureCreator creator(tx, index, utxo.nValue, txdata, sighash); 419 sig_complete = ProduceSignature(provider, creator, utxo.scriptPubKey, sigdata); 420 } 421 // Verify that a witness signature was produced in case one was required. 422 if (require_witness_sig && !sigdata.witness) return false; 423 424 // If we are not finalizing, set sigdata.complete to false to not set the scriptWitness 425 if (!finalize && sigdata.complete) sigdata.complete = false; 426 427 input.FromSignatureData(sigdata); 428 429 // If we have a witness signature, put a witness UTXO. 430 if (sigdata.witness) { 431 input.witness_utxo = utxo; 432 // We can remove the non_witness_utxo if and only if there are no non-segwit or segwit v0 433 // inputs in this transaction. Since this requires inspecting the entire transaction, this 434 // is something for the caller to deal with (i.e. FillPSBT). 435 } 436 437 // Fill in the missing info 438 if (out_sigdata) { 439 out_sigdata->missing_pubkeys = sigdata.missing_pubkeys; 440 out_sigdata->missing_sigs = sigdata.missing_sigs; 441 out_sigdata->missing_redeem_script = sigdata.missing_redeem_script; 442 out_sigdata->missing_witness_script = sigdata.missing_witness_script; 443 } 444 445 return sig_complete; 446 } 447 448 void RemoveUnnecessaryTransactions(PartiallySignedTransaction& psbtx, const int& sighash_type) 449 { 450 // Only drop non_witness_utxos if sighash_type != SIGHASH_ANYONECANPAY 451 if ((sighash_type & 0x80) != SIGHASH_ANYONECANPAY) { 452 // Figure out if any non_witness_utxos should be dropped 453 std::vector<unsigned int> to_drop; 454 for (unsigned int i = 0; i < psbtx.inputs.size(); ++i) { 455 const auto& input = psbtx.inputs.at(i); 456 int wit_ver; 457 std::vector<unsigned char> wit_prog; 458 if (input.witness_utxo.IsNull() || !input.witness_utxo.scriptPubKey.IsWitnessProgram(wit_ver, wit_prog)) { 459 // There's a non-segwit input or Segwit v0, so we cannot drop any witness_utxos 460 to_drop.clear(); 461 break; 462 } 463 if (wit_ver == 0) { 464 // Segwit v0, so we cannot drop any non_witness_utxos 465 to_drop.clear(); 466 break; 467 } 468 if (input.non_witness_utxo) { 469 to_drop.push_back(i); 470 } 471 } 472 473 // Drop the non_witness_utxos that we can drop 474 for (unsigned int i : to_drop) { 475 psbtx.inputs.at(i).non_witness_utxo = nullptr; 476 } 477 } 478 } 479 480 bool FinalizePSBT(PartiallySignedTransaction& psbtx) 481 { 482 // Finalize input signatures -- in case we have partial signatures that add up to a complete 483 // signature, but have not combined them yet (e.g. because the combiner that created this 484 // PartiallySignedTransaction did not understand them), this will combine them into a final 485 // script. 486 bool complete = true; 487 const PrecomputedTransactionData txdata = PrecomputePSBTData(psbtx); 488 for (unsigned int i = 0; i < psbtx.tx->vin.size(); ++i) { 489 complete &= SignPSBTInput(DUMMY_SIGNING_PROVIDER, psbtx, i, &txdata, SIGHASH_ALL, nullptr, true); 490 } 491 492 return complete; 493 } 494 495 bool FinalizeAndExtractPSBT(PartiallySignedTransaction& psbtx, CMutableTransaction& result) 496 { 497 // It's not safe to extract a PSBT that isn't finalized, and there's no easy way to check 498 // whether a PSBT is finalized without finalizing it, so we just do this. 499 if (!FinalizePSBT(psbtx)) { 500 return false; 501 } 502 503 result = *psbtx.tx; 504 for (unsigned int i = 0; i < result.vin.size(); ++i) { 505 result.vin[i].scriptSig = psbtx.inputs[i].final_script_sig; 506 result.vin[i].scriptWitness = psbtx.inputs[i].final_script_witness; 507 } 508 return true; 509 } 510 511 bool CombinePSBTs(PartiallySignedTransaction& out, const std::vector<PartiallySignedTransaction>& psbtxs) 512 { 513 out = psbtxs[0]; // Copy the first one 514 515 // Merge 516 for (auto it = std::next(psbtxs.begin()); it != psbtxs.end(); ++it) { 517 if (!out.Merge(*it)) { 518 return false; 519 } 520 } 521 return true; 522 } 523 524 std::string PSBTRoleName(PSBTRole role) { 525 switch (role) { 526 case PSBTRole::CREATOR: return "creator"; 527 case PSBTRole::UPDATER: return "updater"; 528 case PSBTRole::SIGNER: return "signer"; 529 case PSBTRole::FINALIZER: return "finalizer"; 530 case PSBTRole::EXTRACTOR: return "extractor"; 531 // no default case, so the compiler can warn about missing cases 532 } 533 assert(false); 534 } 535 536 bool DecodeBase64PSBT(PartiallySignedTransaction& psbt, const std::string& base64_tx, std::string& error) 537 { 538 auto tx_data = DecodeBase64(base64_tx); 539 if (!tx_data) { 540 error = "invalid base64"; 541 return false; 542 } 543 return DecodeRawPSBT(psbt, MakeByteSpan(*tx_data), error); 544 } 545 546 bool DecodeRawPSBT(PartiallySignedTransaction& psbt, std::span<const std::byte> tx_data, std::string& error) 547 { 548 DataStream ss_data{tx_data}; 549 try { 550 ss_data >> psbt; 551 if (!ss_data.empty()) { 552 error = "extra data after PSBT"; 553 return false; 554 } 555 } catch (const std::exception& e) { 556 error = e.what(); 557 return false; 558 } 559 return true; 560 } 561 562 uint32_t PartiallySignedTransaction::GetVersion() const 563 { 564 if (m_version != std::nullopt) { 565 return *m_version; 566 } 567 return 0; 568 }