Bitcoin Core 32.99.0
P2P Digital Currency
Loading...
Searching...
No Matches
psbt_tests.cpp
Go to the documentation of this file.
1// Copyright (c) 2022 The Bitcoin Core developers
2// Distributed under the MIT software license, see the accompanying
3// file COPYING or https://www.opensource.org/licenses/mit-license.php.
4
5#include <addresstype.h>
6#include <key.h>
7#include <psbt.h>
8#include <script/descriptor.h>
9#include <script/script.h>
10#include <script/signingprovider.h>
11#include <script/solver.h>
12#include <test/util/common.h>
13#include <test/util/setup_common.h>
14#include <util/strencodings.h>
15#include <util/string.h>
16
17#include <boost/test/unit_test.hpp>
18
19#include <cstddef>
20#include <string>
21#include <vector>
22
23BOOST_FIXTURE_TEST_SUITE(psbt_tests, BasicTestingSetup)
24
25// Bit positions in BIP 370's transaction modifiable flags.
26static constexpr std::size_t INPUTS_MODIFIABLE{0};
27static constexpr std::size_t OUTPUTS_MODIFIABLE{1};
28static constexpr std::size_t HAS_SIGHASH_SINGLE{2};
29
30static PSBTProprietary MakeProprietary(uint64_t subtype, uint8_t key_data, uint8_t value)
31{
32 return PSBTProprietary{
33 .subtype = subtype,
34 .identifier = {'p', 's', 'b', 't'},
35 .key = {key_data},
36 .value = {value},
37 };
38}
39
40void CheckTimeLock(const std::string& base64_psbt, std::optional<uint32_t> timelock)
41{
42 util::Result<PartiallySignedTransaction> psbt = DecodeBase64PSBT(base64_psbt);
43 BOOST_CHECK(psbt);
44
45 std::optional<uint32_t> computed_timelock = psbt->ComputeTimeLock();
46 std::optional<CMutableTransaction> tx = psbt->GetUnsignedTx();
47 if (timelock) {
48 BOOST_CHECK(computed_timelock);
49 BOOST_CHECK_EQUAL(*computed_timelock, *timelock);
50 BOOST_CHECK(tx);
51 BOOST_CHECK_EQUAL(tx->nLockTime, *timelock);
52 } else {
53 BOOST_CHECK(!computed_timelock);
54 BOOST_CHECK(!tx);
55 }
56}
57
58BOOST_AUTO_TEST_CASE(psbt2_timelock_test)
59{
60 CheckTimeLock("cHNidP8BAgQCAAAAAQQBAQEFAQIB+wQCAAAAAAEOIAsK2SFBnByHGXNdctxzn56p4GONH+TB7vD5lECEgV/IAQ8EAAAAAAABAwgACK8vAAAAAAEEFgAUxDD2TEdW2jENvRoIVXLvKZkmJywAAQMIi73rCwAAAAABBBYAFE3Rk6yWSlasG54cyoRU/i9HT4UTAA==", 0);
61 CheckTimeLock("cHNidP8BAgQCAAAAAQMEAAAAAAEEAQIBBQEBAfsEAgAAAAABDiAPdY2/vU2nwWyKMwnDyB4RAPVh6mRttbAXUsSF4b3enwEPBAEAAAAAAQ4gOhs7PIN9ZInqejHY5sfdUDwAG+8+BpWOdXSAjWjKeKUBDwQAAAAAAAEDCE+TNXcAAAAAAQQWABQLE1LKzQPPaqG388jWOIZxs0peEQA=", 0);
62 CheckTimeLock("cHNidP8BAgQCAAAAAQMEAAAAAAEEAQIBBQEBAfsEAgAAAAABDiAPdY2/vU2nwWyKMwnDyB4RAPVh6mRttbAXUsSF4b3enwEPBAEAAAABEgQQJwAAAAEOIDobOzyDfWSJ6nox2ObH3VA8ABvvPgaVjnV0gI1oynilAQ8EAAAAAAABAwhPkzV3AAAAAAEEFgAUCxNSys0Dz2qht/PI1jiGcbNKXhEA", 10000);
63 CheckTimeLock("cHNidP8BAgQCAAAAAQMEAAAAAAEEAQIBBQEBAfsEAgAAAAABDiAPdY2/vU2nwWyKMwnDyB4RAPVh6mRttbAXUsSF4b3enwEPBAEAAAABEgQQJwAAAAEOIDobOzyDfWSJ6nox2ObH3VA8ABvvPgaVjnV0gI1oynilAQ8EAAAAAAESBCgjAAAAAQMIT5M1dwAAAAABBBYAFAsTUsrNA89qobfzyNY4hnGzSl4RAA==", 10000);
64 CheckTimeLock("cHNidP8BAgQCAAAAAQMEAAAAAAEEAQIBBQEBAfsEAgAAAAABDiAPdY2/vU2nwWyKMwnDyB4RAPVh6mRttbAXUsSF4b3enwEPBAEAAAABEgQQJwAAAAEOIDobOzyDfWSJ6nox2ObH3VA8ABvvPgaVjnV0gI1oynilAQ8EAAAAAAERBIyNxGIBEgQoIwAAAAEDCE+TNXcAAAAAAQQWABQLE1LKzQPPaqG388jWOIZxs0peEQA=", 10000);
65 CheckTimeLock("cHNidP8BAgQCAAAAAQMEAAAAAAEEAQIBBQEBAfsEAgAAAAABDiAPdY2/vU2nwWyKMwnDyB4RAPVh6mRttbAXUsSF4b3enwEPBAEAAAABEQSLjcRiARIEECcAAAABDiA6Gzs8g31kiep6Mdjmx91QPAAb7z4GlY51dICNaMp4pQEPBAAAAAABEQSMjcRiARIEKCMAAAABAwhPkzV3AAAAAAEEFgAUCxNSys0Dz2qht/PI1jiGcbNKXhEA", 10000);
66 CheckTimeLock("cHNidP8BAgQCAAAAAQMEAAAAAAEEAQIBBQEBAfsEAgAAAAABDiAPdY2/vU2nwWyKMwnDyB4RAPVh6mRttbAXUsSF4b3enwEPBAEAAAABEQSLjcRiAAEOIDobOzyDfWSJ6nox2ObH3VA8ABvvPgaVjnV0gI1oynilAQ8EAAAAAAERBIyNxGIBEgQoIwAAAAEDCE+TNXcAAAAAAQQWABQLE1LKzQPPaqG388jWOIZxs0peEQA=", 1657048460);
67 CheckTimeLock("cHNidP8BAgQCAAAAAQMEAAAAAAEEAQIBBQEBAfsEAgAAAAABDiAPdY2/vU2nwWyKMwnDyB4RAPVh6mRttbAXUsSF4b3enwEPBAEAAAABEQSLjcRiARIEECcAAAABDiA6Gzs8g31kiep6Mdjmx91QPAAb7z4GlY51dICNaMp4pQEPBAAAAAABEQSMjcRiAAEDCE+TNXcAAAAAAQQWABQLE1LKzQPPaqG388jWOIZxs0peEQA=", 1657048460);
68 CheckTimeLock("cHNidP8BAgQCAAAAAQMEAAAAAAEEAQIBBQEBAfsEAgAAAAABDiAPdY2/vU2nwWyKMwnDyB4RAPVh6mRttbAXUsSF4b3enwEPBAEAAAAAAQ4gOhs7PIN9ZInqejHY5sfdUDwAG+8+BpWOdXSAjWjKeKUBDwQAAAAAAREEjI3EYgABAwhPkzV3AAAAAAEEFgAUCxNSys0Dz2qht/PI1jiGcbNKXhEA", 1657048460);
69 CheckTimeLock("cHNidP8BAgQCAAAAAQMEAAAAAAEEAQIBBQEBAfsEAgAAAAABDiAPdY2/vU2nwWyKMwnDyB4RAPVh6mRttbAXUsSF4b3enwEPBAEAAAABEgQQJwAAAAEOIDobOzyDfWSJ6nox2ObH3VA8ABvvPgaVjnV0gI1oynilAQ8EAAAAAAERBIyNxGIAAQMIT5M1dwAAAAABBBYAFAsTUsrNA89qobfzyNY4hnGzSl4RAA==", std::nullopt);
70 CheckTimeLock("cHNidP8BAgQCAAAAAQMEAAAAAAEEAQIBBQEBAfsEAgAAAAABDiA6Gzs8g31kiep6Mdjmx91QPAAb7z4GlY51dICNaMp4pQEPBAAAAAABEQSMjcRiAAEOIA91jb+9TafBbIozCcPIHhEA9WHqZG21sBdSxIXhvd6fAQ8EAQAAAAESBBAnAAAAAQMIT5M1dwAAAAABBBYAFAsTUsrNA89qobfzyNY4hnGzSl4RAA==", std::nullopt);
71}
72
73BOOST_AUTO_TEST_CASE(psbt2_addinput)
74{
75 FastRandomContext rng(/*fDeterministic=*/true);
76
77 CMutableTransaction mtx;
78 PartiallySignedTransaction psbt(mtx, /*version=*/2);
79 psbt.m_tx_modifiable.emplace();
80 psbt.m_tx_modifiable->set(INPUTS_MODIFIABLE);
81 BOOST_CHECK_EQUAL(psbt.inputs.size(), 0);
82
83 // Same PSBT version is required
84 uint256 txid;
85 rng.fillrand(MakeWritableByteSpan(txid));
86 PSBTInput psbtin_v0(/*psbt_version=*/0, Txid::FromUint256(txid), /*prev_out=*/0);
87 BOOST_CHECK(!psbt.AddInput(psbtin_v0));
88 BOOST_CHECK_EQUAL(psbt.inputs.size(), 0);
89 rng.fillrand(MakeWritableByteSpan(txid));
90 PSBTInput psbtin(/*psbt_version=*/2, Txid::FromUint256(txid), /*prev_out=*/0);
91 BOOST_CHECK(psbt.AddInput(psbtin));
92 BOOST_CHECK_EQUAL(psbt.inputs.size(), 1);
93
94 // Duplicates are not allowed
95 BOOST_CHECK(!psbt.AddInput(psbtin));
96 BOOST_CHECK_EQUAL(psbt.inputs.size(), 1);
97
98 // Input with a unique txid is allowed
99 rng.fillrand(MakeWritableByteSpan(txid));
100 PSBTInput psbtin2(/*psbt_version=*/2, Txid::FromUint256(txid), /*prev_out=*/0);
101 BOOST_CHECK(psbt.AddInput(psbtin2));
102 BOOST_CHECK_EQUAL(psbt.inputs.size(), 2);
103
104 // Disabling inputs modifiable flag prevents adding new inputs
105 psbt.m_tx_modifiable->reset(INPUTS_MODIFIABLE);
106 rng.fillrand(MakeWritableByteSpan(txid));
107 PSBTInput psbtin3(/*psbt_version=*/2, Txid::FromUint256(txid), /*prev_out=*/0);
108 BOOST_CHECK(!psbt.AddInput(psbtin3));
109 BOOST_CHECK_EQUAL(psbt.inputs.size(), 2);
110 psbt.m_tx_modifiable->set(INPUTS_MODIFIABLE);
111
112 // Make sure that timelock compatibility checks are working
113 // No previous required timelocks, new input with both height and time timelocks is allowed
114 rng.fillrand(MakeWritableByteSpan(txid));
115 PSBTInput psbtin4(/*psbt_version=*/2, Txid::FromUint256(txid), /*prev_out=*/0);
116 psbtin4.time_locktime = LOCKTIME_THRESHOLD;
117 psbtin4.height_locktime = 100;
118 BOOST_CHECK(psbt.AddInput(psbtin4));
119 BOOST_CHECK_EQUAL(psbt.inputs.size(), 3);
120
121 // Input with only a time timelock is allowed
122 rng.fillrand(MakeWritableByteSpan(txid));
123 PSBTInput psbtin5(/*psbt_version=*/2, Txid::FromUint256(txid), /*prev_out=*/0);
124 psbtin5.time_locktime = LOCKTIME_THRESHOLD + 1;
125 BOOST_CHECK(psbt.AddInput(psbtin5));
126 BOOST_CHECK_EQUAL(psbt.inputs.size(), 4);
127
128 // Input with only a height timelock is not allowed because of previous
129 rng.fillrand(MakeWritableByteSpan(txid));
130 PSBTInput psbtin6(/*psbt_version=*/2, Txid::FromUint256(txid), /*prev_out=*/0);
131 psbtin6.height_locktime = 100;
132 BOOST_CHECK(!psbt.AddInput(psbtin6));
133 BOOST_CHECK_EQUAL(psbt.inputs.size(), 4);
134
135 // Adding an input that already has a signature is allowed
136 rng.fillrand(MakeWritableByteSpan(txid));
137 PSBTInput psbtin7(/*psbt_version=*/2, Txid::FromUint256(txid), /*prev_out=*/0);
138 psbtin7.final_script_sig << OP_1;
139 BOOST_CHECK(psbt.AddInput(psbtin7));
140 BOOST_CHECK_EQUAL(psbt.inputs.size(), 5);
141
142 // Same thing, but with other things that have signatures
143 psbtin7.final_script_sig.clear();
144 psbtin7.final_script_witness.stack.emplace_back();
145 BOOST_CHECK(!psbt.AddInput(psbtin7));
146 BOOST_CHECK_EQUAL(psbt.inputs.size(), 5);
147 psbtin7.final_script_witness.SetNull();
148 psbtin7.partial_sigs.emplace();
149 BOOST_CHECK(!psbt.AddInput(psbtin7));
150 BOOST_CHECK_EQUAL(psbt.inputs.size(), 5);
151 psbtin7.partial_sigs.clear();
152 psbtin7.m_tap_key_sig.push_back(0);
153 BOOST_CHECK(!psbt.AddInput(psbtin7));
154 BOOST_CHECK_EQUAL(psbt.inputs.size(), 5);
155 psbtin7.m_tap_key_sig.clear();
156 psbtin7.m_tap_script_sigs.emplace();
157 BOOST_CHECK(!psbt.AddInput(psbtin7));
158 BOOST_CHECK_EQUAL(psbt.inputs.size(), 5);
159 psbtin7.m_tap_script_sigs.clear();
160 psbtin7.m_musig2_partial_sigs.emplace();
161 BOOST_CHECK(!psbt.AddInput(psbtin7));
162 BOOST_CHECK_EQUAL(psbt.inputs.size(), 5);
163
164 // Adding an input that changes the timelock is no longer allowed
165 rng.fillrand(MakeWritableByteSpan(txid));
166 PSBTInput psbtin8(/*psbt_version=*/2, Txid::FromUint256(txid), /*prev_out=*/0);
167 psbtin8.time_locktime = LOCKTIME_THRESHOLD + 2;
168 BOOST_CHECK(!psbt.AddInput(psbtin8));
169 BOOST_CHECK_EQUAL(psbt.inputs.size(), 5);
170}
171
172BOOST_AUTO_TEST_CASE(psbt2_addoutput)
173{
174 CMutableTransaction mtx;
175 PartiallySignedTransaction psbt(mtx, /*version=*/2);
176 psbt.m_tx_modifiable.emplace();
177 psbt.m_tx_modifiable->set(OUTPUTS_MODIFIABLE);
178 BOOST_CHECK_EQUAL(psbt.outputs.size(), 0);
179
180 // Same PSBT version is required
181 PSBTOutput psbtout_v0(/*psbt_version=*/0, /*amount=*/1, CScript());
182 BOOST_CHECK(!psbt.AddOutput(psbtout_v0));
183 BOOST_CHECK_EQUAL(psbt.outputs.size(), 0);
184 PSBTOutput psbtout(/*psbt_version=*/2, /*amount=*/1, CScript());
185 BOOST_CHECK(psbt.AddOutput(psbtout));
186 BOOST_CHECK_EQUAL(psbt.outputs.size(), 1);
187
188 // Disabling outputs modifiable flag prevents adding new outputs
189 psbt.m_tx_modifiable->reset(OUTPUTS_MODIFIABLE);
190 PSBTOutput psbtout2(/*psbt_version=*/2, /*amount=*/1, CScript());
191 BOOST_CHECK(!psbt.AddOutput(psbtout2));
192 BOOST_CHECK_EQUAL(psbt.outputs.size(), 1);
193 psbt.m_tx_modifiable->set(OUTPUTS_MODIFIABLE);
194 PSBTOutput psbtout3(/*psbt_version=*/2, /*amount=*/1, CScript());
195 BOOST_CHECK(psbt.AddOutput(psbtout3));
196 BOOST_CHECK_EQUAL(psbt.outputs.size(), 2);
197}
198
199BOOST_AUTO_TEST_CASE(merge_proprietary_fields)
200{
201 CMutableTransaction tx;
202 tx.vin.emplace_back(COutPoint{});
203 tx.vout.emplace_back(0, CScript{});
204
205 PartiallySignedTransaction left(tx, /*version=*/2);
206 PartiallySignedTransaction right(tx, /*version=*/2);
207
208 const auto left_prop = MakeProprietary(/*subtype=*/1, /*key_data=*/0x01, /*value=*/0xaa);
209 const auto right_prop = MakeProprietary(/*subtype=*/2, /*key_data=*/0x02, /*value=*/0xbb);
210
211 left.m_proprietary.insert(left_prop);
212 left.inputs[0].m_proprietary.insert(left_prop);
213 left.outputs[0].m_proprietary.insert(left_prop);
214
215 right.m_proprietary.insert(right_prop);
216 right.inputs[0].m_proprietary.insert(right_prop);
217 right.outputs[0].m_proprietary.insert(right_prop);
218
219 BOOST_REQUIRE(left.Merge(right));
220
221 BOOST_REQUIRE_EQUAL(left.m_proprietary.size(), 2U);
222 BOOST_REQUIRE_EQUAL(left.inputs[0].m_proprietary.size(), 2U);
223 BOOST_REQUIRE_EQUAL(left.outputs[0].m_proprietary.size(), 2U);
224
225 const auto global_it = left.m_proprietary.find(right_prop);
226 BOOST_REQUIRE(global_it != left.m_proprietary.end());
227 BOOST_CHECK(global_it->value == right_prop.value);
228
229 const auto input_it = left.inputs[0].m_proprietary.find(right_prop);
230 BOOST_REQUIRE(input_it != left.inputs[0].m_proprietary.end());
231 BOOST_CHECK(input_it->value == right_prop.value);
232
233 const auto output_it = left.outputs[0].m_proprietary.find(right_prop);
234 BOOST_REQUIRE(output_it != left.outputs[0].m_proprietary.end());
235 BOOST_CHECK(output_it->value == right_prop.value);
236}
237
238struct PSBTOutputTest {
239 CPubKey pubkey;
240 FlatSigningProvider provider;
241 CScript script_pubkey;
242
243 explicit PSBTOutputTest(std::string descriptor)
244 {
245 CKey key{GenerateRandomKey()};
246 pubkey = key.GetPubKey();
247 provider.keys.emplace(pubkey.GetID(), key);
248
249 util::ReplaceAll(descriptor, "<KEY>", HexStr(pubkey));
250 std::string error;
251 auto descriptors{Parse(descriptor, provider, error, /*require_checksum=*/false)};
252 BOOST_REQUIRE_MESSAGE(!descriptors.empty(), error);
253 std::vector<CScript> output_scripts;
254 BOOST_REQUIRE(descriptors[0]->Expand(/*pos=*/0, provider, output_scripts, provider));
255 BOOST_REQUIRE_EQUAL(output_scripts.size(), 1);
256 script_pubkey = output_scripts[0];
257 }
258
259 PSBTOutput UpdateOutput(bool has_input) const
260 {
261 CMutableTransaction tx;
262 if (has_input) tx.vin.emplace_back();
263 tx.vout.emplace_back(0, script_pubkey);
264 PartiallySignedTransaction psbt{tx, /*version=*/2};
265 UpdatePSBTOutput(provider, psbt, 0);
266 return psbt.outputs[0];
267 }
268};
269
270BOOST_AUTO_TEST_CASE(update_psbt_output_keypaths)
271{
272 for (bool has_input : {false, true}) {
273 for (const auto& descriptor : {"pkh(<KEY>)", "wpkh(<KEY>)"}) {
274 PSBTOutputTest test{descriptor};
275 auto out{test.UpdateOutput(has_input)};
276 BOOST_CHECK(out.hd_keypaths.contains(test.pubkey));
277 BOOST_CHECK(out.redeem_script.empty());
278 BOOST_CHECK(out.witness_script.empty());
279 }
280 }
281}
282
283BOOST_AUTO_TEST_CASE(update_psbt_output_redeem_script)
284{
285 for (bool has_input : {false, true}) {
286 PSBTOutputTest test{"sh(wpkh(<KEY>))"};
287 auto out{test.UpdateOutput(has_input)};
288 BOOST_CHECK_EQUAL(out.redeem_script, GetScriptForDestination(WitnessV0KeyHash{test.pubkey}));
289 BOOST_CHECK(out.hd_keypaths.contains(test.pubkey));
290 }
291}
292
293BOOST_AUTO_TEST_CASE(update_psbt_output_witness_script)
294{
295 for (bool has_input : {false, true}) {
296 PSBTOutputTest test{"wsh(pk(<KEY>))"};
297 auto out{test.UpdateOutput(has_input)};
298 BOOST_CHECK_EQUAL(out.witness_script, GetScriptForRawPubKey(test.pubkey));
299 BOOST_CHECK(out.hd_keypaths.contains(test.pubkey));
300 }
301}
302
303BOOST_AUTO_TEST_CASE(update_psbt_output_miniscript_timelock)
304{
305 for (bool has_input : {false, true}) {
306 PSBTOutputTest test{"wsh(and_v(v:pk(<KEY>),older(144)))"};
307 auto out{test.UpdateOutput(has_input)};
308 BOOST_CHECK_EQUAL(GetScriptForDestination(WitnessV0ScriptHash{out.witness_script}), test.script_pubkey);
309 BOOST_CHECK(out.hd_keypaths.contains(test.pubkey));
310 }
311}
312
313BOOST_AUTO_TEST_CASE(update_psbt_output_taproot)
314{
315 for (bool has_input : {false, true}) {
316 PSBTOutputTest test{"rawtr(<KEY>)"};
317 auto out{test.UpdateOutput(has_input)};
318 BOOST_CHECK(out.m_tap_bip32_paths.contains(XOnlyPubKey{test.pubkey}));
319 BOOST_CHECK(out.hd_keypaths.empty());
320 }
321}
322
332
333BOOST_AUTO_TEST_CASE(psbt_merge_fallback_locktime)
334{
335 CMutableTransaction mtx;
336 PartiallySignedTransaction psbt1(mtx, /*version*/2);
337 PartiallySignedTransaction psbt2(mtx, /*version*/2);
338 psbt1.m_tx_modifiable.emplace();
339 psbt1.m_tx_modifiable->set(INPUTS_MODIFIABLE);
340 BOOST_REQUIRE_EQUAL(psbt1.inputs.size(), 0);
341 psbt2.m_tx_modifiable.emplace();
342 psbt2.m_tx_modifiable->set(INPUTS_MODIFIABLE);
343 BOOST_REQUIRE_EQUAL(psbt2.inputs.size(), 0);
344
345
346 PSBTInput psbtin(/*psbt_version=*/2, Txid::FromUint256(uint256::ONE), /*prev_out=*/0);
347 psbtin.height_locktime = 100;
348 BOOST_REQUIRE(psbt1.AddInput(psbtin));
349 BOOST_REQUIRE(psbt2.AddInput(psbtin));
350
351 psbt1.fallback_locktime = std::nullopt;
352 psbt2.fallback_locktime = 21;
353 BOOST_CHECK(psbt1.Merge(psbt2));
354 BOOST_REQUIRE(psbt1.fallback_locktime.has_value());
355 BOOST_CHECK_EQUAL(*psbt1.fallback_locktime, 21);
356
357 psbt1.fallback_locktime = 5;
358 psbt2.fallback_locktime = 19;
359 BOOST_CHECK(psbt1.Merge(psbt2));
360 BOOST_REQUIRE(psbt1.fallback_locktime.has_value());
361 BOOST_CHECK_EQUAL(*psbt1.fallback_locktime, 5);
362
363 psbt1.fallback_locktime = 21;
364 psbt2.fallback_locktime = std::nullopt;
365 BOOST_CHECK(psbt1.Merge(psbt2));
366 BOOST_REQUIRE(psbt1.fallback_locktime.has_value());
367 BOOST_CHECK_EQUAL(*psbt1.fallback_locktime, 21);
368}
369
370BOOST_AUTO_TEST_CASE(psbt_merge_modifiable)
371{
372 CMutableTransaction mtx;
373 PartiallySignedTransaction psbt1(mtx, /*version*/2);
374 PartiallySignedTransaction psbt2(mtx, /*version*/2);
375
376 BOOST_CHECK(psbt1.Merge(psbt2));
377 BOOST_CHECK(!psbt1.m_tx_modifiable.has_value());
378
379 psbt1.m_tx_modifiable.emplace();
380 psbt1.m_tx_modifiable->set(INPUTS_MODIFIABLE);
381 BOOST_CHECK(psbt1.Merge(psbt2));
382 BOOST_REQUIRE(psbt1.m_tx_modifiable.has_value());
383 BOOST_CHECK(!psbt1.m_tx_modifiable->test(INPUTS_MODIFIABLE));
384
385 psbt1.m_tx_modifiable.reset();
386 psbt2.m_tx_modifiable.emplace();
387 psbt2.m_tx_modifiable->set(INPUTS_MODIFIABLE);
388 psbt2.m_tx_modifiable->set(HAS_SIGHASH_SINGLE);
389 BOOST_CHECK(psbt1.Merge(psbt2));
390 BOOST_REQUIRE(psbt1.m_tx_modifiable.has_value());
391 BOOST_CHECK(!psbt1.m_tx_modifiable->test(INPUTS_MODIFIABLE));
392 BOOST_CHECK(psbt1.m_tx_modifiable->test(HAS_SIGHASH_SINGLE));
393
394 psbt1.m_tx_modifiable.emplace();
395 psbt1.m_tx_modifiable->set(HAS_SIGHASH_SINGLE);
396 psbt2.m_tx_modifiable.reset();
397 BOOST_CHECK(psbt1.Merge(psbt2));
398 BOOST_REQUIRE(psbt1.m_tx_modifiable.has_value());
399 BOOST_CHECK(psbt1.m_tx_modifiable->test(HAS_SIGHASH_SINGLE));
400
401 psbt1.m_tx_modifiable.reset();
402 psbt2.m_tx_modifiable.emplace();
403 psbt2.m_tx_modifiable->set(HAS_SIGHASH_SINGLE);
404 BOOST_CHECK(psbt1.Merge(psbt2));
405 BOOST_REQUIRE(psbt1.m_tx_modifiable.has_value());
406 BOOST_CHECK(psbt1.m_tx_modifiable->test(HAS_SIGHASH_SINGLE));
407
408 psbt1.m_tx_modifiable.emplace();
409 psbt1.m_tx_modifiable->set(INPUTS_MODIFIABLE);
410 psbt1.m_tx_modifiable->set(OUTPUTS_MODIFIABLE);
411 psbt2.m_tx_modifiable.emplace();
412 psbt2.m_tx_modifiable->set(INPUTS_MODIFIABLE);
413 psbt2.m_tx_modifiable->set(OUTPUTS_MODIFIABLE);
414 BOOST_CHECK(psbt1.Merge(psbt2));
415 BOOST_REQUIRE(psbt1.m_tx_modifiable.has_value());
416 BOOST_CHECK(psbt1.m_tx_modifiable->test(INPUTS_MODIFIABLE) && psbt1.m_tx_modifiable->test(OUTPUTS_MODIFIABLE));
417}
418
419BOOST_AUTO_TEST_SUITE_END()
GetScriptForDestination
CScript GetScriptForDestination(const CTxDestination &dest)
Generate a Bitcoin scriptPubKey for the given CTxDestination.
Definition addresstype.cpp:165
CKey
An encapsulated private key.
Definition key.h:46
COutPoint
An outpoint - a combination of a transaction hash and an index n into its vout.
Definition transaction.h:30
CPubKey
An encapsulated public key.
Definition pubkey.h:43
CPubKey::GetID
CKeyID GetID() const
Get the KeyID of this public key (hash of its serialization)
Definition pubkey.h:169
CScript
Serialized script, used inside transaction inputs and outputs.
Definition script.h:406
FastRandomContext
Fast randomness source.
Definition random.h:386
FastRandomContext::fillrand
void fillrand(std::span< std::byte > output) noexcept
Fill a byte span with random bytes.
Definition random.cpp:626
PSBTInput
A structure for PSBTs which contain per-input information.
Definition psbt.h:282
PSBTOutput
A structure for PSBTs which contains per output information.
Definition psbt.h:939
PartiallySignedTransaction
A version of CTransaction with the PSBT format.
Definition psbt.h:1239
PartiallySignedTransaction::Merge
bool Merge(const PartiallySignedTransaction &psbt)
Merge psbt into this.
Definition psbt.cpp:37
PartiallySignedTransaction::inputs
std::vector< PSBTInput > inputs
Definition psbt.h:1248
PartiallySignedTransaction::outputs
std::vector< PSBTOutput > outputs
Definition psbt.h:1249
PartiallySignedTransaction::m_proprietary
std::set< PSBTProprietary > m_proprietary
Definition psbt.h:1251
transaction_identifier< false >::FromUint256
static transaction_identifier FromUint256(const uint256 &id)
Definition transaction_identifier.h:38
uint256
256-bit opaque blob.
Definition uint256.h:196
uint256::ONE
static const uint256 ONE
Definition uint256.h:205
Parse
static UniValue Parse(std::string_view raw, ParamFormat format=ParamFormat::JSON)
Parse string to UniValue or throw runtime_error if string contains invalid JSON.
Definition client.cpp:421
BOOST_FIXTURE_TEST_SUITE
BOOST_FIXTURE_TEST_SUITE(cuckoocache_tests, BasicTestingSetup)
Test Suite for CuckooCache.
BOOST_AUTO_TEST_SUITE_END
BOOST_AUTO_TEST_SUITE_END()
HexStr
std::string HexStr(const std::span< const uint8_t > s)
Convert a span of bytes to a lower-case hexadecimal string.
Definition hex_base.cpp:30
GenerateRandomKey
CKey GenerateRandomKey(bool compressed) noexcept
Definition key.cpp:354
util::ReplaceAll
void ReplaceAll(std::string &in_out, std::string_view search, std::string_view substitute)
Replace every non-overlapping occurrence of search with substitute, treating both literally; the repl...
Definition string.cpp:14
BOOST_CHECK_EQUAL
#define BOOST_CHECK_EQUAL(v1, v2)
Definition object.cpp:17
BOOST_CHECK
#define BOOST_CHECK(expr)
Definition object.cpp:16
UpdatePSBTOutput
void UpdatePSBTOutput(const SigningProvider &provider, PartiallySignedTransaction &psbt, int index)
Updates a PSBTOutput with information from provider.
Definition psbt.cpp:597
DecodeBase64PSBT
util::Result< PartiallySignedTransaction > DecodeBase64PSBT(const std::string &base64_tx)
Decode a base64ed PSBT into a PartiallySignedTransaction.
Definition psbt.cpp:862
BOOST_AUTO_TEST_CASE
BOOST_AUTO_TEST_CASE(psbt2_timelock_test)
Definition psbt_tests.cpp:58
HAS_SIGHASH_SINGLE
static constexpr std::size_t HAS_SIGHASH_SINGLE
Definition psbt_tests.cpp:28
MakeProprietary
static PSBTProprietary MakeProprietary(uint64_t subtype, uint8_t key_data, uint8_t value)
Definition psbt_tests.cpp:30
INPUTS_MODIFIABLE
static constexpr std::size_t INPUTS_MODIFIABLE
Definition psbt_tests.cpp:26
OUTPUTS_MODIFIABLE
static constexpr std::size_t OUTPUTS_MODIFIABLE
Definition psbt_tests.cpp:27
CheckTimeLock
void CheckTimeLock(const std::string &base64_psbt, std::optional< uint32_t > timelock)
Definition psbt_tests.cpp:40
OP_1
@ OP_1
Definition script.h:84
LOCKTIME_THRESHOLD
constexpr unsigned int LOCKTIME_THRESHOLD
Definition script.h:48
setup_common.h
GetScriptForRawPubKey
CScript GetScriptForRawPubKey(const CPubKey &pubKey)
Generate a P2PK script for the given pubkey.
Definition solver.cpp:213
MakeWritableByteSpan
auto MakeWritableByteSpan(V &&v) noexcept
Definition span.h:89
strencodings.h
Utilities for converting data from/to strings.
BasicTestingSetup
Basic testing setup.
Definition setup_common.h:58
CMutableTransaction
A mutable version of CTransaction.
Definition transaction.h:372
CMutableTransaction::vout
std::vector< CTxOut > vout
Definition transaction.h:374
CMutableTransaction::vin
std::vector< CTxIn > vin
Definition transaction.h:373
FlatSigningProvider::keys
std::map< CKeyID, CKey > keys
Definition signingprovider.h:239
PSBTOutputTest::UpdateOutput
PSBTOutput UpdateOutput(bool has_input) const
Definition psbt_tests.cpp:259
PSBTOutputTest::provider
FlatSigningProvider provider
Definition psbt_tests.cpp:240
PSBTOutputTest::PSBTOutputTest
PSBTOutputTest(std::string descriptor)
Definition psbt_tests.cpp:243
PSBTOutputTest::script_pubkey
CScript script_pubkey
Definition psbt_tests.cpp:241
PSBTProprietary
A structure for PSBT proprietary types.
Definition psbt.h:101
PSBTProprietary::subtype
uint64_t subtype
Definition psbt.h:102
rng
FastRandomContext rng
Definition dbwrapper.cpp:412
Ticks
constexpr auto Ticks(Dur2 d)
Helper to count the seconds of a duration/time_point.
Definition time.h:82
Generated on Fri Nov 13 2026 20:00:32 for Bitcoin Core by doxygen 1.9.8