Projects : bitcoin : bitcoin_dumpblock_no_losers
1 | // Copyright (c) 2009-2010 Satoshi Nakamoto |
2 | // Copyright (c) 2011 The Bitcoin developers |
3 | // Distributed under the MIT/X11 software license, see the accompanying |
4 | // file license.txt or http://www.opensource.org/licenses/mit-license.php. |
5 | #ifndef H_BITCOIN_SCRIPT |
6 | #define H_BITCOIN_SCRIPT |
7 | |
8 | #include "base58.h" |
9 | #include "keystore.h" |
10 | |
11 | #include <string> |
12 | #include <vector> |
13 | |
14 | #include <boost/foreach.hpp> |
15 | |
16 | class CTransaction; |
17 | |
18 | enum |
19 | { |
20 | SIGHASH_ALL = 1, |
21 | SIGHASH_NONE = 2, |
22 | SIGHASH_SINGLE = 3, |
23 | SIGHASH_ANYONECANPAY = 0x80, |
24 | }; |
25 | |
26 | |
27 | |
28 | enum opcodetype |
29 | { |
30 | // push value |
31 | OP_0=0, |
32 | OP_FALSE=OP_0, |
33 | OP_PUSHDATA1=76, |
34 | OP_PUSHDATA2, |
35 | OP_PUSHDATA4, |
36 | OP_1NEGATE, |
37 | OP_RESERVED, |
38 | OP_1, |
39 | OP_TRUE=OP_1, |
40 | OP_2, |
41 | OP_3, |
42 | OP_4, |
43 | OP_5, |
44 | OP_6, |
45 | OP_7, |
46 | OP_8, |
47 | OP_9, |
48 | OP_10, |
49 | OP_11, |
50 | OP_12, |
51 | OP_13, |
52 | OP_14, |
53 | OP_15, |
54 | OP_16, |
55 | |
56 | // control |
57 | OP_NOP, |
58 | OP_VER, |
59 | OP_IF, |
60 | OP_NOTIF, |
61 | OP_VERIF, |
62 | OP_VERNOTIF, |
63 | OP_ELSE, |
64 | OP_ENDIF, |
65 | OP_VERIFY, |
66 | OP_RETURN, |
67 | |
68 | // stack ops |
69 | OP_TOALTSTACK, |
70 | OP_FROMALTSTACK, |
71 | OP_2DROP, |
72 | OP_2DUP, |
73 | OP_3DUP, |
74 | OP_2OVER, |
75 | OP_2ROT, |
76 | OP_2SWAP, |
77 | OP_IFDUP, |
78 | OP_DEPTH, |
79 | OP_DROP, |
80 | OP_DUP, |
81 | OP_NIP, |
82 | OP_OVER, |
83 | OP_PICK, |
84 | OP_ROLL, |
85 | OP_ROT, |
86 | OP_SWAP, |
87 | OP_TUCK, |
88 | |
89 | // splice ops |
90 | OP_CAT, |
91 | OP_SUBSTR, |
92 | OP_LEFT, |
93 | OP_RIGHT, |
94 | OP_SIZE, |
95 | |
96 | // bit logic |
97 | OP_INVERT, |
98 | OP_AND, |
99 | OP_OR, |
100 | OP_XOR, |
101 | OP_EQUAL, |
102 | OP_EQUALVERIFY, |
103 | OP_RESERVED1, |
104 | OP_RESERVED2, |
105 | |
106 | // numeric |
107 | OP_1ADD, |
108 | OP_1SUB, |
109 | OP_2MUL, |
110 | OP_2DIV, |
111 | OP_NEGATE, |
112 | OP_ABS, |
113 | OP_NOT, |
114 | OP_0NOTEQUAL, |
115 | |
116 | OP_ADD, |
117 | OP_SUB, |
118 | OP_MUL, |
119 | OP_DIV, |
120 | OP_MOD, |
121 | OP_LSHIFT, |
122 | OP_RSHIFT, |
123 | |
124 | OP_BOOLAND, |
125 | OP_BOOLOR, |
126 | OP_NUMEQUAL, |
127 | OP_NUMEQUALVERIFY, |
128 | OP_NUMNOTEQUAL, |
129 | OP_LESSTHAN, |
130 | OP_GREATERTHAN, |
131 | OP_LESSTHANOREQUAL, |
132 | OP_GREATERTHANOREQUAL, |
133 | OP_MIN, |
134 | OP_MAX, |
135 | |
136 | OP_WITHIN, |
137 | |
138 | // crypto |
139 | OP_RIPEMD160, |
140 | OP_SHA1, |
141 | OP_SHA256, |
142 | OP_HASH160, |
143 | OP_HASH256, |
144 | OP_CODESEPARATOR, |
145 | OP_CHECKSIG, |
146 | OP_CHECKSIGVERIFY, |
147 | OP_CHECKMULTISIG, |
148 | OP_CHECKMULTISIGVERIFY, |
149 | |
150 | // expansion |
151 | OP_NOP1, |
152 | OP_NOP2, |
153 | OP_NOP3, |
154 | OP_NOP4, |
155 | OP_NOP5, |
156 | OP_NOP6, |
157 | OP_NOP7, |
158 | OP_NOP8, |
159 | OP_NOP9, |
160 | OP_NOP10, |
161 | |
162 | |
163 | |
164 | // template matching params |
165 | OP_PUBKEYHASH = 0xfd, |
166 | OP_PUBKEY = 0xfe, |
167 | |
168 | OP_INVALIDOPCODE = 0xff, |
169 | }; |
170 | |
171 | |
172 | |
173 | |
174 | |
175 | |
176 | |
177 | |
178 | inline const char* GetOpName(opcodetype opcode) |
179 | { |
180 | switch (opcode) |
181 | { |
182 | // push value |
183 | case OP_0 : return "0"; |
184 | case OP_PUSHDATA1 : return "OP_PUSHDATA1"; |
185 | case OP_PUSHDATA2 : return "OP_PUSHDATA2"; |
186 | case OP_PUSHDATA4 : return "OP_PUSHDATA4"; |
187 | case OP_1NEGATE : return "-1"; |
188 | case OP_RESERVED : return "OP_RESERVED"; |
189 | case OP_1 : return "1"; |
190 | case OP_2 : return "2"; |
191 | case OP_3 : return "3"; |
192 | case OP_4 : return "4"; |
193 | case OP_5 : return "5"; |
194 | case OP_6 : return "6"; |
195 | case OP_7 : return "7"; |
196 | case OP_8 : return "8"; |
197 | case OP_9 : return "9"; |
198 | case OP_10 : return "10"; |
199 | case OP_11 : return "11"; |
200 | case OP_12 : return "12"; |
201 | case OP_13 : return "13"; |
202 | case OP_14 : return "14"; |
203 | case OP_15 : return "15"; |
204 | case OP_16 : return "16"; |
205 | |
206 | // control |
207 | case OP_NOP : return "OP_NOP"; |
208 | case OP_VER : return "OP_VER"; |
209 | case OP_IF : return "OP_IF"; |
210 | case OP_NOTIF : return "OP_NOTIF"; |
211 | case OP_VERIF : return "OP_VERIF"; |
212 | case OP_VERNOTIF : return "OP_VERNOTIF"; |
213 | case OP_ELSE : return "OP_ELSE"; |
214 | case OP_ENDIF : return "OP_ENDIF"; |
215 | case OP_VERIFY : return "OP_VERIFY"; |
216 | case OP_RETURN : return "OP_RETURN"; |
217 | |
218 | // stack ops |
219 | case OP_TOALTSTACK : return "OP_TOALTSTACK"; |
220 | case OP_FROMALTSTACK : return "OP_FROMALTSTACK"; |
221 | case OP_2DROP : return "OP_2DROP"; |
222 | case OP_2DUP : return "OP_2DUP"; |
223 | case OP_3DUP : return "OP_3DUP"; |
224 | case OP_2OVER : return "OP_2OVER"; |
225 | case OP_2ROT : return "OP_2ROT"; |
226 | case OP_2SWAP : return "OP_2SWAP"; |
227 | case OP_IFDUP : return "OP_IFDUP"; |
228 | case OP_DEPTH : return "OP_DEPTH"; |
229 | case OP_DROP : return "OP_DROP"; |
230 | case OP_DUP : return "OP_DUP"; |
231 | case OP_NIP : return "OP_NIP"; |
232 | case OP_OVER : return "OP_OVER"; |
233 | case OP_PICK : return "OP_PICK"; |
234 | case OP_ROLL : return "OP_ROLL"; |
235 | case OP_ROT : return "OP_ROT"; |
236 | case OP_SWAP : return "OP_SWAP"; |
237 | case OP_TUCK : return "OP_TUCK"; |
238 | |
239 | // splice ops |
240 | case OP_CAT : return "OP_CAT"; |
241 | case OP_SUBSTR : return "OP_SUBSTR"; |
242 | case OP_LEFT : return "OP_LEFT"; |
243 | case OP_RIGHT : return "OP_RIGHT"; |
244 | case OP_SIZE : return "OP_SIZE"; |
245 | |
246 | // bit logic |
247 | case OP_INVERT : return "OP_INVERT"; |
248 | case OP_AND : return "OP_AND"; |
249 | case OP_OR : return "OP_OR"; |
250 | case OP_XOR : return "OP_XOR"; |
251 | case OP_EQUAL : return "OP_EQUAL"; |
252 | case OP_EQUALVERIFY : return "OP_EQUALVERIFY"; |
253 | case OP_RESERVED1 : return "OP_RESERVED1"; |
254 | case OP_RESERVED2 : return "OP_RESERVED2"; |
255 | |
256 | // numeric |
257 | case OP_1ADD : return "OP_1ADD"; |
258 | case OP_1SUB : return "OP_1SUB"; |
259 | case OP_2MUL : return "OP_2MUL"; |
260 | case OP_2DIV : return "OP_2DIV"; |
261 | case OP_NEGATE : return "OP_NEGATE"; |
262 | case OP_ABS : return "OP_ABS"; |
263 | case OP_NOT : return "OP_NOT"; |
264 | case OP_0NOTEQUAL : return "OP_0NOTEQUAL"; |
265 | case OP_ADD : return "OP_ADD"; |
266 | case OP_SUB : return "OP_SUB"; |
267 | case OP_MUL : return "OP_MUL"; |
268 | case OP_DIV : return "OP_DIV"; |
269 | case OP_MOD : return "OP_MOD"; |
270 | case OP_LSHIFT : return "OP_LSHIFT"; |
271 | case OP_RSHIFT : return "OP_RSHIFT"; |
272 | case OP_BOOLAND : return "OP_BOOLAND"; |
273 | case OP_BOOLOR : return "OP_BOOLOR"; |
274 | case OP_NUMEQUAL : return "OP_NUMEQUAL"; |
275 | case OP_NUMEQUALVERIFY : return "OP_NUMEQUALVERIFY"; |
276 | case OP_NUMNOTEQUAL : return "OP_NUMNOTEQUAL"; |
277 | case OP_LESSTHAN : return "OP_LESSTHAN"; |
278 | case OP_GREATERTHAN : return "OP_GREATERTHAN"; |
279 | case OP_LESSTHANOREQUAL : return "OP_LESSTHANOREQUAL"; |
280 | case OP_GREATERTHANOREQUAL : return "OP_GREATERTHANOREQUAL"; |
281 | case OP_MIN : return "OP_MIN"; |
282 | case OP_MAX : return "OP_MAX"; |
283 | case OP_WITHIN : return "OP_WITHIN"; |
284 | |
285 | // crypto |
286 | case OP_RIPEMD160 : return "OP_RIPEMD160"; |
287 | case OP_SHA1 : return "OP_SHA1"; |
288 | case OP_SHA256 : return "OP_SHA256"; |
289 | case OP_HASH160 : return "OP_HASH160"; |
290 | case OP_HASH256 : return "OP_HASH256"; |
291 | case OP_CODESEPARATOR : return "OP_CODESEPARATOR"; |
292 | case OP_CHECKSIG : return "OP_CHECKSIG"; |
293 | case OP_CHECKSIGVERIFY : return "OP_CHECKSIGVERIFY"; |
294 | case OP_CHECKMULTISIG : return "OP_CHECKMULTISIG"; |
295 | case OP_CHECKMULTISIGVERIFY : return "OP_CHECKMULTISIGVERIFY"; |
296 | |
297 | // expanson |
298 | case OP_NOP1 : return "OP_NOP1"; |
299 | case OP_NOP2 : return "OP_NOP2"; |
300 | case OP_NOP3 : return "OP_NOP3"; |
301 | case OP_NOP4 : return "OP_NOP4"; |
302 | case OP_NOP5 : return "OP_NOP5"; |
303 | case OP_NOP6 : return "OP_NOP6"; |
304 | case OP_NOP7 : return "OP_NOP7"; |
305 | case OP_NOP8 : return "OP_NOP8"; |
306 | case OP_NOP9 : return "OP_NOP9"; |
307 | case OP_NOP10 : return "OP_NOP10"; |
308 | |
309 | |
310 | |
311 | // template matching params |
312 | case OP_PUBKEYHASH : return "OP_PUBKEYHASH"; |
313 | case OP_PUBKEY : return "OP_PUBKEY"; |
314 | |
315 | case OP_INVALIDOPCODE : return "OP_INVALIDOPCODE"; |
316 | default: |
317 | return "OP_UNKNOWN"; |
318 | } |
319 | }; |
320 | |
321 | |
322 | |
323 | |
324 | inline std::string ValueString(const std::vector<unsigned char>& vch) |
325 | { |
326 | if (vch.size() <= 4) |
327 | return strprintf("%d", CBigNum(vch).getint()); |
328 | else |
329 | return HexStr(vch); |
330 | } |
331 | |
332 | inline std::string StackString(const std::vector<std::vector<unsigned char> >& vStack) |
333 | { |
334 | std::string str; |
335 | BOOST_FOREACH(const std::vector<unsigned char>& vch, vStack) |
336 | { |
337 | if (!str.empty()) |
338 | str += " "; |
339 | str += ValueString(vch); |
340 | } |
341 | return str; |
342 | } |
343 | |
344 | |
345 | |
346 | |
347 | |
348 | |
349 | |
350 | |
351 | |
352 | class CScript : public std::vector<unsigned char> |
353 | { |
354 | protected: |
355 | CScript& push_int64(int64 n) |
356 | { |
357 | if (n == -1 || (n >= 1 && n <= 16)) |
358 | { |
359 | push_back(n + (OP_1 - 1)); |
360 | } |
361 | else |
362 | { |
363 | CBigNum bn(n); |
364 | *this << bn.getvch(); |
365 | } |
366 | return *this; |
367 | } |
368 | |
369 | CScript& push_uint64(uint64 n) |
370 | { |
371 | if (n >= 1 && n <= 16) |
372 | { |
373 | push_back(n + (OP_1 - 1)); |
374 | } |
375 | else |
376 | { |
377 | CBigNum bn(n); |
378 | *this << bn.getvch(); |
379 | } |
380 | return *this; |
381 | } |
382 | |
383 | public: |
384 | CScript() { } |
385 | CScript(const CScript& b) : std::vector<unsigned char>(b.begin(), b.end()) { } |
386 | CScript(const_iterator pbegin, const_iterator pend) : std::vector<unsigned char>(pbegin, pend) { } |
387 | CScript(const unsigned char* pbegin, const unsigned char* pend) : std::vector<unsigned char>(pbegin, pend) { } |
388 | |
389 | CScript& operator+=(const CScript& b) |
390 | { |
391 | insert(end(), b.begin(), b.end()); |
392 | return *this; |
393 | } |
394 | |
395 | friend CScript operator+(const CScript& a, const CScript& b) |
396 | { |
397 | CScript ret = a; |
398 | ret += b; |
399 | return ret; |
400 | } |
401 | |
402 | |
403 | explicit CScript(char b) { operator<<(b); } |
404 | explicit CScript(short b) { operator<<(b); } |
405 | explicit CScript(int b) { operator<<(b); } |
406 | explicit CScript(long b) { operator<<(b); } |
407 | explicit CScript(int64 b) { operator<<(b); } |
408 | explicit CScript(unsigned char b) { operator<<(b); } |
409 | explicit CScript(unsigned int b) { operator<<(b); } |
410 | explicit CScript(unsigned short b) { operator<<(b); } |
411 | explicit CScript(unsigned long b) { operator<<(b); } |
412 | explicit CScript(uint64 b) { operator<<(b); } |
413 | |
414 | explicit CScript(opcodetype b) { operator<<(b); } |
415 | explicit CScript(const uint256& b) { operator<<(b); } |
416 | explicit CScript(const CBigNum& b) { operator<<(b); } |
417 | explicit CScript(const std::vector<unsigned char>& b) { operator<<(b); } |
418 | |
419 | |
420 | CScript& operator<<(char b) { return push_int64(b); } |
421 | CScript& operator<<(short b) { return push_int64(b); } |
422 | CScript& operator<<(int b) { return push_int64(b); } |
423 | CScript& operator<<(long b) { return push_int64(b); } |
424 | CScript& operator<<(int64 b) { return push_int64(b); } |
425 | CScript& operator<<(unsigned char b) { return push_uint64(b); } |
426 | CScript& operator<<(unsigned int b) { return push_uint64(b); } |
427 | CScript& operator<<(unsigned short b) { return push_uint64(b); } |
428 | CScript& operator<<(unsigned long b) { return push_uint64(b); } |
429 | CScript& operator<<(uint64 b) { return push_uint64(b); } |
430 | |
431 | CScript& operator<<(opcodetype opcode) |
432 | { |
433 | if (opcode < 0 || opcode > 0xff) |
434 | throw std::runtime_error("CScript::operator<<() : invalid opcode"); |
435 | insert(end(), (unsigned char)opcode); |
436 | return *this; |
437 | } |
438 | |
439 | CScript& operator<<(const uint160& b) |
440 | { |
441 | insert(end(), sizeof(b)); |
442 | insert(end(), (unsigned char*)&b, (unsigned char*)&b + sizeof(b)); |
443 | return *this; |
444 | } |
445 | |
446 | CScript& operator<<(const uint256& b) |
447 | { |
448 | insert(end(), sizeof(b)); |
449 | insert(end(), (unsigned char*)&b, (unsigned char*)&b + sizeof(b)); |
450 | return *this; |
451 | } |
452 | |
453 | CScript& operator<<(const CBigNum& b) |
454 | { |
455 | *this << b.getvch(); |
456 | return *this; |
457 | } |
458 | |
459 | CScript& operator<<(const std::vector<unsigned char>& b) |
460 | { |
461 | if (b.size() < OP_PUSHDATA1) |
462 | { |
463 | insert(end(), (unsigned char)b.size()); |
464 | } |
465 | else if (b.size() <= 0xff) |
466 | { |
467 | insert(end(), OP_PUSHDATA1); |
468 | insert(end(), (unsigned char)b.size()); |
469 | } |
470 | else if (b.size() <= 0xffff) |
471 | { |
472 | insert(end(), OP_PUSHDATA2); |
473 | unsigned short nSize = b.size(); |
474 | insert(end(), (unsigned char*)&nSize, (unsigned char*)&nSize + sizeof(nSize)); |
475 | } |
476 | else |
477 | { |
478 | insert(end(), OP_PUSHDATA4); |
479 | unsigned int nSize = b.size(); |
480 | insert(end(), (unsigned char*)&nSize, (unsigned char*)&nSize + sizeof(nSize)); |
481 | } |
482 | insert(end(), b.begin(), b.end()); |
483 | return *this; |
484 | } |
485 | |
486 | CScript& operator<<(const CScript& b) |
487 | { |
488 | // I'm not sure if this should push the script or concatenate scripts. |
489 | // If there's ever a use for pushing a script onto a script, delete this member fn |
490 | assert(!"warning: pushing a CScript onto a CScript with << is probably not intended, use + to concatenate"); |
491 | return *this; |
492 | } |
493 | |
494 | |
495 | bool GetOp(iterator& pc, opcodetype& opcodeRet, std::vector<unsigned char>& vchRet) |
496 | { |
497 | // Wrapper so it can be called with either iterator or const_iterator |
498 | const_iterator pc2 = pc; |
499 | bool fRet = GetOp2(pc2, opcodeRet, &vchRet); |
500 | pc = begin() + (pc2 - begin()); |
501 | return fRet; |
502 | } |
503 | |
504 | bool GetOp(iterator& pc, opcodetype& opcodeRet) |
505 | { |
506 | const_iterator pc2 = pc; |
507 | bool fRet = GetOp2(pc2, opcodeRet, NULL); |
508 | pc = begin() + (pc2 - begin()); |
509 | return fRet; |
510 | } |
511 | |
512 | bool GetOp(const_iterator& pc, opcodetype& opcodeRet, std::vector<unsigned char>& vchRet) const |
513 | { |
514 | return GetOp2(pc, opcodeRet, &vchRet); |
515 | } |
516 | |
517 | bool GetOp(const_iterator& pc, opcodetype& opcodeRet) const |
518 | { |
519 | return GetOp2(pc, opcodeRet, NULL); |
520 | } |
521 | |
522 | bool GetOp2(const_iterator& pc, opcodetype& opcodeRet, std::vector<unsigned char>* pvchRet) const |
523 | { |
524 | opcodeRet = OP_INVALIDOPCODE; |
525 | if (pvchRet) |
526 | pvchRet->clear(); |
527 | if (pc >= end()) |
528 | return false; |
529 | |
530 | // Read instruction |
531 | if (end() - pc < 1) |
532 | return false; |
533 | unsigned int opcode = *pc++; |
534 | |
535 | // Immediate operand |
536 | if (opcode <= OP_PUSHDATA4) |
537 | { |
538 | unsigned int nSize; |
539 | if (opcode < OP_PUSHDATA1) |
540 | { |
541 | nSize = opcode; |
542 | } |
543 | else if (opcode == OP_PUSHDATA1) |
544 | { |
545 | if (end() - pc < 1) |
546 | return false; |
547 | nSize = *pc++; |
548 | } |
549 | else if (opcode == OP_PUSHDATA2) |
550 | { |
551 | if (end() - pc < 2) |
552 | return false; |
553 | nSize = 0; |
554 | memcpy(&nSize, &pc[0], 2); |
555 | pc += 2; |
556 | } |
557 | else if (opcode == OP_PUSHDATA4) |
558 | { |
559 | if (end() - pc < 4) |
560 | return false; |
561 | memcpy(&nSize, &pc[0], 4); |
562 | pc += 4; |
563 | } |
564 | if (end() - pc < nSize) |
565 | return false; |
566 | if (pvchRet) |
567 | pvchRet->assign(pc, pc + nSize); |
568 | pc += nSize; |
569 | } |
570 | |
571 | opcodeRet = (opcodetype)opcode; |
572 | return true; |
573 | } |
574 | |
575 | |
576 | void FindAndDelete(const CScript& b) |
577 | { |
578 | if (b.empty()) |
579 | return; |
580 | iterator pc = begin(); |
581 | opcodetype opcode; |
582 | do |
583 | { |
584 | while (end() - pc >= b.size() && memcmp(&pc[0], &b[0], b.size()) == 0) |
585 | erase(pc, pc + b.size()); |
586 | } |
587 | while (GetOp(pc, opcode)); |
588 | } |
589 | |
590 | |
591 | int GetSigOpCount() const |
592 | { |
593 | int n = 0; |
594 | const_iterator pc = begin(); |
595 | while (pc < end()) |
596 | { |
597 | opcodetype opcode; |
598 | if (!GetOp(pc, opcode)) |
599 | break; |
600 | if (opcode == OP_CHECKSIG || opcode == OP_CHECKSIGVERIFY) |
601 | n++; |
602 | else if (opcode == OP_CHECKMULTISIG || opcode == OP_CHECKMULTISIGVERIFY) |
603 | n += 20; |
604 | } |
605 | return n; |
606 | } |
607 | |
608 | |
609 | bool IsPushOnly() const |
610 | { |
611 | if (size() > 200) |
612 | return false; |
613 | const_iterator pc = begin(); |
614 | while (pc < end()) |
615 | { |
616 | opcodetype opcode; |
617 | if (!GetOp(pc, opcode)) |
618 | return false; |
619 | if (opcode > OP_16) |
620 | return false; |
621 | } |
622 | return true; |
623 | } |
624 | |
625 | |
626 | CBitcoinAddress GetBitcoinAddress() const |
627 | { |
628 | opcodetype opcode; |
629 | std::vector<unsigned char> vch; |
630 | CScript::const_iterator pc = begin(); |
631 | if (!GetOp(pc, opcode, vch) || opcode != OP_DUP) return 0; |
632 | if (!GetOp(pc, opcode, vch) || opcode != OP_HASH160) return 0; |
633 | if (!GetOp(pc, opcode, vch) || vch.size() != sizeof(uint160)) return 0; |
634 | uint160 hash160 = uint160(vch); |
635 | if (!GetOp(pc, opcode, vch) || opcode != OP_EQUALVERIFY) return 0; |
636 | if (!GetOp(pc, opcode, vch) || opcode != OP_CHECKSIG) return 0; |
637 | if (pc != end()) return 0; |
638 | return CBitcoinAddress(hash160); |
639 | } |
640 | |
641 | void SetBitcoinAddress(const CBitcoinAddress& address) |
642 | { |
643 | this->clear(); |
644 | *this << OP_DUP << OP_HASH160 << address.GetHash160() << OP_EQUALVERIFY << OP_CHECKSIG; |
645 | } |
646 | |
647 | void SetBitcoinAddress(const std::vector<unsigned char>& vchPubKey) |
648 | { |
649 | SetBitcoinAddress(CBitcoinAddress(vchPubKey)); |
650 | } |
651 | |
652 | |
653 | void PrintHex() const |
654 | { |
655 | printf("CScript(%s)\n", HexStr(begin(), end(), true).c_str()); |
656 | } |
657 | |
658 | std::string ToString() const |
659 | { |
660 | std::string str; |
661 | opcodetype opcode; |
662 | std::vector<unsigned char> vch; |
663 | const_iterator pc = begin(); |
664 | while (pc < end()) |
665 | { |
666 | if (!str.empty()) |
667 | str += " "; |
668 | if (!GetOp(pc, opcode, vch)) |
669 | { |
670 | str += "[error]"; |
671 | return str; |
672 | } |
673 | if (0 <= opcode && opcode <= OP_PUSHDATA4) |
674 | str += ValueString(vch); |
675 | else |
676 | str += GetOpName(opcode); |
677 | } |
678 | return str; |
679 | } |
680 | |
681 | void print() const |
682 | { |
683 | printf("%s\n", ToString().c_str()); |
684 | } |
685 | }; |
686 | |
687 | |
688 | |
689 | |
690 | |
691 | |
692 | |
693 | bool EvalScript(std::vector<std::vector<unsigned char> >& stack, const CScript& script, const CTransaction& txTo, unsigned int nIn, int nHashType); |
694 | |
695 | bool IsStandard(const CScript& scriptPubKey); |
696 | bool IsMine(const CKeyStore& keystore, const CScript& scriptPubKey); |
697 | bool ExtractAddress(const CScript& scriptPubKey, const CKeyStore* pkeystore, CBitcoinAddress& addressRet); |
698 | bool SignSignature(const CKeyStore& keystore, const CTransaction& txFrom, CTransaction& txTo, unsigned int nIn, int nHashType=SIGHASH_ALL, CScript scriptPrereq=CScript()); |
699 | bool VerifySignature(const CTransaction& txFrom, const CTransaction& txTo, unsigned int nIn, int nHashType=0); |
700 | |
701 | #endif |