Inside Bitcoin

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 <common/types.h>
8#include <node/types.h>
9#include <policy/policy.h>
10#include <primitives/transaction.h>
11#include <script/signingprovider.h>
12#include <util/check.h>
13#include <util/result.h>
14#include <util/strencodings.h>
15
16#include <algorithm>
17#include <set>
18
19using common::PSBTError;
20
21PartiallySignedTransaction::PartiallySignedTransaction(const CMutableTransaction& tx, uint32_t version) : m_version(version)
22{
23    assert(m_version == 0 || m_version == 2);
24
25    tx_version = tx.version;
26    fallback_locktime = tx.nLockTime;
27    inputs.reserve(tx.vin.size());
28    for (const CTxIn& input : tx.vin) {
29        inputs.emplace_back(GetVersion(), input.prevout.hash, input.prevout.n, input.nSequence);
30    }
31    outputs.reserve(tx.vout.size());
32    for (const CTxOut& output : tx.vout) {
33        outputs.emplace_back(GetVersion(), output.nValue, output.scriptPubKey);
34    }
35}
36
37bool PartiallySignedTransaction::Merge(const PartiallySignedTransaction& psbt)
38{
39    // Prohibited to merge two PSBTs over different transactions
40    std::optional<Txid> this_id = GetUniqueID();
41    std::optional<Txid> psbt_id = psbt.GetUniqueID();
42    if (!this_id || !psbt_id || this_id != psbt_id) {
43        return false;
44    }
45    if (GetVersion() != psbt.GetVersion()) {
46        return false;
47    }
48
49    for (unsigned int i = 0; i < inputs.size(); ++i) {
50        inputs[i].Merge(psbt.inputs[i]);
51    }
52    for (unsigned int i = 0; i < outputs.size(); ++i) {
53        outputs[i].Merge(psbt.outputs[i]);
54    }
55    MergeGlobalXPubs(psbt);
56    if (fallback_locktime == std::nullopt && psbt.fallback_locktime != std::nullopt) fallback_locktime = psbt.fallback_locktime;
57
58    // Set m_tx_modifiable only if either PSBT had it set
59    if (m_tx_modifiable.has_value() || psbt.m_tx_modifiable.has_value()) {
60        // In general, we AND the modifiable flags
61        std::bitset<8> this_modifiable = m_tx_modifiable.value_or(0);
62        std::bitset<8> psbt_modifiable = psbt.m_tx_modifiable.value_or(0);
63        std::bitset<8> final_modifiable = this_modifiable & psbt_modifiable;
64        // SIGHASH_SINGLE Modifiable (bit 2) needs to be bitwise OR'd
65        final_modifiable.set(2, this_modifiable[2] || psbt_modifiable[2]);
66
67        m_tx_modifiable = final_modifiable;
68    }
69
70    m_proprietary.insert(psbt.m_proprietary.begin(), psbt.m_proprietary.end());
71    unknown.insert(psbt.unknown.begin(), psbt.unknown.end());
72
73    return true;
74}
75
76void PartiallySignedTransaction::MergeGlobalXPubs(const PartiallySignedTransaction& psbt)
77{
78    for (const auto& [origin, xpubs] : psbt.m_xpubs) {
79        for (const CExtPubKey& xpub : xpubs) {
80            const bool known{std::ranges::any_of(m_xpubs, [&](const auto& entry) { return entry.second.contains(xpub); })};
81            if (!known) m_xpubs[origin].insert(xpub);
82        }
83    }
84}
85
86std::optional<uint32_t> PartiallySignedTransaction::ComputeTimeLock() const
87{
88    if (GetVersion() >= 2) {
89        std::optional<uint32_t> time_lock{0};
90        std::optional<uint32_t> height_lock{0};
91        for (const PSBTInput& input : inputs) {
92            if (input.time_locktime.has_value() && !input.height_locktime.has_value()) {
93                height_lock.reset(); // Transaction can no longer have a height locktime
94                if (!time_lock.has_value()) {
95                    return std::nullopt;
96                }
97            } else if (!input.time_locktime.has_value() && input.height_locktime.has_value()) {
98                time_lock.reset(); // Transaction can no longer have a time locktime
99                if (!height_lock.has_value()) {
100                    return std::nullopt;
101                }
102            }
103            if (input.time_locktime && time_lock.has_value()) {
104                time_lock = std::max(time_lock, input.time_locktime);
105            }
106            if (input.height_locktime && height_lock.has_value()) {
107                height_lock = std::max(height_lock, input.height_locktime);
108            }
109        }
110        if (height_lock.has_value() && *height_lock > 0) {
111            return *height_lock;
112        }
113        if (time_lock.has_value() && *time_lock > 0) {
114            return *time_lock;
115        }
116    }
117    return fallback_locktime.value_or(0);
118}
119
120std::optional<CMutableTransaction> PartiallySignedTransaction::GetUnsignedTx() const
121{
122    CMutableTransaction mtx;
123    mtx.version = tx_version;
124    std::optional<uint32_t> locktime = ComputeTimeLock();
125    if (!locktime) {
126        return std::nullopt;
127    }
128    mtx.nLockTime = *locktime;
129    uint32_t max_sequence = CTxIn::SEQUENCE_FINAL;
130    for (const PSBTInput& input : inputs) {
131        CTxIn txin;
132        txin.prevout.hash = input.prev_txid;
133        txin.prevout.n = input.prev_out;
134        txin.nSequence = input.sequence.value_or(max_sequence);
135        mtx.vin.push_back(txin);
136    }
137    for (const PSBTOutput& output : outputs) {
138        CTxOut txout;
139        txout.nValue = output.amount;
140        txout.scriptPubKey = output.script;
141        mtx.vout.push_back(txout);
142    }
143    return mtx;
144}
145
146std::optional<Txid> PartiallySignedTransaction::GetUniqueID() const
147{
148    // Get the unsigned transaction
149    std::optional<CMutableTransaction> mtx = GetUnsignedTx();
150    if (!mtx) {
151        return std::nullopt;
152    }
153    if (GetVersion() >= 2) {
154        for (CTxIn& txin : mtx->vin) {
155            txin.nSequence = 0;
156        }
157    }
158    return mtx->GetHash();
159}
160
161bool PartiallySignedTransaction::AddInput(const PSBTInput& psbtin)
162{
163    // The input being added must be for this PSBT's version
164    if (psbtin.GetVersion() != GetVersion()) {
165        return false;
166    }
167
168    // Prevent duplicate inputs
169    if (std::find_if(inputs.begin(), inputs.end(),
170        [psbtin](const PSBTInput& psbt) {
171            return psbt.prev_txid == psbtin.prev_txid && psbt.prev_out == psbtin.prev_out;
172        }
173    ) != inputs.end()) {
174        return false;
175    }
176
177    if (GetVersion() < 2) {
178        // This is a v0 psbt, so do the v0 AddInput
179        inputs.push_back(psbtin);
180        inputs.back().partial_sigs.clear();
181        inputs.back().final_script_sig.clear();
182        inputs.back().final_script_witness.SetNull();
183        return true;
184    }
185
186    // Check inputs modifiable flag
187    if (!m_tx_modifiable.has_value() || !m_tx_modifiable->test(0)) {
188        return false;
189    }
190
191    // Determine if we need to iterate the inputs.
192    // For now, we only do this if the new input has a required time lock.
193    // BIP 370 states that we should also do this if m_tx_modifiable's bit 2 is set
194    // (Has SIGHASH_SINGLE flag) but since we are only adding inputs at the end of the vector,
195    // we don't care about that.
196    bool iterate_inputs = psbtin.time_locktime != std::nullopt || psbtin.height_locktime != std::nullopt;
197    if (iterate_inputs) {
198        std::optional<uint32_t> old_timelock = ComputeTimeLock();
199        if (!old_timelock) {
200            return false;
201        }
202
203        std::optional<uint32_t> time_lock = psbtin.time_locktime;
204        std::optional<uint32_t> height_lock = psbtin.height_locktime;
205        bool has_sigs = false;
206        for (const PSBTInput& input : inputs) {
207            if (input.time_locktime.has_value() && !input.height_locktime.has_value()) {
208                height_lock.reset(); // Transaction can no longer have a height locktime
209                if (time_lock == std::nullopt) {
210                    return false;
211                }
212            } else if (!input.time_locktime.has_value() && input.height_locktime.has_value()) {
213                time_lock.reset(); // Transaction can no longer have a time locktime
214                if (height_lock == std::nullopt) {
215                    return false;
216                }
217            }
218            if (input.time_locktime && time_lock.has_value()) {
219                time_lock = std::max(time_lock, input.time_locktime);
220            }
221            if (input.height_locktime && height_lock.has_value()) {
222                height_lock = std::max(height_lock, input.height_locktime);
223            }
224            if (input.HasSignatures()) {
225                has_sigs = true;
226            }
227        }
228        uint32_t new_timelock = fallback_locktime.value_or(0);
229        if (height_lock.has_value() && *height_lock > 0) {
230            new_timelock = *height_lock;
231        } else if (time_lock.has_value() && *time_lock > 0) {
232            new_timelock = *time_lock;
233        }
234        if (has_sigs && *old_timelock != new_timelock) {
235            return false;
236        }
237    }
238
239    // Add the input to the end
240    inputs.push_back(psbtin);
241    return true;
242}
243
244bool PartiallySignedTransaction::AddOutput(const PSBTOutput& psbtout)
245{
246    // The output being added must be for this PSBT's version
247    if (psbtout.GetVersion() != GetVersion()) {
248        return false;
249    }
250