src/script.h

   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 COPYING 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 #ifndef _MSC_VER
 388     CScript(const unsigned char* pbegin, const unsigned char* pend) : std::vector<unsigned char>(pbegin, pend) { }
 389 #endif
 390
 391     CScript& operator+=(const CScript& b)
 392     {
 393         insert(end(), b.begin(), b.end());
 394         return *this;
 395     }
 396
 397     friend CScript operator+(const CScript& a, const CScript& b)
 398     {
 399         CScript ret = a;
 400         ret += b;
 401         return ret;
 402     }
 403
 404
 405     //explicit CScript(char b) is not portable.  Use 'signed char' or 'unsigned char'.
 406     explicit CScript(signed char b)    { operator<<(b); }
 407     explicit CScript(short b)          { operator<<(b); }
 408     explicit CScript(int b)            { operator<<(b); }
 409     explicit CScript(long b)           { operator<<(b); }
 410     explicit CScript(int64 b)          { operator<<(b); }
 411     explicit CScript(unsigned char b)  { operator<<(b); }
 412     explicit CScript(unsigned int b)   { operator<<(b); }
 413     explicit CScript(unsigned short b) { operator<<(b); }
 414     explicit CScript(unsigned long b)  { operator<<(b); }
 415     explicit CScript(uint64 b)         { operator<<(b); }
 416
 417     explicit CScript(opcodetype b)     { operator<<(b); }
 418     explicit CScript(const uint256& b) { operator<<(b); }
 419     explicit CScript(const CBigNum& b) { operator<<(b); }
 420     explicit CScript(const std::vector<unsigned char>& b) { operator<<(b); }
 421
 422
 423     //CScript& operator<<(char b) is not portable.  Use 'signed char' or 'unsigned char'.
 424     CScript& operator<<(signed char b)    { return push_int64(b); }
 425     CScript& operator<<(short b)          { return push_int64(b); }
 426     CScript& operator<<(int b)            { return push_int64(b); }
 427     CScript& operator<<(long b)           { return push_int64(b); }
 428     CScript& operator<<(int64 b)          { return push_int64(b); }
 429     CScript& operator<<(unsigned char b)  { return push_uint64(b); }
 430     CScript& operator<<(unsigned int b)   { return push_uint64(b); }
 431     CScript& operator<<(unsigned short b) { return push_uint64(b); }
 432     CScript& operator<<(unsigned long b)  { return push_uint64(b); }
 433     CScript& operator<<(uint64 b)         { return push_uint64(b); }
 434
 435     CScript& operator<<(opcodetype opcode)
 436     {
 437         if (opcode < 0 || opcode > 0xff)
 438             throw std::runtime_error("CScript::operator<<() : invalid opcode");
 439         insert(end(), (unsigned char)opcode);
 440         return *this;
 441     }
 442
 443     CScript& operator<<(const uint160& b)
 444     {
 445         insert(end(), sizeof(b));
 446         insert(end(), (unsigned char*)&b, (unsigned char*)&b + sizeof(b));
 447         return *this;
 448     }
 449
 450     CScript& operator<<(const uint256& b)
 451     {
 452         insert(end(), sizeof(b));
 453         insert(end(), (unsigned char*)&b, (unsigned char*)&b + sizeof(b));
 454         return *this;
 455     }
 456
 457     CScript& operator<<(const CBigNum& b)
 458     {
 459         *this << b.getvch();
 460         return *this;
 461     }
 462
 463     CScript& operator<<(const std::vector<unsigned char>& b)
 464     {
 465         if (b.size() < OP_PUSHDATA1)
 466         {
 467             insert(end(), (unsigned char)b.size());
 468         }
 469         else if (b.size() <= 0xff)
 470         {
 471             insert(end(), OP_PUSHDATA1);
 472             insert(end(), (unsigned char)b.size());
 473         }
 474         else if (b.size() <= 0xffff)
 475         {
 476             insert(end(), OP_PUSHDATA2);
 477             unsigned short nSize = b.size();
 478             insert(end(), (unsigned char*)&nSize, (unsigned char*)&nSize + sizeof(nSize));
 479         }
 480         else
 481         {
 482             insert(end(), OP_PUSHDATA4);
 483             unsigned int nSize = b.size();
 484             insert(end(), (unsigned char*)&nSize, (unsigned char*)&nSize + sizeof(nSize));
 485         }
 486         insert(end(), b.begin(), b.end());
 487         return *this;
 488     }
 489
 490     CScript& operator<<(const CScript& b)
 491     {
 492         // I'm not sure if this should push the script or concatenate scripts.
 493         // If there's ever a use for pushing a script onto a script, delete this member fn
 494         assert(!"warning: pushing a CScript onto a CScript with << is probably not intended, use + to concatenate");
 495         return *this;
 496     }
 497
 498
 499     bool GetOp(iterator& pc, opcodetype& opcodeRet, std::vector<unsigned char>& vchRet)
 500     {
 501          // Wrapper so it can be called with either iterator or const_iterator
 502          const_iterator pc2 = pc;
 503          bool fRet = GetOp2(pc2, opcodeRet, &vchRet);
 504          pc = begin() + (pc2 - begin());
 505          return fRet;
 506     }
 507
 508     bool GetOp(iterator& pc, opcodetype& opcodeRet)
 509     {
 510          const_iterator pc2 = pc;
 511          bool fRet = GetOp2(pc2, opcodeRet, NULL);
 512          pc = begin() + (pc2 - begin());
 513          return fRet;
 514     }
 515
 516     bool GetOp(const_iterator& pc, opcodetype& opcodeRet, std::vector<unsigned char>& vchRet) const
 517     {
 518         return GetOp2(pc, opcodeRet, &vchRet);
 519     }
 520
 521     bool GetOp(const_iterator& pc, opcodetype& opcodeRet) const
 522     {
 523         return GetOp2(pc, opcodeRet, NULL);
 524     }
 525
 526     bool GetOp2(const_iterator& pc, opcodetype& opcodeRet, std::vector<unsigned char>* pvchRet) const
 527     {
 528         opcodeRet = OP_INVALIDOPCODE;
 529         if (pvchRet)
 530             pvchRet->clear();
 531         if (pc >= end())
 532             return false;
 533
 534         // Read instruction
 535         if (end() - pc < 1)
 536             return false;
 537         unsigned int opcode = *pc++;
 538
 539         // Immediate operand
 540         if (opcode <= OP_PUSHDATA4)
 541         {
 542             unsigned int nSize;
 543             if (opcode < OP_PUSHDATA1)
 544             {
 545                 nSize = opcode;
 546             }
 547             else if (opcode == OP_PUSHDATA1)
 548             {
 549                 if (end() - pc < 1)
 550                     return false;
 551                 nSize = *pc++;
 552             }
 553             else if (opcode == OP_PUSHDATA2)
 554             {
 555                 if (end() - pc < 2)
 556                     return false;
 557                 nSize = 0;
 558                 memcpy(&nSize, &pc[0], 2);
 559                 pc += 2;
 560             }
 561             else if (opcode == OP_PUSHDATA4)
 562             {
 563                 if (end() - pc < 4)
 564                     return false;
 565                 memcpy(&nSize, &pc[0], 4);
 566                 pc += 4;
 567             }
 568             if (end() - pc < nSize)
 569                 return false;
 570             if (pvchRet)
 571                 pvchRet->assign(pc, pc + nSize);
 572             pc += nSize;
 573         }
 574
 575         opcodeRet = (opcodetype)opcode;
 576         return true;
 577     }
 578
 579     // Encode/decode small integers:
 580     static int DecodeOP_N(opcodetype opcode)
 581     {
 582         if (opcode == OP_0)
 583             return 0;
 584         assert(opcode >= OP_1 && opcode <= OP_16);
 585         return (int)opcode - (int)(OP_1 - 1);
 586     }
 587
 588     void FindAndDelete(const CScript& b)
 589     {
 590         if (b.empty())
 591             return;
 592         iterator pc = begin();
 593         opcodetype opcode;
 594         do
 595         {
 596             while (end() - pc >= b.size() && memcmp(&pc[0], &b[0], b.size()) == 0)
 597                 erase(pc, pc + b.size());
 598         }
 599         while (GetOp(pc, opcode));
 600     }
 601     int Find(opcodetype op) const
 602     {
 603         int nFound = 0;
 604         opcodetype opcode;
 605         for (const_iterator pc = begin(); pc != end() && GetOp(pc, opcode);)
 606             if (opcode == op)
 607                 ++nFound;
 608         return nFound;
 609     }
 610
 611     // Pre-version-0.6, Bitcoin always counted CHECKMULTISIGs
 612     // as 20 sigops. With pay-to-script-hash, that changed:
 613     // CHECKMULTISIGs serialized in scriptSigs are
 614     // counted more accurately, assuming they are of the form
 615     //  ... OP_N CHECKMULTISIG ...
 616     int GetSigOpCount(bool fAccurate=false) const;
 617
 618     // Accurately count sigOps, including sigOps in
 619     // pay-to-script-hash transactions:
 620     int GetSigOpCount(const CScript& scriptSig) const;
 621
 622     bool IsPayToScriptHash() const;
 623
 624     bool IsPushOnly() const
 625     {
 626         const_iterator pc = begin();
 627         while (pc < end())
 628         {
 629             opcodetype opcode;
 630             if (!GetOp(pc, opcode))
 631                 return false;
 632             if (opcode > OP_16)
 633                 return false;
 634         }
 635         return true;
 636     }
 637
 638
 639     CBitcoinAddress GetBitcoinAddress() const
 640     {
 641         opcodetype opcode;
 642         std::vector<unsigned char> vch;
 643         CScript::const_iterator pc = begin();
 644         if (!GetOp(pc, opcode, vch) || opcode != OP_DUP) return 0;
 645         if (!GetOp(pc, opcode, vch) || opcode != OP_HASH160) return 0;
 646         if (!GetOp(pc, opcode, vch) || vch.size() != sizeof(uint160)) return 0;
 647         uint160 hash160 = uint160(vch);
 648         if (!GetOp(pc, opcode, vch) || opcode != OP_EQUALVERIFY) return 0;
 649         if (!GetOp(pc, opcode, vch) || opcode != OP_CHECKSIG) return 0;
 650         if (pc != end()) return 0;
 651         return CBitcoinAddress(hash160);
 652     }
 653
 654     void SetBitcoinAddress(const CBitcoinAddress& address)
 655     {
 656         this->clear();
 657         *this << OP_DUP << OP_HASH160 << address.GetHash160() << OP_EQUALVERIFY << OP_CHECKSIG;
 658     }
 659
 660     void SetBitcoinAddress(const std::vector<unsigned char>& vchPubKey)
 661     {
 662         SetBitcoinAddress(CBitcoinAddress(vchPubKey));
 663     }
 664
 665
 666     void PrintHex() const
 667     {
 668         printf("CScript(%s)\n", HexStr(begin(), end(), true).c_str());
 669     }
 670
 671     std::string ToString() const
 672     {
 673         std::string str;
 674         opcodetype opcode;
 675         std::vector<unsigned char> vch;
 676         const_iterator pc = begin();
 677         while (pc < end())
 678         {
 679             if (!str.empty())
 680                 str += " ";
 681             if (!GetOp(pc, opcode, vch))
 682             {
 683                 str += "[error]";
 684                 return str;
 685             }
 686             if (0 <= opcode && opcode <= OP_PUSHDATA4)
 687                 str += ValueString(vch);
 688             else
 689                 str += GetOpName(opcode);
 690         }
 691         return str;
 692     }
 693
 694     void print() const
 695     {
 696         printf("%s\n", ToString().c_str());
 697     }
 698 };
 699
 700
 701
 702
 703
 704
 705
 706 bool EvalScript(std::vector<std::vector<unsigned char> >& stack, const CScript& script, const CTransaction& txTo, unsigned int nIn, int nHashType);
 707
 708 bool IsStandard(const CScript& scriptPubKey);
 709 bool IsMine(const CKeyStore& keystore, const CScript& scriptPubKey);
 710 bool ExtractAddress(const CScript& scriptPubKey, const CKeyStore* pkeystore, CBitcoinAddress& addressRet);
 711 bool SignSignature(const CKeyStore& keystore, const CTransaction& txFrom, CTransaction& txTo, unsigned int nIn, int nHashType=SIGHASH_ALL, CScript scriptPrereq=CScript());
 712 bool VerifySignature(const CTransaction& txFrom, const CTransaction& txTo, unsigned int nIn, bool fValidatePayToScriptHash, int nHashType);
 713
 714 #endif