Branch data Line data Source code
1 : : // Copyright (c) 2010 Satoshi Nakamoto
2 : : // Copyright (c) 2009-2022 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 <key_io.h>
12 : : #include <policy/policy.h>
13 : : #include <primitives/transaction.h>
14 : : #include <rpc/request.h>
15 : : #include <rpc/util.h>
16 : : #include <script/sign.h>
17 [ + - ]: 173 : #include <script/signingprovider.h>
18 [ + - ]: 173 : #include <tinyformat.h>
19 : : #include <univalue.h>
20 : : #include <util/rbf.h>
21 : : #include <util/strencodings.h>
22 : : #include <util/translation.h>
23 : :
24 : 5 : void AddInputs(CMutableTransaction& rawTx, const UniValue& inputs_in, std::optional<bool> rbf)
25 : : {
26 : 5 : UniValue inputs;
27 [ + - + - ]: 178 : if (inputs_in.isNull()) {
28 [ # # ]: 0 : inputs = UniValue::VARR;
29 : 0 : } else {
30 [ + - + - ]: 5 : inputs = inputs_in.get_array();
31 : : }
32 : :
33 [ + - + - ]: 5 : for (unsigned int idx = 0; idx < inputs.size(); idx++) {
34 [ + - ]: 5 : const UniValue& input = inputs[idx];
35 [ - + ]: 5 : const UniValue& o = input.get_obj();
36 : :
37 [ # # # # ]: 0 : uint256 txid = ParseHashO(o, "txid");
38 : :
39 [ # # ]: 0 : const UniValue& vout_v = o.find_value("vout");
40 [ # # # # ]: 0 : if (!vout_v.isNum())
41 [ # # # # : 0 : throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, missing vout key");
# # ]
42 [ # # ]: 0 : int nOutput = vout_v.getInt<int>();
43 [ # # ]: 0 : if (nOutput < 0)
44 [ # # # # : 0 : throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, vout cannot be negative");
# # ]
45 : :
46 : : uint32_t nSequence;
47 : :
48 [ # # # # ]: 0 : if (rbf.value_or(true)) {
49 : 0 : nSequence = MAX_BIP125_RBF_SEQUENCE; /* CTxIn::SEQUENCE_FINAL - 2 */
50 [ # # ]: 0 : } else if (rawTx.nLockTime) {
51 : 0 : nSequence = CTxIn::MAX_SEQUENCE_NONFINAL; /* CTxIn::SEQUENCE_FINAL - 1 */
52 : 0 : } else {
53 : 0 : nSequence = CTxIn::SEQUENCE_FINAL;
54 : : }
55 : :
56 : : // set the sequence number if passed in the parameters object
57 [ # # ]: 0 : const UniValue& sequenceObj = o.find_value("sequence");
58 [ # # # # ]: 0 : if (sequenceObj.isNum()) {
59 [ # # ]: 0 : int64_t seqNr64 = sequenceObj.getInt<int64_t>();
60 [ # # ]: 0 : if (seqNr64 < 0 || seqNr64 > CTxIn::SEQUENCE_FINAL) {
61 [ # # # # : 0 : throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, sequence number is out of range");
# # ]
62 : : } else {
63 : 0 : nSequence = (uint32_t)seqNr64;
64 : : }
65 : 0 : }
66 : :
67 [ # # # # : 0 : CTxIn in(COutPoint(txid, nOutput), CScript(), nSequence);
# # ]
68 : :
69 [ # # ]: 0 : rawTx.vin.push_back(in);
70 : 0 : }
71 : 5 : }
72 : :
73 : 0 : void AddOutputs(CMutableTransaction& rawTx, const UniValue& outputs_in)
74 : 173 : {
75 [ # # ]: 0 : if (outputs_in.isNull()) {
76 [ # # # # : 0 : throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, output argument must be non-null");
# # ]
77 : : }
78 : :
79 : 0 : const bool outputs_is_obj = outputs_in.isObject();
80 [ # # ]: 0 : UniValue outputs = outputs_is_obj ? outputs_in.get_obj() : outputs_in.get_array();
81 : :
82 [ # # ]: 0 : if (!outputs_is_obj) {
83 : : // Translate array of key-value pairs into dict
84 [ # # ]: 0 : UniValue outputs_dict = UniValue(UniValue::VOBJ);
85 [ # # # # ]: 0 : for (size_t i = 0; i < outputs.size(); ++i) {
86 [ # # ]: 0 : const UniValue& output = outputs[i];
87 [ # # # # ]: 0 : if (!output.isObject()) {
88 [ # # # # : 0 : throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, key-value pair not an object as expected");
# # ]
89 : : }
90 [ # # # # ]: 0 : if (output.size() != 1) {
91 [ # # # # : 0 : throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, key-value pair must contain exactly one key");
# # ]
92 : : }
93 [ # # # # ]: 0 : outputs_dict.pushKVs(output);
94 : 0 : }
95 : 0 : outputs = std::move(outputs_dict);
96 : 0 : }
97 : :
98 : : // Duplicate checking
99 : 0 : std::set<CTxDestination> destinations;
100 : 0 : bool has_data{false};
101 : :
102 [ # # # # ]: 0 : for (const std::string& name_ : outputs.getKeys()) {
103 [ # # # # ]: 0 : if (name_ == "data") {
104 [ # # ]: 0 : if (has_data) {
105 [ # # # # : 0 : throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, duplicate key: data");
# # ]
106 : : }
107 : 0 : has_data = true;
108 [ # # # # : 0 : std::vector<unsigned char> data = ParseHexV(outputs[name_].getValStr(), "Data");
# # # # #
# ]
109 : :
110 [ # # # # : 0 : CTxOut out(0, CScript() << OP_RETURN << data);
# # # # #
# ]
111 [ # # ]: 0 : rawTx.vout.push_back(out);
112 : 0 : } else {
113 [ # # ]: 0 : CTxDestination destination = DecodeDestination(name_);
114 [ # # # # ]: 0 : if (!IsValidDestination(destination)) {
115 [ # # # # : 0 : throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, std::string("Invalid Bitcoin address: ") + name_);
# # # # ]
116 : : }
117 : :
118 [ # # # # ]: 0 : if (!destinations.insert(destination).second) {
119 [ # # # # : 0 : throw JSONRPCError(RPC_INVALID_PARAMETER, std::string("Invalid parameter, duplicated address: ") + name_);
# # # # ]
120 : : }
121 : :
122 [ # # ]: 0 : CScript scriptPubKey = GetScriptForDestination(destination);
123 [ # # # # ]: 0 : CAmount nAmount = AmountFromValue(outputs[name_]);
124 : :
125 [ # # # # ]: 0 : CTxOut out(nAmount, scriptPubKey);
126 [ # # ]: 0 : rawTx.vout.push_back(out);
127 : 0 : }
128 : : }
129 : 0 : }
130 : :
131 : 9 : CMutableTransaction ConstructTransaction(const UniValue& inputs_in, const UniValue& outputs_in, const UniValue& locktime, std::optional<bool> rbf)
132 : : {
133 : 9 : CMutableTransaction rawTx;
134 : :
135 [ + - + + ]: 9 : if (!locktime.isNull()) {
136 [ + + ]: 5 : int64_t nLockTime = locktime.getInt<int64_t>();
137 [ + + ]: 2 : if (nLockTime < 0 || nLockTime > LOCKTIME_MAX)
138 [ + - + - : 1 : throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, locktime out of range");
+ - ]
139 : 1 : rawTx.nLockTime = nLockTime;
140 : 1 : }
141 : :
142 [ - + ]: 5 : AddInputs(rawTx, inputs_in, rbf);
143 [ # # ]: 0 : AddOutputs(rawTx, outputs_in);
144 : :
145 [ # # # # : 0 : if (rbf.has_value() && rbf.value() && rawTx.vin.size() > 0 && !SignalsOptInRBF(CTransaction(rawTx))) {
# # # # #
# # # # #
# # # # ]
146 [ # # # # : 0 : throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter combination: Sequence number(s) contradict replaceable option");
# # ]
147 : : }
148 : :
149 : 0 : return rawTx;
150 [ # # ]: 10 : }
151 : :
152 : : /** Pushes a JSON object for script verification or signing errors to vErrorsRet. */
153 : 3962 : static void TxInErrorToJSON(const CTxIn& txin, UniValue& vErrorsRet, const std::string& strMessage)
154 : : {
155 [ + - ]: 3962 : UniValue entry(UniValue::VOBJ);
156 [ + - + - : 3962 : entry.pushKV("txid", txin.prevout.hash.ToString());
+ - + - ]
157 [ + - + - : 3962 : entry.pushKV("vout", (uint64_t)txin.prevout.n);
+ - ]
158 [ + - ]: 3962 : UniValue witness(UniValue::VARR);
159 [ + + ]: 4133 : for (unsigned int i = 0; i < txin.scriptWitness.stack.size(); i++) {
160 [ + - + - : 171 : witness.push_back(HexStr(txin.scriptWitness.stack[i]));
+ - + - ]
161 : 171 : }
162 [ + - + - : 3962 : entry.pushKV("witness", witness);
+ - ]
163 [ + - + - : 3962 : entry.pushKV("scriptSig", HexStr(txin.scriptSig));
+ - + - +
- ]
164 [ + - + - : 3962 : entry.pushKV("sequence", (uint64_t)txin.nSequence);
+ - ]
165 [ + - + - : 3962 : entry.pushKV("error", strMessage);
+ - ]
166 [ + - + - ]: 3962 : vErrorsRet.push_back(entry);
167 : 3962 : }
168 : :
169 : 150 : void ParsePrevouts(const UniValue& prevTxsUnival, FillableSigningProvider* keystore, std::map<COutPoint, Coin>& coins)
170 : : {
171 [ + + ]: 150 : if (!prevTxsUnival.isNull()) {
172 : 7 : const UniValue& prevTxs = prevTxsUnival.get_array();
173 [ + - ]: 7 : for (unsigned int idx = 0; idx < prevTxs.size(); ++idx) {
174 : 7 : const UniValue& p = prevTxs[idx];
175 [ - + ]: 7 : if (!p.isObject()) {
176 [ + - + - : 7 : throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "expected object with {\"txid'\",\"vout\",\"scriptPubKey\"}");
+ - ]
177 : : }
178 : :
179 : 0 : const UniValue& prevOut = p.get_obj();
180 : :
181 [ # # ]: 0 : RPCTypeCheckObj(prevOut,
182 [ # # ]: 0 : {
183 [ # # # # ]: 0 : {"txid", UniValueType(UniValue::VSTR)},
184 [ # # # # ]: 0 : {"vout", UniValueType(UniValue::VNUM)},
185 [ # # # # ]: 0 : {"scriptPubKey", UniValueType(UniValue::VSTR)},
186 : : });
187 : :
188 [ # # # # ]: 0 : uint256 txid = ParseHashO(prevOut, "txid");
189 : :
190 : 0 : int nOut = prevOut.find_value("vout").getInt<int>();
191 [ # # ]: 0 : if (nOut < 0) {
192 [ # # # # : 0 : throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "vout cannot be negative");
# # ]
193 : : }
194 : :
195 : 0 : COutPoint out(txid, nOut);
196 [ # # # # ]: 0 : std::vector<unsigned char> pkData(ParseHexO(prevOut, "scriptPubKey"));
197 [ # # ]: 0 : CScript scriptPubKey(pkData.begin(), pkData.end());
198 : :
199 : : {
200 [ # # ]: 0 : auto coin = coins.find(out);
201 [ # # # # : 0 : if (coin != coins.end() && !coin->second.IsSpent() && coin->second.out.scriptPubKey != scriptPubKey) {
# # # # #
# ]
202 [ # # ]: 0 : std::string err("Previous output scriptPubKey mismatch:\n");
203 [ # # # # : 0 : err = err + ScriptToAsmStr(coin->second.out.scriptPubKey) + "\nvs:\n"+
# # # # ]
204 [ # # ]: 0 : ScriptToAsmStr(scriptPubKey);
205 [ # # ]: 0 : throw JSONRPCError(RPC_DESERIALIZATION_ERROR, err);
206 : 0 : }
207 [ # # ]: 0 : Coin newcoin;
208 [ # # ]: 0 : newcoin.out.scriptPubKey = scriptPubKey;
209 : 0 : newcoin.out.nValue = MAX_MONEY;
210 [ # # # # : 0 : if (prevOut.exists("amount")) {
# # ]
211 [ # # # # ]: 0 : newcoin.out.nValue = AmountFromValue(prevOut.find_value("amount"));
212 : 0 : }
213 : 0 : newcoin.nHeight = 1;
214 [ # # ]: 0 : coins[out] = std::move(newcoin);
215 : 0 : }
216 : :
217 : : // if redeemScript and private keys were given, add redeemScript to the keystore so it can be signed
218 [ # # ]: 0 : const bool is_p2sh = scriptPubKey.IsPayToScriptHash();
219 [ # # ]: 0 : const bool is_p2wsh = scriptPubKey.IsPayToWitnessScriptHash();
220 [ # # # # : 0 : if (keystore && (is_p2sh || is_p2wsh)) {
# # ]
221 [ # # ]: 0 : RPCTypeCheckObj(prevOut,
222 [ # # ]: 0 : {
223 [ # # # # ]: 0 : {"redeemScript", UniValueType(UniValue::VSTR)},
224 [ # # # # ]: 0 : {"witnessScript", UniValueType(UniValue::VSTR)},
225 : : }, true);
226 [ # # ]: 0 : const UniValue& rs{prevOut.find_value("redeemScript")};
227 [ # # ]: 0 : const UniValue& ws{prevOut.find_value("witnessScript")};
228 [ # # # # : 0 : if (rs.isNull() && ws.isNull()) {
# # # # ]
229 [ # # # # : 0 : throw JSONRPCError(RPC_INVALID_PARAMETER, "Missing redeemScript/witnessScript");
# # ]
230 : : }
231 : :
232 : : // work from witnessScript when possible
233 [ # # # # : 0 : std::vector<unsigned char> scriptData(!ws.isNull() ? ParseHexV(ws, "witnessScript") : ParseHexV(rs, "redeemScript"));
# # # # #
# # # # #
# # # # #
# # # # #
# # # # ]
234 [ # # ]: 0 : CScript script(scriptData.begin(), scriptData.end());
235 [ # # ]: 0 : keystore->AddCScript(script);
236 : : // Automatically also add the P2WSH wrapped version of the script (to deal with P2SH-P2WSH).
237 : : // This is done for redeemScript only for compatibility, it is encouraged to use the explicit witnessScript field instead.
238 [ # # # # ]: 0 : CScript witness_output_script{GetScriptForDestination(WitnessV0ScriptHash(script))};
239 [ # # ]: 0 : keystore->AddCScript(witness_output_script);
240 : :
241 [ # # # # : 0 : if (!ws.isNull() && !rs.isNull()) {
# # # # ]
242 : : // if both witnessScript and redeemScript are provided,
243 : : // they should either be the same (for backwards compat),
244 : : // or the redeemScript should be the encoded form of
245 : : // the witnessScript (ie, for p2sh-p2wsh)
246 [ # # # # : 0 : if (ws.get_str() != rs.get_str()) {
# # ]
247 [ # # # # ]: 0 : std::vector<unsigned char> redeemScriptData(ParseHexV(rs, "redeemScript"));
248 [ # # ]: 0 : CScript redeemScript(redeemScriptData.begin(), redeemScriptData.end());
249 [ # # # # ]: 0 : if (redeemScript != witness_output_script) {
250 [ # # # # : 0 : throw JSONRPCError(RPC_INVALID_PARAMETER, "redeemScript does not correspond to witnessScript");
# # ]
251 : : }
252 : 0 : }
253 : 0 : }
254 : :
255 [ # # ]: 0 : if (is_p2sh) {
256 [ # # ]: 0 : const CTxDestination p2sh{ScriptHash(script)};
257 [ # # ]: 0 : const CTxDestination p2sh_p2wsh{ScriptHash(witness_output_script)};
258 [ # # # # : 0 : if (scriptPubKey == GetScriptForDestination(p2sh)) {
# # ]
259 : : // traditional p2sh; arguably an error if
260 : : // we got here with rs.IsNull(), because
261 : : // that means the p2sh script was specified
262 : : // via witnessScript param, but for now
263 : : // we'll just quietly accept it
264 [ # # # # : 0 : } else if (scriptPubKey == GetScriptForDestination(p2sh_p2wsh)) {
# # ]
265 : : // p2wsh encoded as p2sh; ideally the witness
266 : : // script was specified in the witnessScript
267 : : // param, but also support specifying it via
268 : : // redeemScript param for backwards compat
269 : : // (in which case ws.IsNull() == true)
270 : 0 : } else {
271 : : // otherwise, can't generate scriptPubKey from
272 : : // either script, so we got unusable parameters
273 [ # # # # : 0 : throw JSONRPCError(RPC_INVALID_PARAMETER, "redeemScript/witnessScript does not match scriptPubKey");
# # ]
274 : : }
275 [ # # ]: 0 : } else if (is_p2wsh) {
276 : : // plain p2wsh; could throw an error if script
277 : : // was specified by redeemScript rather than
278 : : // witnessScript (ie, ws.IsNull() == true), but
279 : : // accept it for backwards compat
280 [ # # ]: 0 : const CTxDestination p2wsh{WitnessV0ScriptHash(script)};
281 [ # # # # : 0 : if (scriptPubKey != GetScriptForDestination(p2wsh)) {
# # ]
282 [ # # # # : 0 : throw JSONRPCError(RPC_INVALID_PARAMETER, "redeemScript/witnessScript does not match scriptPubKey");
# # ]
283 : : }
284 : 0 : }
285 : 0 : }
286 : 0 : }
287 : 0 : }
288 : 150 : }
289 : :
290 : 143 : void SignTransaction(CMutableTransaction& mtx, const SigningProvider* keystore, const std::map<COutPoint, Coin>& coins, const UniValue& hashType, UniValue& result)
291 : : {
292 : 143 : int nHashType = ParseSighashString(hashType);
293 : :
294 : : // Script verification errors
295 : 143 : std::map<int, bilingual_str> input_errors;
296 : :
297 [ + - ]: 143 : bool complete = SignTransaction(mtx, keystore, coins, nHashType, input_errors);
298 [ + - ]: 143 : SignTransactionResultToJSON(mtx, complete, coins, input_errors, result);
299 : 143 : }
300 : :
301 : 143 : void SignTransactionResultToJSON(CMutableTransaction& mtx, bool complete, const std::map<COutPoint, Coin>& coins, const std::map<int, bilingual_str>& input_errors, UniValue& result)
302 : : {
303 : : // Make errors UniValue
304 [ + - ]: 143 : UniValue vErrors(UniValue::VARR);
305 [ + + ]: 4105 : for (const auto& err_pair : input_errors) {
306 [ + - + - ]: 3962 : if (err_pair.second.original == "Missing amount") {
307 : : // This particular error needs to be an exception for some reason
308 [ # # # # : 0 : throw JSONRPCError(RPC_TYPE_ERROR, strprintf("Missing amount for %s", coins.at(mtx.vin.at(err_pair.first).prevout).out.ToString()));
# # # # #
# # # #
# ]
309 : : }
310 [ + - + - ]: 3962 : TxInErrorToJSON(mtx.vin.at(err_pair.first), vErrors, err_pair.second.original);
311 : : }
312 : :
313 [ + - + - : 143 : result.pushKV("hex", EncodeHexTx(CTransaction(mtx)));
+ - + - +
- ]
314 [ + - + - : 143 : result.pushKV("complete", complete);
+ - ]
315 [ + - + + ]: 143 : if (!vErrors.empty()) {
316 [ + - + - : 111 : if (result.exists("errors")) {
+ - ]
317 [ # # # # : 0 : vErrors.push_backV(result["errors"].getValues());
# # # # ]
318 : 0 : }
319 [ + - + - : 111 : result.pushKV("errors", vErrors);
+ - ]
320 : 111 : }
321 : 143 : }
|
