READ THE CODE

Inside Bitcoin

The code behind the network, with room to understand it.

Stable release v32.1bitcoin/bitcoin · f0de87f04062 ↗3,020 source files · 47.5 MB stored on the server340 file guides

Release published 2026-10-28 · Snapshot fetched 2026-11-01. Latest stable release at fetch time; development branches and Git history are excluded. Only the selected code window and visible folders load here.

21,423 bytes · SHA-256 996ee9b15a8d6c53… · View upstream ↗

1// Copyright (c) 2010 Satoshi Nakamoto
2// Copyright (c) 2009-present The Bitcoin Core developers
3// Distributed under the MIT software license, see the accompanying
4// file COPYING or http://www.opensource.org/licenses/mit-license.php.
5
6#include <rpc/rawtransaction_util.h>
7
8#include <coins.h>
9#include <consensus/amount.h>
10#include <core_io.h>
11#include <crypto/hex_base.h>
12#include <key_io.h>
13#include <policy/feerate.h>
14#include <policy/policy.h>
15#include <primitives/transaction.h>
16#include <rpc/protocol.h>
17#include <rpc/request.h>
18#include <rpc/util.h>
19#include <script/interpreter.h>
20#include <script/script.h>
21#include <script/sign.h>
22#include <script/signingprovider.h>
23#include <tinyformat.h>
24#include <univalue.h>
25#include <util/check.h>
26#include <util/rbf.h>
27#include <util/translation.h>
28#include <util/vector.h>
29
30#include <cstddef>
31#include <set>
32#include <span>
33#include <variant>
34
35void AddInputs(CMutableTransaction& rawTx, const UniValue& inputs_in, std::optional<bool> rbf)
36{
37    UniValue inputs;
38    if (inputs_in.isNull()) {
39        inputs = UniValue::VARR;
40    } else {
41        inputs = inputs_in.get_array();
42    }
43
44    for (unsigned int idx = 0; idx < inputs.size(); idx++) {
45        const UniValue& input = inputs[idx];
46        const UniValue& o = input.get_obj();
47
48        Txid txid = Txid::FromUint256(ParseHashO(o, "txid"));
49
50        const UniValue& vout_v = o.find_value("vout");
51        if (!vout_v.isNum())
52            throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, missing vout key");
53        int nOutput = vout_v.getInt<int>();
54        if (nOutput < 0)
55            throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, vout cannot be negative");
56
57        uint32_t nSequence;
58
59        if (rbf.value_or(true)) {
60            nSequence = MAX_BIP125_RBF_SEQUENCE; /* CTxIn::SEQUENCE_FINAL - 2 */
61        } else if (rawTx.nLockTime) {
62            nSequence = CTxIn::MAX_SEQUENCE_NONFINAL; /* CTxIn::SEQUENCE_FINAL - 1 */
63        } else {
64            nSequence = CTxIn::SEQUENCE_FINAL;
65        }
66
67        // set the sequence number if passed in the parameters object
68        const UniValue& sequenceObj = o.find_value("sequence");
69        if (sequenceObj.isNum()) {
70            int64_t seqNr64 = sequenceObj.getInt<int64_t>();
71            if (seqNr64 < 0 || seqNr64 > CTxIn::SEQUENCE_FINAL) {
72                throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, sequence number is out of range");
73            } else {
74                nSequence = (uint32_t)seqNr64;
75            }
76        }
77
78        CTxIn in(COutPoint(txid, nOutput), CScript(), nSequence);
79
80        rawTx.vin.push_back(in);
81    }
82}
83
84UniValue NormalizeOutputs(const UniValue& outputs_in)
85{
86    if (outputs_in.isNull()) {
87        throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, output argument must be non-null");
88    }
89
90    const bool outputs_is_obj = outputs_in.isObject();
91    UniValue outputs = outputs_is_obj ? outputs_in.get_obj() : outputs_in.get_array();
92
93    if (!outputs_is_obj) {
94        // Translate array of key-value pairs into dict
95        UniValue outputs_dict = UniValue(UniValue::VOBJ);
96        for (size_t i = 0; i < outputs.size(); ++i) {
97            const UniValue& output = outputs[i];
98            if (!output.isObject()) {
99                throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, key-value pair not an object as expected");
100            }
101            if (output.size() != 1) {
102                throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, key-value pair must contain exactly one key");
103            }
104            outputs_dict.pushKVs(output);
105        }
106        outputs = std::move(outputs_dict);
107    }
108    return outputs;
109}
110
111std::vector<std::pair<CTxDestination, CAmount>> ParseOutputs(const UniValue& outputs)
112{
113    // Duplicate checking
114    std::set<CTxDestination> destinations;
115    std::vector<std::pair<CTxDestination, CAmount>> parsed_outputs;
116    bool has_data{false};
117    const auto& keys{outputs.getKeys()};
118    const auto& values{outputs.getValues()};
119    for (size_t i{0}; i < keys.size(); ++i) {
120        const auto& name_{keys[i]};
121        const auto& value{values[i]};
122        if (name_ == "data") {
123            if (has_data) {
124                throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, duplicate key: data");
125            }
126            has_data = true;
127            std::vector<unsigned char> data = ParseHexV(value.getValStr(), "Data");
128            CTxDestination destination{CNoDestination{CScript() << OP_RETURN << data}};
129            CAmount amount{0};
130            parsed_outputs.emplace_back(destination, amount);
131        } else {
132            CTxDestination destination{DecodeDestination(name_)};
133            CAmount amount{AmountFromValue(value)};
134            if (!IsValidDestination(destination)) {
135                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, std::string("Invalid Bitcoin address: ") + name_);
136            }
137
138            if (!destinations.insert(destination).second) {
139                throw JSONRPCError(RPC_INVALID_PARAMETER, std::string("Invalid parameter, duplicated address: ") + name_);
140            }
141            parsed_outputs.emplace_back(destination, amount);
142        }
143    }
144    return parsed_outputs;
145}
146
147void AddOutputs(CMutableTransaction& rawTx, const UniValue& outputs_in)
148{
149    UniValue outputs(UniValue::VOBJ);
150    outputs = NormalizeOutputs(outputs_in);
151
152    std::vector<std::pair<CTxDestination, CAmount>> parsed_outputs = ParseOutputs(outputs);
153    for (const auto& [destination, nAmount] : parsed_outputs) {
154        CScript scriptPubKey = GetScriptForDestination(destination);
155
156        CTxOut out(nAmount, scriptPubKey);
157        rawTx.vout.push_back(out);
158    }
159}
160
161CMutableTransaction ConstructTransaction(const UniValue& inputs_in, const UniValue& outputs_in, const UniValue& locktime, std::optional<bool> rbf, const uint32_t version)
162{
163    CMutableTransaction rawTx;
164
165    if (!locktime.isNull()) {
166        int64_t nLockTime = locktime.getInt<int64_t>();
167        if (nLockTime < 0 || nLockTime > LOCKTIME_MAX)
168            throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, locktime out of range");
169        rawTx.nLockTime = nLockTime;
170    }
171
172    if (version < TX_MIN_STANDARD_VERSION || version > TX_MAX_STANDARD_VERSION) {
173        throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("Invalid parameter, version out of range(%d~%d)", TX_MIN_STANDARD_VERSION, TX_MAX_STANDARD_VERSION));
174    }
175    rawTx.version = version;
176
177    AddInputs(rawTx, inputs_in, rbf);
178    AddOutputs(rawTx, outputs_in);
179
180    if (rbf.has_value() && rbf.value() && rawTx.vin.size() > 0 && !SignalsOptInRBF(CTransaction(rawTx))) {
181        throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter combination: Sequence number(s) contradict replaceable option");
182    }
183
184    return rawTx;
185}
186
187/** Pushes a JSON object for script verification or signing errors to vErrorsRet. */
188static void TxInErrorToJSON(const CTxIn& txin, UniValue& vErrorsRet, const std::string& strMessage)
189{
190    UniValue entry(UniValue::VOBJ);
191    entry.pushKV("txid", txin.prevout.hash.ToString());
192    entry.pushKV("vout", txin.prevout.n);
193    UniValue witness(UniValue::VARR);
194    for (unsigned int i = 0; i < txin.scriptWitness.stack.size(); i++) {
195        witness.push_back(HexStr(txin.scriptWitness.stack[i]));
196    }
197    entry.pushKV("witness", std::move(witness));
198    entry.pushKV("scriptSig", HexStr(txin.scriptSig));
199    entry.pushKV("sequence", txin.nSequence);
200    entry.pushKV("error", strMessage);
201    vErrorsRet.push_back(std::move(entry));
202}
203
204void ParsePrevouts(const UniValue& prevTxsUnival, FlatSigningProvider* keystore, std::map<COutPoint, Coin>& coins)
205{
206    if (!prevTxsUnival.isNull()) {
207        const UniValue& prevTxs = prevTxsUnival.get_array();
208        for (unsigned int idx = 0; idx < prevTxs.size(); ++idx) {
209            const UniValue& p = prevTxs[idx];
210            if (!p.isObject()) {
211                throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "expected object with {\"txid'\",\"vout\",\"scriptPubKey\"}");
212            }
213
214            const UniValue& prevOut = p.get_obj();
215
216            RPCTypeCheckObj(prevOut,
217                {
218                    {"txid", UniValueType(UniValue::VSTR)},
219                    {"vout", UniValueType(UniValue::VNUM)},
220                    {"scriptPubKey", UniValueType(UniValue::VSTR)},
221                });
222
223            Txid txid = Txid::FromUint256(ParseHashO(prevOut, "txid"));
224
225            int nOut = prevOut.find_value("vout").getInt<int>();
226            if (nOut < 0) {
227                throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "vout cannot be negative");
228            }
229
230            COutPoint out(txid, nOut);
231            std::vector<unsigned char> pkData(ParseHexO(prevOut, "scriptPubKey"));
232            CScript scriptPubKey(pkData.begin(), pkData.end());
233
234            {
235                auto coin = coins.find(out);
236                if (coin != coins.end() && !coin->second.IsSpent() && coin->second.out.scriptPubKey != scriptPubKey) {
237                    std::string err("Previous output scriptPubKey mismatch:\n");
238                    err = err + ScriptToAsmStr(coin->second.out.scriptPubKey) + "\nvs:\n"+
239                        ScriptToAsmStr(scriptPubKey);
240                    throw JSONRPCError(RPC_DESERIALIZATION_ERROR, err);
241                }
242                Coin newcoin;
243                newcoin.out.scriptPubKey = scriptPubKey;
244                newcoin.out.nValue = MAX_MONEY;
245                if (prevOut.exists("amount")) {
246                    newcoin.out.nValue = AmountFromValue(prevOut.find_value("amount"));
247                }
248                newcoin.nHeight = 1;
249                coins[out] = std::move(newcoin);
250            }

FILE GUIDE · KEY SECTIONS

Constructing raw transactions from checked RPC values

These helpers translate inputs, output destinations and amounts into transaction structures, then support signing and signing-result serialization. Creating bytes is separate from acceptance into the mempool.

Line 35 ↗

Choose and validate input sequences

Each input names a transaction ID and nonnegative output index. The default sequence depends on the replaceability option and locktime; an explicit sequence must fit the permitted integer range. Referencing an outpoint here does not prove that it exists or is spendable.

Line 111 ↗

Distinguish payment outputs from data outputs

Payment entries decode an address and parse an amount, rejecting duplicate destinations. The data entry parses hex and produces a zero-value OP_RETURN script, with duplicate data entries rejected. Those are construction rules in this helper, not a promise that every resulting transaction meets relay policy.

Line 161 ↗

Assemble without signing or broadcasting

Construction bounds locktime and standard transaction version, adds inputs and outputs, then checks an explicitly requested replaceability setting against the supplied sequences. The returned mutable transaction still needs appropriate funding, signatures and validation; this function does not send coins.

Independent explanations by MyBitcoinExplorer. Not affiliated with or endorsed by Bitcoin Core. Guides are educational and do not replace the source or its tests.

Bitcoin Core source © its contributors, distributed under the MIT license. Original notices and bundled third-party licenses are retained in the source tree.