Branch data Line data Source code
1 : : // Copyright (c) 2012-2022 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 <consensus/tx_verify.h>
6 : : #include <key.h>
7 : : #include <policy/policy.h>
8 : : #include <policy/settings.h>
9 : : #include <script/script.h>
10 : : #include <script/script_error.h>
11 : : #include <script/sign.h>
12 : : #include <script/signingprovider.h>
13 : : #include <test/util/setup_common.h>
14 : : #include <test/util/transaction_utils.h>
15 : : #include <validation.h>
16 : :
17 : : #include <vector>
18 : :
19 : : #include <boost/test/unit_test.hpp>
20 : :
21 : : // Helpers:
22 : 8 : static bool IsStandardTx(const CTransaction& tx, bool permit_bare_multisig, std::string& reason)
23 : : {
24 : 8 : return IsStandardTx(tx, std::nullopt, permit_bare_multisig, CFeeRate{DUST_RELAY_TX_FEE}, reason);
25 : : }
26 : :
27 : 2 : static bool IsStandardTx(const CTransaction& tx, std::string& reason)
28 : : {
29 [ + - - + ]: 4 : return IsStandardTx(tx, std::nullopt, /*permit_bare_multisig=*/true, CFeeRate{DUST_RELAY_TX_FEE}, reason) &&
30 : 2 : IsStandardTx(tx, std::nullopt, /*permit_bare_multisig=*/false, CFeeRate{DUST_RELAY_TX_FEE}, reason);
31 : : }
32 : :
33 : 4 : static std::vector<unsigned char> Serialize(const CScript& s)
34 : : {
35 [ + - ]: 8 : std::vector<unsigned char> sSerialized(s.begin(), s.end());
36 : 4 : return sSerialized;
37 : : }
38 : :
39 : 4 : static bool Verify(const CScript& scriptSig, const CScript& scriptPubKey, bool fStrict, ScriptError& err)
40 : : {
41 : : // Create dummy to/from transactions:
42 : 4 : CMutableTransaction txFrom;
43 [ + - ]: 4 : txFrom.vout.resize(1);
44 : 4 : txFrom.vout[0].scriptPubKey = scriptPubKey;
45 : :
46 [ + - ]: 4 : CMutableTransaction txTo;
47 [ + - ]: 4 : txTo.vin.resize(1);
48 [ + - ]: 4 : txTo.vout.resize(1);
49 [ + - ]: 4 : txTo.vin[0].prevout.n = 0;
50 [ + - ]: 4 : txTo.vin[0].prevout.hash = txFrom.GetHash();
51 : 4 : txTo.vin[0].scriptSig = scriptSig;
52 [ + + ]: 4 : txTo.vout[0].nValue = 1;
53 : :
54 [ + + + - ]: 5 : return VerifyScript(scriptSig, scriptPubKey, nullptr, fStrict ? SCRIPT_VERIFY_P2SH : SCRIPT_VERIFY_NONE, MutableTransactionSignatureChecker(&txTo, 0, txFrom.vout[0].nValue, MissingDataBehavior::ASSERT_FAIL), &err);
55 : 8 : }
56 : :
57 : :
58 : : BOOST_FIXTURE_TEST_SUITE(script_p2sh_tests, BasicTestingSetup)
59 : :
60 [ + - + - : 7 : BOOST_AUTO_TEST_CASE(sign)
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- ]
61 : : {
62 : : // Pay-to-script-hash looks like this:
63 : : // scriptSig: <sig> <sig...> <serialized_script>
64 : : // scriptPubKey: HASH160 <hash> EQUAL
65 : :
66 : : // Test SignSignature() (and therefore the version of Solver() that signs transactions)
67 : 1 : FillableSigningProvider keystore;
68 : 4 : CKey key[4];
69 [ + + ]: 5 : for (int i = 0; i < 4; i++)
70 : : {
71 [ + - ]: 4 : key[i].MakeNewKey(true);
72 [ + - + - : 8 : BOOST_CHECK(keystore.AddKey(key[i]));
+ - ]
73 : : }
74 : :
75 : : // 8 Scripts: checking all combinations of
76 : : // different keys, straight/P2SH, pubkey/pubkeyhash
77 : 5 : CScript standardScripts[4];
78 [ + - + - : 1 : standardScripts[0] << ToByteVector(key[0].GetPubKey()) << OP_CHECKSIG;
+ - ]
79 [ + - + - : 2 : standardScripts[1] = GetScriptForDestination(PKHash(key[1].GetPubKey()));
+ - ]
80 [ + - + - : 1 : standardScripts[2] << ToByteVector(key[1].GetPubKey()) << OP_CHECKSIG;
+ - ]
81 [ + - + - : 2 : standardScripts[3] = GetScriptForDestination(PKHash(key[2].GetPubKey()));
+ - ]
82 : 5 : CScript evalScripts[4];
83 [ + + ]: 5 : for (int i = 0; i < 4; i++)
84 : : {
85 [ + - + - : 8 : BOOST_CHECK(keystore.AddCScript(standardScripts[i]));
+ - + - ]
86 [ + - + - ]: 4 : evalScripts[i] = GetScriptForDestination(ScriptHash(standardScripts[i]));
87 : : }
88 : :
89 [ + - ]: 1 : CMutableTransaction txFrom; // Funding transaction:
90 [ + - ]: 1 : std::string reason;
91 [ + - ]: 1 : txFrom.vout.resize(8);
92 [ + + ]: 5 : for (int i = 0; i < 4; i++)
93 : : {
94 : 4 : txFrom.vout[i].scriptPubKey = evalScripts[i];
95 : 4 : txFrom.vout[i].nValue = COIN;
96 : 4 : txFrom.vout[i+4].scriptPubKey = standardScripts[i];
97 : 4 : txFrom.vout[i+4].nValue = COIN;
98 : : }
99 [ + - + - : 3 : BOOST_CHECK(IsStandardTx(CTransaction(txFrom), reason));
+ - + - ]
100 : :
101 [ + - + + : 25 : CMutableTransaction txTo[8]; // Spending transactions
- - ]
102 [ + + ]: 9 : for (int i = 0; i < 8; i++)
103 : : {
104 [ + - ]: 8 : txTo[i].vin.resize(1);
105 [ + - ]: 8 : txTo[i].vout.resize(1);
106 [ + - ]: 8 : txTo[i].vin[0].prevout.n = i;
107 [ + - ]: 8 : txTo[i].vin[0].prevout.hash = txFrom.GetHash();
108 : 8 : txTo[i].vout[0].nValue = 1;
109 : : }
110 [ + + ]: 9 : for (int i = 0; i < 8; i++)
111 : : {
112 : 8 : SignatureData empty;
113 [ + - + - : 24 : BOOST_CHECK_MESSAGE(SignSignature(keystore, CTransaction(txFrom), txTo[i], 0, SIGHASH_ALL, empty), strprintf("SignSignature %d", i));
+ - + - +
- ]
114 : 8 : }
115 : : // All of the above should be OK, and the txTos have valid signatures
116 : : // Check to make sure signature verification fails if we use the wrong ScriptSig:
117 [ + - ]: 1 : SignatureCache signature_cache{DEFAULT_SIGNATURE_CACHE_BYTES};
118 [ + + ]: 9 : for (int i = 0; i < 8; i++) {
119 [ + - ]: 8 : PrecomputedTransactionData txdata(txTo[i]);
120 [ + + ]: 72 : for (int j = 0; j < 8; j++)
121 : : {
122 : 64 : CScript sigSave = txTo[i].vin[0].scriptSig;
123 : 64 : txTo[i].vin[0].scriptSig = txTo[j].vin[0].scriptSig;
124 [ + - + - ]: 64 : bool sigOK = CScriptCheck(txFrom.vout[txTo[i].vin[0].prevout.n], CTransaction(txTo[i]), signature_cache, 0, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC, false, &txdata)();
125 [ + + ]: 64 : if (i == j)
126 [ + - + - : 16 : BOOST_CHECK_MESSAGE(sigOK, strprintf("VerifySignature %d %d", i, j));
+ - ]
127 : : else
128 [ + - + - : 112 : BOOST_CHECK_MESSAGE(!sigOK, strprintf("VerifySignature %d %d", i, j));
+ - ]
129 : 64 : txTo[i].vin[0].scriptSig = sigSave;
130 : 64 : }
131 : 8 : }
132 [ + + + + : 26 : }
+ + + + -
- - - - -
- - ]
133 : :
134 [ + - + - : 7 : BOOST_AUTO_TEST_CASE(norecurse)
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- ]
135 : : {
136 : 1 : ScriptError err;
137 : : // Make sure only the outer pay-to-script-hash does the
138 : : // extra-validation thing:
139 : 1 : CScript invalidAsScript;
140 [ + - + - ]: 1 : invalidAsScript << OP_INVALIDOPCODE << OP_INVALIDOPCODE;
141 : :
142 [ + - + - ]: 1 : CScript p2sh = GetScriptForDestination(ScriptHash(invalidAsScript));
143 : :
144 : 1 : CScript scriptSig;
145 [ + - ]: 1 : scriptSig << Serialize(invalidAsScript);
146 : :
147 : : // Should not verify, because it will try to execute OP_INVALIDOPCODE
148 [ + - + - : 2 : BOOST_CHECK(!Verify(scriptSig, p2sh, true, err));
+ - + - ]
149 [ + - + - : 2 : BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_BAD_OPCODE, ScriptErrorString(err));
+ - ]
150 : :
151 : : // Try to recur, and verification should succeed because
152 : : // the inner HASH160 <> EQUAL should only check the hash:
153 [ + - + - ]: 1 : CScript p2sh2 = GetScriptForDestination(ScriptHash(p2sh));
154 : 1 : CScript scriptSig2;
155 [ + - + - ]: 1 : scriptSig2 << Serialize(invalidAsScript) << Serialize(p2sh);
156 : :
157 [ + - + - : 2 : BOOST_CHECK(Verify(scriptSig2, p2sh2, true, err));
+ - + - ]
158 [ + - + - : 2 : BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
+ - ]
159 : 1 : }
160 : :
161 [ + - + - : 7 : BOOST_AUTO_TEST_CASE(set)
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- ]
162 : : {
163 : : // Test the CScript::Set* methods
164 : 1 : FillableSigningProvider keystore;
165 : 4 : CKey key[4];
166 : 1 : std::vector<CPubKey> keys;
167 [ + - ]: 1 : keys.reserve(4);
168 [ + + ]: 5 : for (int i = 0; i < 4; i++)
169 : : {
170 [ + - ]: 4 : key[i].MakeNewKey(true);
171 [ + - + - : 8 : BOOST_CHECK(keystore.AddKey(key[i]));
+ - + - ]
172 [ + - ]: 8 : keys.push_back(key[i].GetPubKey());
173 : : }
174 : :
175 : 4 : CScript inner[4];
176 [ + - + - : 2 : inner[0] = GetScriptForDestination(PKHash(key[0].GetPubKey()));
+ - ]
177 [ + - + - : 2 : inner[1] = GetScriptForMultisig(2, std::vector<CPubKey>(keys.begin(), keys.begin()+2));
+ - ]
178 [ + - + - : 2 : inner[2] = GetScriptForMultisig(1, std::vector<CPubKey>(keys.begin(), keys.begin()+2));
+ - ]
179 [ + - + - ]: 2 : inner[3] = GetScriptForMultisig(2, std::vector<CPubKey>(keys.begin(), keys.begin()+3));
180 : :
181 : 5 : CScript outer[4];
182 [ + + ]: 5 : for (int i = 0; i < 4; i++)
183 : : {
184 [ + - + - ]: 4 : outer[i] = GetScriptForDestination(ScriptHash(inner[i]));
185 [ + - + - : 8 : BOOST_CHECK(keystore.AddCScript(inner[i]));
+ - ]
186 : : }
187 : :
188 [ + - ]: 1 : CMutableTransaction txFrom; // Funding transaction:
189 [ + - ]: 1 : std::string reason;
190 [ + - ]: 1 : txFrom.vout.resize(4);
191 [ + + ]: 5 : for (int i = 0; i < 4; i++)
192 : : {
193 : 4 : txFrom.vout[i].scriptPubKey = outer[i];
194 : 4 : txFrom.vout[i].nValue = CENT;
195 : : }
196 [ + - + - : 3 : BOOST_CHECK(IsStandardTx(CTransaction(txFrom), reason));
+ - + - ]
197 : :
198 [ + - + + : 13 : CMutableTransaction txTo[4]; // Spending transactions
- - ]
199 [ + + ]: 5 : for (int i = 0; i < 4; i++)
200 : : {
201 [ + - ]: 4 : txTo[i].vin.resize(1);
202 [ + - ]: 4 : txTo[i].vout.resize(1);
203 [ + - ]: 4 : txTo[i].vin[0].prevout.n = i;
204 [ + - ]: 4 : txTo[i].vin[0].prevout.hash = txFrom.GetHash();
205 : 4 : txTo[i].vout[0].nValue = 1*CENT;
206 : 4 : txTo[i].vout[0].scriptPubKey = inner[i];
207 : : }
208 [ + + ]: 5 : for (int i = 0; i < 4; i++)
209 : : {
210 : 4 : SignatureData empty;
211 [ + - + - : 12 : BOOST_CHECK_MESSAGE(SignSignature(keystore, CTransaction(txFrom), txTo[i], 0, SIGHASH_ALL, empty), strprintf("SignSignature %d", i));
+ - + - +
- ]
212 [ + - + - : 12 : BOOST_CHECK_MESSAGE(IsStandardTx(CTransaction(txTo[i]), /*permit_bare_multisig=*/true, reason), strprintf("txTo[%d].IsStandard", i));
+ - + - +
- ]
213 [ + - + - ]: 4 : bool no_pbms_is_std = IsStandardTx(CTransaction(txTo[i]), /*permit_bare_multisig=*/false, reason);
214 [ + - + - : 8 : BOOST_CHECK_MESSAGE((i == 0 ? no_pbms_is_std : !no_pbms_is_std), strprintf("txTo[%d].IsStandard(permbaremulti=false)", i));
+ + + - ]
215 : 4 : }
216 [ + + + + : 22 : }
+ + + + -
- - - - -
- - ]
217 : :
218 [ + - + - : 7 : BOOST_AUTO_TEST_CASE(is)
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- ]
219 : : {
220 : : // Test CScript::IsPayToScriptHash()
221 : 1 : uint160 dummy;
222 : 1 : CScript p2sh;
223 [ + - + - : 1 : p2sh << OP_HASH160 << ToByteVector(dummy) << OP_EQUAL;
+ - ]
224 [ + - + - : 2 : BOOST_CHECK(p2sh.IsPayToScriptHash());
+ - + - ]
225 : :
226 [ + - ]: 1 : std::vector<unsigned char> direct = {OP_HASH160, 20};
227 [ + - ]: 1 : direct.insert(direct.end(), 20, 0);
228 [ + - ]: 1 : direct.push_back(OP_EQUAL);
229 [ + - + - : 2 : BOOST_CHECK(CScript(direct.begin(), direct.end()).IsPayToScriptHash());
+ - + - ]
230 : :
231 : : // Not considered pay-to-script-hash if using one of the OP_PUSHDATA opcodes:
232 [ + - ]: 1 : std::vector<unsigned char> pushdata1 = {OP_HASH160, OP_PUSHDATA1, 20};
233 [ + - ]: 1 : pushdata1.insert(pushdata1.end(), 20, 0);
234 [ + - ]: 1 : pushdata1.push_back(OP_EQUAL);
235 [ + - + - : 2 : BOOST_CHECK(!CScript(pushdata1.begin(), pushdata1.end()).IsPayToScriptHash());
+ - + - ]
236 [ + - ]: 1 : std::vector<unsigned char> pushdata2 = {OP_HASH160, OP_PUSHDATA2, 20, 0};
237 [ + - ]: 1 : pushdata2.insert(pushdata2.end(), 20, 0);
238 [ + - ]: 1 : pushdata2.push_back(OP_EQUAL);
239 [ + - + - : 2 : BOOST_CHECK(!CScript(pushdata2.begin(), pushdata2.end()).IsPayToScriptHash());
+ - + - ]
240 [ + - ]: 1 : std::vector<unsigned char> pushdata4 = {OP_HASH160, OP_PUSHDATA4, 20, 0, 0, 0};
241 [ + - ]: 1 : pushdata4.insert(pushdata4.end(), 20, 0);
242 [ + - ]: 1 : pushdata4.push_back(OP_EQUAL);
243 [ + - + - : 2 : BOOST_CHECK(!CScript(pushdata4.begin(), pushdata4.end()).IsPayToScriptHash());
+ - + - ]
244 : :
245 : 1 : CScript not_p2sh;
246 [ + - + - : 2 : BOOST_CHECK(!not_p2sh.IsPayToScriptHash());
+ - ]
247 : :
248 [ + - + - : 2 : not_p2sh.clear(); not_p2sh << OP_HASH160 << ToByteVector(dummy) << ToByteVector(dummy) << OP_EQUAL;
+ - + - ]
249 [ + - + - : 2 : BOOST_CHECK(!not_p2sh.IsPayToScriptHash());
+ - ]
250 : :
251 [ + - + - : 1 : not_p2sh.clear(); not_p2sh << OP_NOP << ToByteVector(dummy) << OP_EQUAL;
+ - ]
252 [ + - + - : 2 : BOOST_CHECK(!not_p2sh.IsPayToScriptHash());
+ - ]
253 : :
254 [ + - + - : 1 : not_p2sh.clear(); not_p2sh << OP_HASH160 << ToByteVector(dummy) << OP_CHECKSIG;
+ - ]
255 [ + - + - : 2 : BOOST_CHECK(!not_p2sh.IsPayToScriptHash());
+ - ]
256 : 1 : }
257 : :
258 [ + - + - : 7 : BOOST_AUTO_TEST_CASE(switchover)
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- ]
259 : : {
260 : : // Test switch over code
261 : 1 : CScript notValid;
262 : 1 : ScriptError err;
263 [ + - + - : 1 : notValid << OP_11 << OP_12 << OP_EQUALVERIFY;
+ - ]
264 : 1 : CScript scriptSig;
265 [ + - ]: 1 : scriptSig << Serialize(notValid);
266 : :
267 [ + - + - ]: 1 : CScript fund = GetScriptForDestination(ScriptHash(notValid));
268 : :
269 : :
270 : : // Validation should succeed under old rules (hash is correct):
271 [ + - + - : 2 : BOOST_CHECK(Verify(scriptSig, fund, false, err));
+ - + - ]
272 [ + - + - : 2 : BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
+ - ]
273 : : // Fail under new:
274 [ + - + - : 2 : BOOST_CHECK(!Verify(scriptSig, fund, true, err));
+ - + - ]
275 [ + - + - : 2 : BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_EQUALVERIFY, ScriptErrorString(err));
+ - ]
276 : 1 : }
277 : :
278 [ + - + - : 7 : BOOST_AUTO_TEST_CASE(AreInputsStandard)
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- ]
279 : : {
280 : 1 : CCoinsView coinsDummy;
281 [ + - ]: 1 : CCoinsViewCache coins(&coinsDummy);
282 : 1 : FillableSigningProvider keystore;
283 : 6 : CKey key[6];
284 [ + + ]: 7 : for (int i = 0; i < 6; i++)
285 : : {
286 [ + - ]: 6 : key[i].MakeNewKey(true);
287 [ + - + - : 12 : BOOST_CHECK(keystore.AddKey(key[i]));
+ - ]
288 : : }
289 : 1 : std::vector<CPubKey> keys;
290 [ + - ]: 1 : keys.reserve(3);
291 [ + + ]: 4 : for (int i = 0; i < 3; i++)
292 [ + - ]: 6 : keys.push_back(key[i].GetPubKey());
293 : :
294 [ + - ]: 1 : CMutableTransaction txFrom;
295 [ + - ]: 1 : txFrom.vout.resize(7);
296 : :
297 : : // First three are standard:
298 [ + - + - : 1 : CScript pay1 = GetScriptForDestination(PKHash(key[0].GetPubKey()));
+ - ]
299 [ + - + - : 2 : BOOST_CHECK(keystore.AddCScript(pay1));
+ - + - ]
300 [ + - ]: 1 : CScript pay1of3 = GetScriptForMultisig(1, keys);
301 : :
302 [ + - + - ]: 1 : txFrom.vout[0].scriptPubKey = GetScriptForDestination(ScriptHash(pay1)); // P2SH (OP_CHECKSIG)
303 : 1 : txFrom.vout[0].nValue = 1000;
304 : 1 : txFrom.vout[1].scriptPubKey = pay1; // ordinary OP_CHECKSIG
305 : 1 : txFrom.vout[1].nValue = 2000;
306 : 1 : txFrom.vout[2].scriptPubKey = pay1of3; // ordinary OP_CHECKMULTISIG
307 [ + - ]: 1 : txFrom.vout[2].nValue = 3000;
308 : :
309 : : // vout[3] is complicated 1-of-3 AND 2-of-3
310 : : // ... that is OK if wrapped in P2SH:
311 : 1 : CScript oneAndTwo;
312 [ + - + - : 1 : oneAndTwo << OP_1 << ToByteVector(key[0].GetPubKey()) << ToByteVector(key[1].GetPubKey()) << ToByteVector(key[2].GetPubKey());
+ - + - +
- + - +
- ]
313 [ + - + - ]: 1 : oneAndTwo << OP_3 << OP_CHECKMULTISIGVERIFY;
314 [ + - + - : 1 : oneAndTwo << OP_2 << ToByteVector(key[3].GetPubKey()) << ToByteVector(key[4].GetPubKey()) << ToByteVector(key[5].GetPubKey());
+ - + - +
- + - +
- ]
315 [ + - + - ]: 1 : oneAndTwo << OP_3 << OP_CHECKMULTISIG;
316 [ + - + - : 2 : BOOST_CHECK(keystore.AddCScript(oneAndTwo));
+ - + - ]
317 [ + - + - ]: 1 : txFrom.vout[3].scriptPubKey = GetScriptForDestination(ScriptHash(oneAndTwo));
318 [ + - ]: 1 : txFrom.vout[3].nValue = 4000;
319 : :
320 : : // vout[4] is max sigops:
321 [ + - ]: 1 : CScript fifteenSigops; fifteenSigops << OP_1;
322 [ + + ]: 16 : for (unsigned i = 0; i < MAX_P2SH_SIGOPS; i++)
323 [ + - + - ]: 15 : fifteenSigops << ToByteVector(key[i%3].GetPubKey());
324 [ + - + - ]: 1 : fifteenSigops << OP_15 << OP_CHECKMULTISIG;
325 [ + - + - : 2 : BOOST_CHECK(keystore.AddCScript(fifteenSigops));
+ - + - ]
326 [ + - + - ]: 1 : txFrom.vout[4].scriptPubKey = GetScriptForDestination(ScriptHash(fifteenSigops));
327 [ + - ]: 1 : txFrom.vout[4].nValue = 5000;
328 : :
329 : : // vout[5/6] are non-standard because they exceed MAX_P2SH_SIGOPS
330 [ + - + - ]: 1 : CScript sixteenSigops; sixteenSigops << OP_16 << OP_CHECKMULTISIG;
331 [ + - + - : 2 : BOOST_CHECK(keystore.AddCScript(sixteenSigops));
+ - + - ]
332 [ + - + - ]: 1 : txFrom.vout[5].scriptPubKey = GetScriptForDestination(ScriptHash(sixteenSigops));
333 [ + - ]: 1 : txFrom.vout[5].nValue = 5000;
334 [ + - ]: 1 : CScript twentySigops; twentySigops << OP_CHECKMULTISIG;
335 [ + - + - : 2 : BOOST_CHECK(keystore.AddCScript(twentySigops));
+ - + - ]
336 [ + - + - ]: 1 : txFrom.vout[6].scriptPubKey = GetScriptForDestination(ScriptHash(twentySigops));
337 [ + - ]: 1 : txFrom.vout[6].nValue = 6000;
338 : :
339 [ + - + - ]: 1 : AddCoins(coins, CTransaction(txFrom), 0);
340 : :
341 [ + - ]: 1 : CMutableTransaction txTo;
342 [ + - ]: 1 : txTo.vout.resize(1);
343 [ + - + - : 1 : txTo.vout[0].scriptPubKey = GetScriptForDestination(PKHash(key[1].GetPubKey()));
+ - ]
344 : :
345 [ + - ]: 1 : txTo.vin.resize(5);
346 [ + + ]: 6 : for (int i = 0; i < 5; i++)
347 : : {
348 [ + - ]: 5 : txTo.vin[i].prevout.n = i;
349 [ + - ]: 5 : txTo.vin[i].prevout.hash = txFrom.GetHash();
350 : : }
351 : 1 : SignatureData empty;
352 [ + - + - : 3 : BOOST_CHECK(SignSignature(keystore, CTransaction(txFrom), txTo, 0, SIGHASH_ALL, empty));
+ - + - ]
353 : 1 : SignatureData empty_b;
354 [ + - + - : 3 : BOOST_CHECK(SignSignature(keystore, CTransaction(txFrom), txTo, 1, SIGHASH_ALL, empty_b));
+ - + - ]
355 : 1 : SignatureData empty_c;
356 [ + - + - : 3 : BOOST_CHECK(SignSignature(keystore, CTransaction(txFrom), txTo, 2, SIGHASH_ALL, empty_c));
+ - + - +
- ]
357 : : // SignSignature doesn't know how to sign these. We're
358 : : // not testing validating signatures, so just create
359 : : // dummy signatures that DO include the correct P2SH scripts:
360 [ + - + - : 2 : txTo.vin[3].scriptSig << OP_11 << OP_11 << std::vector<unsigned char>(oneAndTwo.begin(), oneAndTwo.end());
+ - + - +
- ]
361 [ + - + - : 2 : txTo.vin[4].scriptSig << std::vector<unsigned char>(fifteenSigops.begin(), fifteenSigops.end());
+ - ]
362 : :
363 [ + - + - : 3 : BOOST_CHECK(::AreInputsStandard(CTransaction(txTo), coins));
+ - + - +
- ]
364 : : // 22 P2SH sigops for all inputs (1 for vin[0], 6 for vin[3], 15 for vin[4]
365 [ + - + - : 1 : BOOST_CHECK_EQUAL(GetP2SHSigOpCount(CTransaction(txTo), coins), 22U);
+ - + - ]
366 : :
367 [ + - ]: 1 : CMutableTransaction txToNonStd1;
368 [ + - ]: 1 : txToNonStd1.vout.resize(1);
369 [ + - + - : 1 : txToNonStd1.vout[0].scriptPubKey = GetScriptForDestination(PKHash(key[1].GetPubKey()));
+ - ]
370 [ + - ]: 1 : txToNonStd1.vout[0].nValue = 1000;
371 [ + - ]: 1 : txToNonStd1.vin.resize(1);
372 [ + - ]: 1 : txToNonStd1.vin[0].prevout.n = 5;
373 [ + - ]: 1 : txToNonStd1.vin[0].prevout.hash = txFrom.GetHash();
374 [ - + + - : 1 : txToNonStd1.vin[0].scriptSig << std::vector<unsigned char>(sixteenSigops.begin(), sixteenSigops.end());
+ - ]
375 : :
376 [ + - + - : 3 : BOOST_CHECK(!::AreInputsStandard(CTransaction(txToNonStd1), coins));
+ - + - +
- ]
377 [ + - + - : 1 : BOOST_CHECK_EQUAL(GetP2SHSigOpCount(CTransaction(txToNonStd1), coins), 16U);
+ - + - ]
378 : :
379 [ + - ]: 1 : CMutableTransaction txToNonStd2;
380 [ + - ]: 1 : txToNonStd2.vout.resize(1);
381 [ + - + - : 1 : txToNonStd2.vout[0].scriptPubKey = GetScriptForDestination(PKHash(key[1].GetPubKey()));
+ - ]
382 [ + - ]: 1 : txToNonStd2.vout[0].nValue = 1000;
383 [ + - ]: 1 : txToNonStd2.vin.resize(1);
384 [ + - ]: 1 : txToNonStd2.vin[0].prevout.n = 6;
385 [ + - ]: 1 : txToNonStd2.vin[0].prevout.hash = txFrom.GetHash();
386 [ - + + - : 1 : txToNonStd2.vin[0].scriptSig << std::vector<unsigned char>(twentySigops.begin(), twentySigops.end());
+ - ]
387 : :
388 [ + - + - : 3 : BOOST_CHECK(!::AreInputsStandard(CTransaction(txToNonStd2), coins));
+ - + - +
- ]
389 [ + - + - : 2 : BOOST_CHECK_EQUAL(GetP2SHSigOpCount(CTransaction(txToNonStd2), coins), 20U);
+ - + - ]
390 [ + + - - ]: 11 : }
391 : :
392 : : BOOST_AUTO_TEST_SUITE_END()
|
