text: // Copyright (c) 2009-2010 Satoshi Nakamoto
  // Copyright (c) 2011 The Bitcoin developers
  // Distributed under the MIT/X11 software license, see the accompanying
  // file license.txt or http://www.opensource.org/licenses/mit-license.php.
  #ifndef H_BITCOIN_SCRIPT
  #define H_BITCOIN_SCRIPT
  
  #include "base58.h"
  #include "keystore.h"
  
  #include <string>
  #include <vector>
  
  #include <boost/foreach.hpp>
  
  class CTransaction;
  
  enum
  {
      SIGHASH_ALL = 1,
      SIGHASH_NONE = 2,
      SIGHASH_SINGLE = 3,
      SIGHASH_ANYONECANPAY = 0x80,
  };
  
  
  
  enum opcodetype
  {
      // push value
      OP_0=0,
      OP_FALSE=OP_0,
      OP_PUSHDATA1=76,
      OP_PUSHDATA2,
      OP_PUSHDATA4,
      OP_1NEGATE,
      OP_RESERVED,
      OP_1,
      OP_TRUE=OP_1,
      OP_2,
      OP_3,
      OP_4,
      OP_5,
      OP_6,
      OP_7,
      OP_8,
      OP_9,
      OP_10,
      OP_11,
      OP_12,
      OP_13,
      OP_14,
      OP_15,
      OP_16,
  
      // control
      OP_NOP,
      OP_VER,
      OP_IF,
      OP_NOTIF,
      OP_VERIF,
      OP_VERNOTIF,
      OP_ELSE,
      OP_ENDIF,
      OP_VERIFY,
      OP_RETURN,
  
      // stack ops
      OP_TOALTSTACK,
      OP_FROMALTSTACK,
      OP_2DROP,
      OP_2DUP,
      OP_3DUP,
      OP_2OVER,
      OP_2ROT,
      OP_2SWAP,
      OP_IFDUP,
      OP_DEPTH,
      OP_DROP,
      OP_DUP,
      OP_NIP,
      OP_OVER,
      OP_PICK,
      OP_ROLL,
      OP_ROT,
      OP_SWAP,
      OP_TUCK,
  
      // splice ops
      OP_CAT,
      OP_SUBSTR,
      OP_LEFT,
      OP_RIGHT,
      OP_SIZE,
  
      // bit logic
      OP_INVERT,
      OP_AND,
      OP_OR,
      OP_XOR,
      OP_EQUAL,
      OP_EQUALVERIFY,
      OP_RESERVED1,
      OP_RESERVED2,
  
      // numeric
      OP_1ADD,
      OP_1SUB,
      OP_2MUL,
      OP_2DIV,
      OP_NEGATE,
      OP_ABS,
      OP_NOT,
      OP_0NOTEQUAL,
  
      OP_ADD,
      OP_SUB,
      OP_MUL,
      OP_DIV,
      OP_MOD,
      OP_LSHIFT,
      OP_RSHIFT,
  
      OP_BOOLAND,
      OP_BOOLOR,
      OP_NUMEQUAL,
      OP_NUMEQUALVERIFY,
      OP_NUMNOTEQUAL,
      OP_LESSTHAN,
      OP_GREATERTHAN,
      OP_LESSTHANOREQUAL,
      OP_GREATERTHANOREQUAL,
      OP_MIN,
      OP_MAX,
  
      OP_WITHIN,
  
      // crypto
      OP_RIPEMD160,
      OP_SHA1,
      OP_SHA256,
      OP_HASH160,
      OP_HASH256,
      OP_CODESEPARATOR,
      OP_CHECKSIG,
      OP_CHECKSIGVERIFY,
      OP_CHECKMULTISIG,
      OP_CHECKMULTISIGVERIFY,
  
      // expansion
      OP_NOP1,
      OP_NOP2,
      OP_NOP3,
      OP_NOP4,
      OP_NOP5,
      OP_NOP6,
      OP_NOP7,
      OP_NOP8,
      OP_NOP9,
      OP_NOP10,
  
  
  
      // template matching params
      OP_PUBKEYHASH = 0xfd,
      OP_PUBKEY = 0xfe,
  
      OP_INVALIDOPCODE = 0xff,
  };
  
  
  
  
  
  
  
  
  inline const char* GetOpName(opcodetype opcode)
  {
      switch (opcode)
      {
      // push value
      case OP_0                      : return "0";
      case OP_PUSHDATA1              : return "OP_PUSHDATA1";
      case OP_PUSHDATA2              : return "OP_PUSHDATA2";
      case OP_PUSHDATA4              : return "OP_PUSHDATA4";
      case OP_1NEGATE                : return "-1";
      case OP_RESERVED               : return "OP_RESERVED";
      case OP_1                      : return "1";
      case OP_2                      : return "2";
      case OP_3                      : return "3";
      case OP_4                      : return "4";
      case OP_5                      : return "5";
      case OP_6                      : return "6";
      case OP_7                      : return "7";
      case OP_8                      : return "8";
      case OP_9                      : return "9";
      case OP_10                     : return "10";
      case OP_11                     : return "11";
      case OP_12                     : return "12";
      case OP_13                     : return "13";
      case OP_14                     : return "14";
      case OP_15                     : return "15";
      case OP_16                     : return "16";
  
      // control
      case OP_NOP                    : return "OP_NOP";
      case OP_VER                    : return "OP_VER";
      case OP_IF                     : return "OP_IF";
      case OP_NOTIF                  : return "OP_NOTIF";
      case OP_VERIF                  : return "OP_VERIF";
      case OP_VERNOTIF               : return "OP_VERNOTIF";
      case OP_ELSE                   : return "OP_ELSE";
      case OP_ENDIF                  : return "OP_ENDIF";
      case OP_VERIFY                 : return "OP_VERIFY";
      case OP_RETURN                 : return "OP_RETURN";
  
      // stack ops
      case OP_TOALTSTACK             : return "OP_TOALTSTACK";
      case OP_FROMALTSTACK           : return "OP_FROMALTSTACK";
      case OP_2DROP                  : return "OP_2DROP";
      case OP_2DUP                   : return "OP_2DUP";
      case OP_3DUP                   : return "OP_3DUP";
      case OP_2OVER                  : return "OP_2OVER";
      case OP_2ROT                   : return "OP_2ROT";
      case OP_2SWAP                  : return "OP_2SWAP";
      case OP_IFDUP                  : return "OP_IFDUP";
      case OP_DEPTH                  : return "OP_DEPTH";
      case OP_DROP                   : return "OP_DROP";
      case OP_DUP                    : return "OP_DUP";
      case OP_NIP                    : return "OP_NIP";
      case OP_OVER                   : return "OP_OVER";
      case OP_PICK                   : return "OP_PICK";
      case OP_ROLL                   : return "OP_ROLL";
      case OP_ROT                    : return "OP_ROT";
      case OP_SWAP                   : return "OP_SWAP";
      case OP_TUCK                   : return "OP_TUCK";
  
      // splice ops
      case OP_CAT                    : return "OP_CAT";
      case OP_SUBSTR                 : return "OP_SUBSTR";
      case OP_LEFT                   : return "OP_LEFT";
      case OP_RIGHT                  : return "OP_RIGHT";
      case OP_SIZE                   : return "OP_SIZE";
  
      // bit logic
      case OP_INVERT                 : return "OP_INVERT";
      case OP_AND                    : return "OP_AND";
      case OP_OR                     : return "OP_OR";
      case OP_XOR                    : return "OP_XOR";
      case OP_EQUAL                  : return "OP_EQUAL";
      case OP_EQUALVERIFY            : return "OP_EQUALVERIFY";
      case OP_RESERVED1              : return "OP_RESERVED1";
      case OP_RESERVED2              : return "OP_RESERVED2";
  
      // numeric
      case OP_1ADD                   : return "OP_1ADD";
      case OP_1SUB                   : return "OP_1SUB";
      case OP_2MUL                   : return "OP_2MUL";
      case OP_2DIV                   : return "OP_2DIV";
      case OP_NEGATE                 : return "OP_NEGATE";
      case OP_ABS                    : return "OP_ABS";
      case OP_NOT                    : return "OP_NOT";
      case OP_0NOTEQUAL              : return "OP_0NOTEQUAL";
      case OP_ADD                    : return "OP_ADD";
      case OP_SUB                    : return "OP_SUB";
      case OP_MUL                    : return "OP_MUL";
      case OP_DIV                    : return "OP_DIV";
      case OP_MOD                    : return "OP_MOD";
      case OP_LSHIFT                 : return "OP_LSHIFT";
      case OP_RSHIFT                 : return "OP_RSHIFT";
      case OP_BOOLAND                : return "OP_BOOLAND";
      case OP_BOOLOR                 : return "OP_BOOLOR";
      case OP_NUMEQUAL               : return "OP_NUMEQUAL";
      case OP_NUMEQUALVERIFY         : return "OP_NUMEQUALVERIFY";
      case OP_NUMNOTEQUAL            : return "OP_NUMNOTEQUAL";
      case OP_LESSTHAN               : return "OP_LESSTHAN";
      case OP_GREATERTHAN            : return "OP_GREATERTHAN";
      case OP_LESSTHANOREQUAL        : return "OP_LESSTHANOREQUAL";
      case OP_GREATERTHANOREQUAL     : return "OP_GREATERTHANOREQUAL";
      case OP_MIN                    : return "OP_MIN";
      case OP_MAX                    : return "OP_MAX";
      case OP_WITHIN                 : return "OP_WITHIN";
  
      // crypto
      case OP_RIPEMD160              : return "OP_RIPEMD160";
      case OP_SHA1                   : return "OP_SHA1";
      case OP_SHA256                 : return "OP_SHA256";
      case OP_HASH160                : return "OP_HASH160";
      case OP_HASH256                : return "OP_HASH256";
      case OP_CODESEPARATOR          : return "OP_CODESEPARATOR";
      case OP_CHECKSIG               : return "OP_CHECKSIG";
      case OP_CHECKSIGVERIFY         : return "OP_CHECKSIGVERIFY";
      case OP_CHECKMULTISIG          : return "OP_CHECKMULTISIG";
      case OP_CHECKMULTISIGVERIFY    : return "OP_CHECKMULTISIGVERIFY";
  
      // expanson
      case OP_NOP1                   : return "OP_NOP1";
      case OP_NOP2                   : return "OP_NOP2";
      case OP_NOP3                   : return "OP_NOP3";
      case OP_NOP4                   : return "OP_NOP4";
      case OP_NOP5                   : return "OP_NOP5";
      case OP_NOP6                   : return "OP_NOP6";
      case OP_NOP7                   : return "OP_NOP7";
      case OP_NOP8                   : return "OP_NOP8";
      case OP_NOP9                   : return "OP_NOP9";
      case OP_NOP10                  : return "OP_NOP10";
  
  
  
      // template matching params
      case OP_PUBKEYHASH             : return "OP_PUBKEYHASH";
      case OP_PUBKEY                 : return "OP_PUBKEY";
  
      case OP_INVALIDOPCODE          : return "OP_INVALIDOPCODE";
      default:
          return "OP_UNKNOWN";
      }
  };
  
  
  
  
  inline std::string ValueString(const std::vector<unsigned char>& vch)
  {
      if (vch.size() <= 4)
          return strprintf("%d", CBigNum(vch).getint());
      else
          return HexStr(vch);
  }
  
  inline std::string StackString(const std::vector<std::vector<unsigned char> >& vStack)
  {
      std::string str;
      BOOST_FOREACH(const std::vector<unsigned char>& vch, vStack)
      {
          if (!str.empty())
              str += " ";
          str += ValueString(vch);
      }
      return str;
  }
  
  
  
  
  
  
  
  
  
  class CScript : public std::vector<unsigned char>
  {
  protected:
      CScript& push_int64(int64 n)
      {
          if (n == -1 || (n >= 1 && n <= 16))
          {
              push_back(n + (OP_1 - 1));
          }
          else
          {
              CBigNum bn(n);
              *this << bn.getvch();
          }
          return *this;
      }
  
      CScript& push_uint64(uint64 n)
      {
          if (n >= 1 && n <= 16)
          {
              push_back(n + (OP_1 - 1));
          }
          else
          {
              CBigNum bn(n);
              *this << bn.getvch();
          }
          return *this;
      }
  
  public:
      CScript() { }
      CScript(const CScript& b) : std::vector<unsigned char>(b.begin(), b.end()) { }
      CScript(const_iterator pbegin, const_iterator pend) : std::vector<unsigned char>(pbegin, pend) { }
      CScript(const unsigned char* pbegin, const unsigned char* pend) : std::vector<unsigned char>(pbegin, pend) { }
  
      CScript& operator+=(const CScript& b)
      {
          insert(end(), b.begin(), b.end());
          return *this;
      }
  
      friend CScript operator+(const CScript& a, const CScript& b)
      {
          CScript ret = a;
          ret += b;
          return ret;
      }
  
  
      explicit CScript(char b)           { operator<<(b); }
      explicit CScript(short b)          { operator<<(b); }
      explicit CScript(int b)            { operator<<(b); }
      explicit CScript(long b)           { operator<<(b); }
      explicit CScript(int64 b)          { operator<<(b); }
      explicit CScript(unsigned char b)  { operator<<(b); }
      explicit CScript(unsigned int b)   { operator<<(b); }
      explicit CScript(unsigned short b) { operator<<(b); }
      explicit CScript(unsigned long b)  { operator<<(b); }
      explicit CScript(uint64 b)         { operator<<(b); }
  
      explicit CScript(opcodetype b)     { operator<<(b); }
      explicit CScript(const uint256& b) { operator<<(b); }
      explicit CScript(const CBigNum& b) { operator<<(b); }
      explicit CScript(const std::vector<unsigned char>& b) { operator<<(b); }
  
  
      CScript& operator<<(char b)           { return push_int64(b); }
      CScript& operator<<(short b)          { return push_int64(b); }
      CScript& operator<<(int b)            { return push_int64(b); }
      CScript& operator<<(long b)           { return push_int64(b); }
      CScript& operator<<(int64 b)          { return push_int64(b); }
      CScript& operator<<(unsigned char b)  { return push_uint64(b); }
      CScript& operator<<(unsigned int b)   { return push_uint64(b); }
      CScript& operator<<(unsigned short b) { return push_uint64(b); }
      CScript& operator<<(unsigned long b)  { return push_uint64(b); }
      CScript& operator<<(uint64 b)         { return push_uint64(b); }
  
      CScript& operator<<(opcodetype opcode)
      {
          if (opcode < 0 || opcode > 0xff)
              throw std::runtime_error("CScript::operator<<() : invalid opcode");
          insert(end(), (unsigned char)opcode);
          return *this;
      }
  
      CScript& operator<<(const uint160& b)
      {
          insert(end(), sizeof(b));
          insert(end(), (unsigned char*)&b, (unsigned char*)&b + sizeof(b));
          return *this;
      }
  
      CScript& operator<<(const uint256& b)
      {
          insert(end(), sizeof(b));
          insert(end(), (unsigned char*)&b, (unsigned char*)&b + sizeof(b));
          return *this;
      }
  
      CScript& operator<<(const CBigNum& b)
      {
          *this << b.getvch();
          return *this;
      }
  
      CScript& operator<<(const std::vector<unsigned char>& b)
      {
          if (b.size() < OP_PUSHDATA1)
          {
              insert(end(), (unsigned char)b.size());
          }
          else if (b.size() <= 0xff)
          {
              insert(end(), OP_PUSHDATA1);
              insert(end(), (unsigned char)b.size());
          }
          else if (b.size() <= 0xffff)
          {
              insert(end(), OP_PUSHDATA2);
              unsigned short nSize = b.size();
              insert(end(), (unsigned char*)&nSize, (unsigned char*)&nSize + sizeof(nSize));
          }
          else
          {
              insert(end(), OP_PUSHDATA4);
              unsigned int nSize = b.size();
              insert(end(), (unsigned char*)&nSize, (unsigned char*)&nSize + sizeof(nSize));
          }
          insert(end(), b.begin(), b.end());
          return *this;
      }
  
      CScript& operator<<(const CScript& b)
      {
          // I'm not sure if this should push the script or concatenate scripts.
          // If there's ever a use for pushing a script onto a script, delete this member fn
          assert(!"warning: pushing a CScript onto a CScript with << is probably not intended, use + to concatenate");
          return *this;
      }
  
  
      bool GetOp(iterator& pc, opcodetype& opcodeRet, std::vector<unsigned char>& vchRet)
      {
           // Wrapper so it can be called with either iterator or const_iterator
           const_iterator pc2 = pc;
           bool fRet = GetOp2(pc2, opcodeRet, &vchRet);
           pc = begin() + (pc2 - begin());
           return fRet;
      }
  
      bool GetOp(iterator& pc, opcodetype& opcodeRet)
      {
           const_iterator pc2 = pc;
           bool fRet = GetOp2(pc2, opcodeRet, NULL);
           pc = begin() + (pc2 - begin());
           return fRet;
      }
  
      bool GetOp(const_iterator& pc, opcodetype& opcodeRet, std::vector<unsigned char>& vchRet) const
      {
          return GetOp2(pc, opcodeRet, &vchRet);
      }
  
      bool GetOp(const_iterator& pc, opcodetype& opcodeRet) const
      {
          return GetOp2(pc, opcodeRet, NULL);
      }
  
      bool GetOp2(const_iterator& pc, opcodetype& opcodeRet, std::vector<unsigned char>* pvchRet) const
      {
          opcodeRet = OP_INVALIDOPCODE;
          if (pvchRet)
              pvchRet->clear();
          if (pc >= end())
              return false;
  
          // Read instruction
          if (end() - pc < 1)
              return false;
          unsigned int opcode = *pc++;
  
          // Immediate operand
          if (opcode <= OP_PUSHDATA4)
          {
              unsigned int nSize;
              if (opcode < OP_PUSHDATA1)
              {
                  nSize = opcode;
              }
              else if (opcode == OP_PUSHDATA1)
              {
                  if (end() - pc < 1)
                      return false;
                  nSize = *pc++;
              }
              else if (opcode == OP_PUSHDATA2)
              {
                  if (end() - pc < 2)
                      return false;
                  nSize = 0;
                  memcpy(&nSize, &pc[0], 2);
                  pc += 2;
              }
              else if (opcode == OP_PUSHDATA4)
              {
                  if (end() - pc < 4)
                      return false;
                  memcpy(&nSize, &pc[0], 4);
                  pc += 4;
              }
              if (end() - pc < nSize)
                  return false;
              if (pvchRet)
                  pvchRet->assign(pc, pc + nSize);
              pc += nSize;
          }
  
          opcodeRet = (opcodetype)opcode;
          return true;
      }
  
  
      void FindAndDelete(const CScript& b)
      {
          if (b.empty())
              return;
          iterator pc = begin();
          opcodetype opcode;
          do
          {
              while (end() - pc >= b.size() && memcmp(&pc[0], &b[0], b.size()) == 0)
                  erase(pc, pc + b.size());
          }
          while (GetOp(pc, opcode));
      }
  
  
      int GetSigOpCount() const
      {
          int n = 0;
          const_iterator pc = begin();
          while (pc < end())
          {
              opcodetype opcode;
              if (!GetOp(pc, opcode))
                  break;
              if (opcode == OP_CHECKSIG || opcode == OP_CHECKSIGVERIFY)
                  n++;
              else if (opcode == OP_CHECKMULTISIG || opcode == OP_CHECKMULTISIGVERIFY)
                  n += 20;
          }
          return n;
      }
  
  
      bool IsPushOnly() const
      {
          if (size() > 200)
              return false;
          const_iterator pc = begin();
          while (pc < end())
          {
              opcodetype opcode;
              if (!GetOp(pc, opcode))
                  return false;
              if (opcode > OP_16)
                  return false;
          }
          return true;
      }
  
  
      CBitcoinAddress GetBitcoinAddress() const
      {
          opcodetype opcode;
          std::vector<unsigned char> vch;
          CScript::const_iterator pc = begin();
          if (!GetOp(pc, opcode, vch) || opcode != OP_DUP) return 0;
          if (!GetOp(pc, opcode, vch) || opcode != OP_HASH160) return 0;
          if (!GetOp(pc, opcode, vch) || vch.size() != sizeof(uint160)) return 0;
          uint160 hash160 = uint160(vch);
          if (!GetOp(pc, opcode, vch) || opcode != OP_EQUALVERIFY) return 0;
          if (!GetOp(pc, opcode, vch) || opcode != OP_CHECKSIG) return 0;
          if (pc != end()) return 0;
          return CBitcoinAddress(hash160);
      }
  
      void SetBitcoinAddress(const CBitcoinAddress& address)
      {
          this->clear();
          *this << OP_DUP << OP_HASH160 << address.GetHash160() << OP_EQUALVERIFY << OP_CHECKSIG;
      }
  
      void SetBitcoinAddress(const std::vector<unsigned char>& vchPubKey)
      {
          SetBitcoinAddress(CBitcoinAddress(vchPubKey));
      }
  
  
      void PrintHex() const
      {
          printf("CScript(%s)\n", HexStr(begin(), end(), true).c_str());
      }
  
      std::string ToString() const
      {
          std::string str;
          opcodetype opcode;
          std::vector<unsigned char> vch;
          const_iterator pc = begin();
          while (pc < end())
          {
              if (!str.empty())
                  str += " ";
              if (!GetOp(pc, opcode, vch))
              {
                  str += "[error]";
                  return str;
              }
              if (0 <= opcode && opcode <= OP_PUSHDATA4)
                  str += ValueString(vch);
              else
                  str += GetOpName(opcode);
          }
          return str;
      }
  
      void print() const
      {
          printf("%s\n", ToString().c_str());
      }
  };
  
  
  
  
  
  
  
  bool EvalScript(std::vector<std::vector<unsigned char> >& stack, const CScript& script, const CTransaction& txTo, unsigned int nIn, int nHashType);
  
  bool IsStandard(const CScript& scriptPubKey);
  bool IsMine(const CKeyStore& keystore, const CScript& scriptPubKey);
  bool ExtractAddress(const CScript& scriptPubKey, const CKeyStore* pkeystore, CBitcoinAddress& addressRet);
  bool SignSignature(const CKeyStore& keystore, const CTransaction& txFrom, CTransaction& txTo, unsigned int nIn, int nHashType=SIGHASH_ALL, CScript scriptPrereq=CScript());
  bool VerifySignature(const CTransaction& txFrom, const CTransaction& txTo, unsigned int nIn, int nHashType=0);
  
  #endif