diff --git a/src/init.cpp b/src/init.cpp
index f09f044..1045610 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -496,21 +496,21 @@ bool AppInit2(int argc, char* argv[])
     fNoListen = !GetBoolArg("-listen", true);
 
     // This code can be removed once a super-majority of the network has upgraded.
-    if (GetBoolArg("-bip16", true))
+    if (GetBoolArg("-bip17", true))
     {
         if (fTestNet)
-            SoftSetArg("-paytoscripthashtime", "1329264000"); // Feb 15
+            SoftSetArg("-p2shtime", "1329264000"); // Feb 15
         else
-            SoftSetArg("-paytoscripthashtime", "1330578000"); // Mar 1
+            SoftSetArg("-p2shtime", "1332460800"); // Mar 23
 
         // Put "/P2SH/" in the coinbase so everybody can tell when
         // a majority of miners support it
-        const char* pszP2SH = "/P2SH/";
+        const char* pszP2SH = "p2sh/CHV";
         COINBASE_FLAGS << std::vector<unsigned char>(pszP2SH, pszP2SH+strlen(pszP2SH));
     }
     else
     {
-        const char* pszP2SH = "NOP2SH";
+        const char* pszP2SH = "p2sh/NOCHV";
         COINBASE_FLAGS << std::vector<unsigned char>(pszP2SH, pszP2SH+strlen(pszP2SH));
     }
 
diff --git a/src/main.cpp b/src/main.cpp
index b73037f..7d5c4f2 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -260,7 +260,7 @@ bool CTransaction::IsStandard() const
         // ~65-byte public keys, plus a few script ops.
         if (txin.scriptSig.size() > 500)
             return false;
-        if (!txin.scriptSig.IsPushOnly())
+        if (!::IsStandardInput(txin.scriptSig))
             return false;
     }
     BOOST_FOREACH(const CTxOut& txout, vout)
@@ -270,16 +270,16 @@ bool CTransaction::IsStandard() const
 }
 
 //
-// Check transaction inputs, and make sure any
-// pay-to-script-hash transactions are evaluating IsStandard scripts
+// Check transaction inputs, and make sure their scriptPubKeys are "standard"
 //
-// Why bother? To avoid denial-of-service attacks; an attacker
-// can submit a standard HASH... OP_EQUAL transaction,
-// which will get accepted into blocks. The redemption
-// script can be anything; an attacker could use a very
-// expensive-to-check-upon-redemption script like:
+// Why bother? To avoid denial-of-service attacks; an attacker can mine a
+// non-standard transaction with an expensive scriptPubKey, and then use a
+// standard transaction to trick a miner into executing it. For example:
 //   DUP CHECKSIG DROP ... repeated 100 times... OP_1
 //
+// Note that this does NOT check scriptSig, as that is already done execution
+// for the inputs.
+//
 bool CTransaction::AreInputsStandard(const MapPrevTx& mapInputs) const
 {
     if (IsCoinBase())
@@ -298,28 +298,12 @@ bool CTransaction::AreInputsStandard(const MapPrevTx& mapInputs) const
         int nArgsExpected = ScriptSigArgsExpected(whichType, vSolutions);
 
         // Transactions with extra stuff in their scriptSigs are
-        // non-standard. Note that this EvalScript() call will
-        // be quick, because if there are any operations
-        // beside "push data" in the scriptSig the
-        // IsStandard() call returns false
+        // non-standard.
         vector<vector<unsigned char> > stack;
-        if (!EvalScript(stack, vin[i].scriptSig, *this, i, 0))
+        std::vector<unsigned char> vchLastScript;
+        if (!EvalScript(stack, vin[i].scriptSig, *this, i, 0, true, vchLastScript))
             return false;
 
-        if (whichType == TX_SCRIPTHASH)
-        {
-            if (stack.empty())
-                return false;
-            CScript subscript(stack.back().begin(), stack.back().end());
-            vector<vector<unsigned char> > vSolutions2;
-            txnouttype whichType2;
-            if (!Solver(subscript, whichType2, vSolutions2))
-                return false;
-            if (whichType2 == TX_SCRIPTHASH)
-                return false;
-            nArgsExpected += ScriptSigArgsExpected(whichType2, vSolutions2);
-        }
-
         if (stack.size() != nArgsExpected)
             return false;
     }
@@ -1086,15 +1070,14 @@ int CTransaction::GetP2SHSigOpCount(const MapPrevTx& inputs) const
     for (int i = 0; i < vin.size(); i++)
     {
         const CTxOut& prevout = GetOutputFor(vin[i], inputs);
-        if (prevout.scriptPubKey.IsPayToScriptHash())
-            nSigOps += prevout.scriptPubKey.GetSigOpCount(vin[i].scriptSig);
+        nSigOps += prevout.scriptPubKey.GetSigOpCount(true);
     }
     return nSigOps;
 }
 
 bool CTransaction::ConnectInputs(MapPrevTx inputs,
                                  map<uint256, CTxIndex>& mapTestPool, const CDiskTxPos& posThisTx,
-                                 const CBlockIndex* pindexBlock, bool fBlock, bool fMiner, bool fStrictPayToScriptHash)
+                                 const CBlockIndex* pindexBlock, bool fBlock, bool fMiner)
 {
     // Take over previous transactions' spent pointers
     // fBlock is true when this is called from AcceptBlock when a new best-block is added to the blockchain
@@ -1131,6 +1114,20 @@ bool CTransaction::ConnectInputs(MapPrevTx inputs,
             if (!MoneyRange(txPrev.vout[prevout.n].nValue) || !MoneyRange(nValueIn))
                 return DoS(100, error("ConnectInputs() : txin values out of range"));
 
+            bool fStrictPayToScriptHash = true;
+            if (fBlock)
+            {
+                // To avoid being on the short end of a block-chain split,
+                // don't do validation of pay-to-script-hash transactions
+                // until blocks with timestamps after p2shtime:
+                int64 nP2SHSwitchTime = GetArg("-p2shtime", std::numeric_limits<int64_t>::max());
+                fStrictPayToScriptHash = (pindexBlock->nTime >= nP2SHSwitchTime);
+            }
+            // if !fBlock, then always be strict-- don't accept
+            // invalid-under-new-rules pay-to-script-hash transactions into
+            // our memory pool (don't relay them, don't include them
+            // in blocks we mine).
+
             // Skip ECDSA signature verification when connecting blocks (fBlock=true)
             // before the last blockchain checkpoint. This is safe because block merkle hashes are
             // still computed and checked, and any change will be caught at the next checkpoint.
@@ -1241,13 +1238,6 @@ bool CBlock::ConnectBlock(CTxDB& txdb, CBlockIndex* pindex)
     if (!CheckBlock())
         return false;
 
-    // To avoid being on the short end of a block-chain split,
-    // don't do secondary validation of pay-to-script-hash transactions
-    // until blocks with timestamps after paytoscripthashtime (see init.cpp for default).
-    // This code can be removed once a super-majority of the network has upgraded.
-    int64 nEvalSwitchTime = GetArg("-paytoscripthashtime", std::numeric_limits<int64_t>::max());
-    bool fStrictPayToScriptHash = (pindex->nTime >= nEvalSwitchTime);
-
     //// issue here: it doesn't know the version
     unsigned int nTxPos = pindex->nBlockPos + ::GetSerializeSize(CBlock(), SER_DISK) - 1 + GetSizeOfCompactSize(vtx.size());
 
@@ -1270,19 +1260,9 @@ bool CBlock::ConnectBlock(CTxDB& txdb, CBlockIndex* pindex)
             if (!tx.FetchInputs(txdb, mapQueuedChanges, true, false, mapInputs, fInvalid))
                 return false;
 
-            if (fStrictPayToScriptHash)
-            {
-                // Add in sigops done by pay-to-script-hash inputs;
-                // this is to prevent a "rogue miner" from creating
-                // an incredibly-expensive-to-validate block.
-                nSigOps += tx.GetP2SHSigOpCount(mapInputs);
-                if (nSigOps > MAX_BLOCK_SIGOPS)
-                    return DoS(100, error("ConnectBlock() : too many sigops"));
-            }
-
             nFees += tx.GetValueIn(mapInputs)-tx.GetValueOut();
 
-            if (!tx.ConnectInputs(mapInputs, mapQueuedChanges, posThisTx, pindex, true, false, fStrictPayToScriptHash))
+            if (!tx.ConnectInputs(mapInputs, mapQueuedChanges, posThisTx, pindex, true, false))
                 return false;
         }
 
diff --git a/src/main.h b/src/main.h
index d9f976c..200e56a 100644
--- a/src/main.h
+++ b/src/main.h
@@ -696,12 +696,11 @@ public:
         @param[in] pindexBlock
         @param[in] fBlock	true if called from ConnectBlock
         @param[in] fMiner	true if called from CreateNewBlock
-        @param[in] fStrictPayToScriptHash	true if fully validating p2sh transactions
         @return Returns true if all checks succeed
      */
     bool ConnectInputs(MapPrevTx inputs,
                        std::map<uint256, CTxIndex>& mapTestPool, const CDiskTxPos& posThisTx,
-                       const CBlockIndex* pindexBlock, bool fBlock, bool fMiner, bool fStrictPayToScriptHash=true);
+                       const CBlockIndex* pindexBlock, bool fBlock, bool fMiner);
     bool ClientConnectInputs();
     bool CheckTransaction() const;
     bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true, bool* pfMissingInputs=NULL);
diff --git a/src/script.cpp b/src/script.cpp
index b6f1202..23610e6 100644
--- a/src/script.cpp
+++ b/src/script.cpp
@@ -205,7 +205,7 @@ const char* GetOpName(opcodetype opcode)
 
     // expanson
     case OP_NOP1                   : return "OP_NOP1";
-    case OP_NOP2                   : return "OP_NOP2";
+    case OP_CHECKHASHVERIFY        : return "OP_CHECKHASHVERIFY";
     case OP_NOP3                   : return "OP_NOP3";
     case OP_NOP4                   : return "OP_NOP4";
     case OP_NOP5                   : return "OP_NOP5";
@@ -218,6 +218,7 @@ const char* GetOpName(opcodetype opcode)
 
 
     // template matching params
+    case OP_SCRIPTHASH             : return "OP_SCRIPTHASH";
     case OP_PUBKEYHASH             : return "OP_PUBKEYHASH";
     case OP_PUBKEY                 : return "OP_PUBKEY";
 
@@ -227,7 +228,7 @@ const char* GetOpName(opcodetype opcode)
     }
 }
 
-bool EvalScript(vector<vector<unsigned char> >& stack, const CScript& script, const CTransaction& txTo, unsigned int nIn, int nHashType)
+bool EvalScript(vector<vector<unsigned char> >& stack, const CScript& script, const CTransaction& txTo, unsigned int nIn, int nHashType, bool fValidatePayToScriptHash, std::vector<unsigned char> &vchLastScript)
 {
     CAutoBN_CTX pctx;
     CScript::const_iterator pc = script.begin();
@@ -312,7 +313,7 @@ bool EvalScript(vector<vector<unsigned char> >& stack, const CScript& script, co
                 // Control
                 //
                 case OP_NOP:
-                case OP_NOP1: case OP_NOP2: case OP_NOP3: case OP_NOP4: case OP_NOP5:
+                case OP_NOP1: case OP_NOP3: case OP_NOP4: case OP_NOP5:
                 case OP_NOP6: case OP_NOP7: case OP_NOP8: case OP_NOP9: case OP_NOP10:
                 break;
 
@@ -928,6 +929,36 @@ bool EvalScript(vector<vector<unsigned char> >& stack, const CScript& script, co
                 }
                 break;
 
+                case OP_CHECKHASHVERIFY:
+                {
+                    // This was OP_NOP2 in old scripts
+                    if (!fValidatePayToScriptHash)
+                        break;
+
+                    if (stack.size() < 1)
+                        return false;
+
+                    // The only stack item here is what we expect the code to hash to
+                    valtype& vchHashCheck = stacktop(-1);
+
+                    // This hashes the code with RIPEMD160(SHA256(vchLastScript))
+                    valtype vchHash(20);
+                    {
+                        uint160 hash160 = Hash160(vchLastScript);
+                        memcpy(&vchHash[0], &hash160, sizeof(hash160));
+                    }
+
+                    bool fEqual = (vchHash == vchHashCheck);
+
+                    // Don't pop anything off the stack, for backward compatibility
+
+                    if (!fEqual)
+                        // If the hash doesn't match, abort
+                        return false;
+                    // If the hash matches, we're good: act like OP_NOP2 for compatibility
+                }
+                break;
+
                 case OP_CHECKMULTISIG:
                 case OP_CHECKMULTISIGVERIFY:
                 {
@@ -1009,6 +1040,9 @@ bool EvalScript(vector<vector<unsigned char> >& stack, const CScript& script, co
             if (stack.size() + altstack.size() > 1000)
                 return false;
         }
+
+        // Save the last code segment (from the last executed OP_CODESEPARATOR onward)
+        vchLastScript = std::vector<unsigned char>(pbegincodehash, pend);
     }
     catch (...)
     {
@@ -1137,16 +1171,9 @@ bool Solver(const CScript& scriptPubKey, txnouttype& typeRet, vector<vector<unsi
 
         // Sender provides N pubkeys, receivers provides M signatures
         mTemplates.insert(make_pair(TX_MULTISIG, CScript() << OP_SMALLINTEGER << OP_PUBKEYS << OP_SMALLINTEGER << OP_CHECKMULTISIG));
-    }
 
-    // Shortcut for pay-to-script-hash, which are more constrained than the other types:
-    // it is always OP_HASH160 20 [20 byte hash] OP_EQUAL
-    if (scriptPubKey.IsPayToScriptHash())
-    {
-        typeRet = TX_SCRIPTHASH;
-        vector<unsigned char> hashBytes(scriptPubKey.begin()+2, scriptPubKey.begin()+22);
-        vSolutionsRet.push_back(hashBytes);
-        return true;
+        // Push-to-script-hash txn, sender provides hash of verification script, receiver provides script
+        mTemplates.insert(make_pair(TX_SCRIPTHASH, CScript() << OP_SCRIPTHASH << OP_CHECKHASHVERIFY << OP_DROP));
     }
 
     // Scan templates
@@ -1221,6 +1248,12 @@ bool Solver(const CScript& scriptPubKey, txnouttype& typeRet, vector<vector<unsi
                 else
                     break;
             }
+            else if (opcode2 == OP_SCRIPTHASH)
+            {
+                if (vch1.size() != sizeof(uint160))
+                    break;
+                vSolutionsRet.push_back(vch1);
+            }
             else if (opcode1 != opcode2 || vch1 != vch2)
             {
                 // Others must match exactly
@@ -1327,7 +1360,7 @@ int ScriptSigArgsExpected(txnouttype t, const std::vector<std::vector<unsigned c
             return -1;
         return vSolutions[0][0] + 1;
     case TX_SCRIPTHASH:
-        return 1; // doesn't include args needed by the script
+        return 1;
     }
     return -1;
 }
@@ -1353,6 +1386,37 @@ bool IsStandard(const CScript& scriptPubKey)
     return whichType != TX_NONSTANDARD;
 }
 
+bool IsStandardInput(const CScript& scriptSig)
+{
+    CScript::const_iterator pc = scriptSig.begin();
+    CScript::const_iterator pend = scriptSig.end();
+    CScript::const_iterator pcodesep = pend;
+    CScript::const_iterator pafter;
+    opcodetype opcode;
+
+    for ( ; pc < pend; pc = pafter)
+    {
+        pafter = pc;
+        if (!scriptSig.GetOp(pafter, opcode))
+            return false;
+        if (opcode == OP_CODESEPARATOR)
+        {
+            pcodesep = pc;
+            break;
+        }
+    }
+
+    CScript scriptSigData(scriptSig.begin(), pcodesep);
+    if (!scriptSigData.IsPushOnly())
+        return false;
+
+    if (pcodesep == pend)
+        return true;
+
+    CScript scriptSigCode(pafter, pend);
+    return IsStandard(scriptSigCode);
+}
+
 
 int HaveKeys(const vector<valtype>& pubkeys, const CKeyStore& keystore)
 {
@@ -1470,37 +1534,15 @@ bool ExtractAddresses(const CScript& scriptPubKey, txnouttype& typeRet, vector<C
 bool VerifyScript(const CScript& scriptSig, const CScript& scriptPubKey, const CTransaction& txTo, unsigned int nIn,
                   bool fValidatePayToScriptHash, int nHashType)
 {
-    vector<vector<unsigned char> > stack, stackCopy;
-    if (!EvalScript(stack, scriptSig, txTo, nIn, nHashType))
+    vector<vector<unsigned char> > stack;
+    std::vector<unsigned char> vchLastScript;
+    if (!EvalScript(stack, scriptSig, txTo, nIn, nHashType, fValidatePayToScriptHash, vchLastScript))
         return false;
-    if (fValidatePayToScriptHash)
-        stackCopy = stack;
-    if (!EvalScript(stack, scriptPubKey, txTo, nIn, nHashType))
+    if (!EvalScript(stack, scriptPubKey, txTo, nIn, nHashType, fValidatePayToScriptHash, vchLastScript))
         return false;
     if (stack.empty())
         return false;
-
-    if (CastToBool(stack.back()) == false)
-        return false;
-
-    // Additional validation for spend-to-script-hash transactions:
-    if (fValidatePayToScriptHash && scriptPubKey.IsPayToScriptHash())
-    {
-        if (!scriptSig.IsPushOnly()) // scriptSig must be literals-only
-            return false;            // or validation fails
-
-        const valtype& pubKeySerialized = stackCopy.back();
-        CScript pubKey2(pubKeySerialized.begin(), pubKeySerialized.end());
-        popstack(stackCopy);
-
-        if (!EvalScript(stackCopy, pubKey2, txTo, nIn, nHashType))
-            return false;
-        if (stackCopy.empty())
-            return false;
-        return CastToBool(stackCopy.back());
-    }
-
-    return true;
+    return CastToBool(stack.back());
 }
 
 
@@ -1521,9 +1563,8 @@ bool SignSignature(const CKeyStore &keystore, const CTransaction& txFrom, CTrans
 
     if (whichType == TX_SCRIPTHASH)
     {
-        // Solver returns the subscript that need to be evaluated;
-        // the final scriptSig is the signatures from that
-        // and then the serialized subscript:
+        // Solver returns the end of the scriptSig; the final scriptSig is the
+        // signatures for that and then this end script:
         CScript subscript = txin.scriptSig;
 
         // Recompute txn hash using subscript in place of scriptPubKey:
@@ -1533,7 +1574,8 @@ bool SignSignature(const CKeyStore &keystore, const CTransaction& txFrom, CTrans
             return false;
         if (subType == TX_SCRIPTHASH)
             return false;
-        txin.scriptSig << static_cast<valtype>(subscript); // Append serialized subscript
+        txin.scriptSig << OP_CODESEPARATOR;
+        txin.scriptSig += subscript;
     }
 
     // Test solution
@@ -1585,44 +1627,11 @@ int CScript::GetSigOpCount(bool fAccurate) const
     return n;
 }
 
-int CScript::GetSigOpCount(const CScript& scriptSig) const
-{
-    if (!IsPayToScriptHash())
-        return GetSigOpCount(true);
-
-    // This is a pay-to-script-hash scriptPubKey;
-    // get the last item that the scriptSig
-    // pushes onto the stack:
-    const_iterator pc = scriptSig.begin();
-    vector<unsigned char> data;
-    while (pc < scriptSig.end())
-    {
-        opcodetype opcode;
-        if (!scriptSig.GetOp(pc, opcode, data))
-            return 0;
-        if (opcode > OP_16)
-            return 0;
-    }
-
-    /// ... and return it's opcount:
-    CScript subscript(data.begin(), data.end());
-    return subscript.GetSigOpCount(true);
-}
-
-bool CScript::IsPayToScriptHash() const
-{
-    // Extra-fast test for pay-to-script-hash CScripts:
-    return (this->size() == 23 &&
-            this->at(0) == OP_HASH160 &&
-            this->at(1) == 0x14 &&
-            this->at(22) == OP_EQUAL);
-}
-
 void CScript::SetBitcoinAddress(const CBitcoinAddress& address)
 {
     this->clear();
     if (address.IsScript())
-        *this << OP_HASH160 << address.GetHash160() << OP_EQUAL;
+        *this << address.GetHash160() << OP_CHECKHASHVERIFY << OP_DROP;
     else
         *this << OP_DUP << OP_HASH160 << address.GetHash160() << OP_EQUALVERIFY << OP_CHECKSIG;
 }
@@ -1642,5 +1651,5 @@ void CScript::SetPayToScriptHash(const CScript& subscript)
     assert(!subscript.empty());
     uint160 subscriptHash = Hash160(subscript);
     this->clear();
-    *this << OP_HASH160 << subscriptHash << OP_EQUAL;
+    *this << subscriptHash << OP_CHECKHASHVERIFY << OP_DROP;
 }
diff --git a/src/script.h b/src/script.h
index 46f2d31..e3aa651 100644
--- a/src/script.h
+++ b/src/script.h
@@ -160,7 +160,7 @@ enum opcodetype
 
     // expansion
     OP_NOP1,
-    OP_NOP2,
+    OP_CHECKHASHVERIFY,  // "crypto"
     OP_NOP3,
     OP_NOP4,
     OP_NOP5,
@@ -175,6 +175,7 @@ enum opcodetype
     // template matching params
     OP_SMALLINTEGER = 0xfa,
     OP_PUBKEYS = 0xfb,
+    OP_SCRIPTHASH = 0xfc,
     OP_PUBKEYHASH = 0xfd,
     OP_PUBKEY = 0xfe,
 
@@ -489,12 +490,6 @@ public:
     //  ... OP_N CHECKMULTISIG ...
     int GetSigOpCount(bool fAccurate) const;
 
-    // Accurately count sigOps, including sigOps in
-    // pay-to-script-hash transactions:
-    int GetSigOpCount(const CScript& scriptSig) const;
-
-    bool IsPayToScriptHash() const;
-
     // Called by CTransaction::IsStandard
     bool IsPushOnly() const
     {
@@ -558,10 +553,11 @@ public:
 
 
 
-bool EvalScript(std::vector<std::vector<unsigned char> >& stack, const CScript& script, const CTransaction& txTo, unsigned int nIn, int nHashType);
+bool EvalScript(std::vector<std::vector<unsigned char> >& stack, const CScript& script, const CTransaction& txTo, unsigned int nIn, int nHashType, bool fValidatePayToScriptHash, std::vector<unsigned char> &vchLastScript);
 bool Solver(const CScript& scriptPubKey, txnouttype& typeRet, std::vector<std::vector<unsigned char> >& vSolutionsRet);
 int ScriptSigArgsExpected(txnouttype t, const std::vector<std::vector<unsigned char> >& vSolutions);
 bool IsStandard(const CScript& scriptPubKey);
+bool IsStandardInput(const CScript& scriptSig);
 bool IsMine(const CKeyStore& keystore, const CScript& scriptPubKey);
 bool ExtractAddress(const CScript& scriptPubKey, CBitcoinAddress& addressRet);
 bool ExtractAddresses(const CScript& scriptPubKey, txnouttype& typeRet, std::vector<CBitcoinAddress>& addressRet, int& nRequiredRet);
diff --git a/src/test/script_P2SH_tests.cpp b/src/test/script_P2SH_tests.cpp
index aa72c00..815311a 100644
--- a/src/test/script_P2SH_tests.cpp
+++ b/src/test/script_P2SH_tests.cpp
@@ -49,8 +49,8 @@ BOOST_AUTO_TEST_SUITE(script_P2SH_tests)
 BOOST_AUTO_TEST_CASE(sign)
 {
     // Pay-to-script-hash looks like this:
-    // scriptSig:    <sig> <sig...> <serialized_script>
-    // scriptPubKey: HASH160 <hash> EQUAL
+    // scriptSig:    <sig> <sig...> OP_CODESEPARATOR <script>
+    // scriptPubKey: <hash> CHECKHASHVERIFY DROP
 
     // Test SignSignature() (and therefore the version of Solver() that signs transactions)
     CBasicKeyStore keystore;
@@ -114,32 +114,6 @@ BOOST_AUTO_TEST_CASE(sign)
         }
 }
 
-BOOST_AUTO_TEST_CASE(norecurse)
-{
-    // Make sure only the outer pay-to-script-hash does the
-    // extra-validation thing:
-    CScript invalidAsScript;
-    invalidAsScript << OP_INVALIDOPCODE << OP_INVALIDOPCODE;
-
-    CScript p2sh;
-    p2sh.SetPayToScriptHash(invalidAsScript);
-
-    CScript scriptSig;
-    scriptSig << Serialize(invalidAsScript);
-
-    // Should not verify, because it will try to execute OP_INVALIDOPCODE
-    BOOST_CHECK(!Verify(scriptSig, p2sh, true));
-
-    // Try to recurse, and verification should succeed because
-    // the inner HASH160 <> EQUAL should only check the hash:
-    CScript p2sh2;
-    p2sh2.SetPayToScriptHash(p2sh);
-    CScript scriptSig2;
-    scriptSig2 << Serialize(invalidAsScript) << Serialize(p2sh);
-
-    BOOST_CHECK(Verify(scriptSig2, p2sh2, true));
-}
-
 BOOST_AUTO_TEST_CASE(set)
 {
     // Test the CScript::Set* methods
@@ -192,44 +166,25 @@ BOOST_AUTO_TEST_CASE(set)
     }
 }
 
-BOOST_AUTO_TEST_CASE(is)
+BOOST_AUTO_TEST_CASE(solver)
 {
-    // Test CScript::IsPayToScriptHash()
+    // Test CScript::Solver
     uint160 dummy;
     CScript p2sh;
-    p2sh << OP_HASH160 << dummy << OP_EQUAL;
-    BOOST_CHECK(p2sh.IsPayToScriptHash());
-
-    // Not considered pay-to-script-hash if using one of the OP_PUSHDATA opcodes:
-    static const unsigned char direct[] =    { OP_HASH160, 20, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, OP_EQUAL };
-    BOOST_CHECK(CScript(direct, direct+sizeof(direct)).IsPayToScriptHash());
-    static const unsigned char pushdata1[] = { OP_HASH160, OP_PUSHDATA1, 20, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, OP_EQUAL };
-    BOOST_CHECK(!CScript(pushdata1, pushdata1+sizeof(pushdata1)).IsPayToScriptHash());
-    static const unsigned char pushdata2[] = { OP_HASH160, OP_PUSHDATA2, 20,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, OP_EQUAL };
-    BOOST_CHECK(!CScript(pushdata2, pushdata2+sizeof(pushdata2)).IsPayToScriptHash());
-    static const unsigned char pushdata4[] = { OP_HASH160, OP_PUSHDATA4, 20,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, OP_EQUAL };
-    BOOST_CHECK(!CScript(pushdata4, pushdata4+sizeof(pushdata4)).IsPayToScriptHash());
-
-    CScript not_p2sh;
-    BOOST_CHECK(!not_p2sh.IsPayToScriptHash());
-
-    not_p2sh.clear(); not_p2sh << OP_HASH160 << dummy << dummy << OP_EQUAL;
-    BOOST_CHECK(!not_p2sh.IsPayToScriptHash());
-
-    not_p2sh.clear(); not_p2sh << OP_NOP << dummy << OP_EQUAL;
-    BOOST_CHECK(!not_p2sh.IsPayToScriptHash());
-
-    not_p2sh.clear(); not_p2sh << OP_HASH160 << dummy << OP_CHECKSIG;
-    BOOST_CHECK(!not_p2sh.IsPayToScriptHash());
+    txnouttype type;
+    std::vector<std::vector<unsigned char> > vSolutions;
+    p2sh << dummy << OP_CHECKHASHVERIFY << OP_DROP;
+    BOOST_CHECK(Solver(p2sh, type, vSolutions));
+    BOOST_CHECK(type == TX_SCRIPTHASH);
 }
 
 BOOST_AUTO_TEST_CASE(switchover)
 {
     // Test switchover code
     CScript notValid;
-    notValid << OP_11 << OP_12 << OP_EQUALVERIFY;
+    notValid << OP_2;
     CScript scriptSig;
-    scriptSig << Serialize(notValid);
+    scriptSig << OP_CODESEPARATOR << OP_1;
 
     CScript fund;
     fund.SetPayToScriptHash(notValid);
@@ -255,7 +210,7 @@ BOOST_AUTO_TEST_CASE(AreInputsStandard)
     }
 
     CTransaction txFrom;
-    txFrom.vout.resize(6);
+    txFrom.vout.resize(5);
 
     // First three are standard:
     CScript pay1; pay1.SetBitcoinAddress(key[0].GetPubKey());
@@ -267,18 +222,12 @@ BOOST_AUTO_TEST_CASE(AreInputsStandard)
     txFrom.vout[1].scriptPubKey = pay1;
     txFrom.vout[2].scriptPubKey = pay1of3;
 
-    // Last three non-standard:
+    // Last two non-standard:
     CScript empty;
     keystore.AddCScript(empty);
     txFrom.vout[3].scriptPubKey = empty;
-    // Can't use SetPayToScriptHash, it checks for the empty Script. So:
-    txFrom.vout[4].scriptPubKey << OP_HASH160 << Hash160(empty) << OP_EQUAL;
-    CScript oneOfEleven;
-    oneOfEleven << OP_1;
-    for (int i = 0; i < 11; i++)
-        oneOfEleven << key[0].GetPubKey();
-    oneOfEleven << OP_11 << OP_CHECKMULTISIG;
-    txFrom.vout[5].scriptPubKey.SetPayToScriptHash(oneOfEleven);
+    // This is missing DROP:
+    txFrom.vout[4].scriptPubKey << Hash160(empty) << OP_CHECKHASHVERIFY;
 
     mapInputs[txFrom.GetHash()] = make_pair(CTxIndex(), txFrom);
 
@@ -298,30 +247,16 @@ BOOST_AUTO_TEST_CASE(AreInputsStandard)
     BOOST_CHECK(SignSignature(keystore, txFrom, txTo, 2));
 
     BOOST_CHECK(txTo.AreInputsStandard(mapInputs));
-    BOOST_CHECK_EQUAL(txTo.GetP2SHSigOpCount(mapInputs), 1);
-
-    // Make sure adding crap to the scriptSigs makes them non-standard:
-    for (int i = 0; i < 3; i++)
-    {
-        CScript t = txTo.vin[i].scriptSig;
-        txTo.vin[i].scriptSig = (CScript() << 11) + t;
-        BOOST_CHECK(!txTo.AreInputsStandard(mapInputs));
-        txTo.vin[i].scriptSig = t;
-    }
 
     CTransaction txToNonStd;
     txToNonStd.vout.resize(1);
     txToNonStd.vout[0].scriptPubKey.SetBitcoinAddress(key[1].GetPubKey());
-    txToNonStd.vin.resize(2);
+    txToNonStd.vin.resize(1);
     txToNonStd.vin[0].prevout.n = 4;
     txToNonStd.vin[0].prevout.hash = txFrom.GetHash();
     txToNonStd.vin[0].scriptSig << Serialize(empty);
-    txToNonStd.vin[1].prevout.n = 5;
-    txToNonStd.vin[1].prevout.hash = txFrom.GetHash();
-    txToNonStd.vin[1].scriptSig << OP_0 << Serialize(oneOfEleven);
 
     BOOST_CHECK(!txToNonStd.AreInputsStandard(mapInputs));
-    BOOST_CHECK_EQUAL(txToNonStd.GetP2SHSigOpCount(mapInputs), 11);
 
     txToNonStd.vin[0].scriptSig.clear();
     BOOST_CHECK(!txToNonStd.AreInputsStandard(mapInputs));
diff --git a/src/test/script_tests.cpp b/src/test/script_tests.cpp
index 493ea69..62764a9 100644
--- a/src/test/script_tests.cpp
+++ b/src/test/script_tests.cpp
@@ -22,18 +22,19 @@ BOOST_AUTO_TEST_CASE(script_PushData)
     static const unsigned char pushdata4[] = { OP_PUSHDATA4, 1, 0, 0, 0, 0x5a };
 
     vector<vector<unsigned char> > directStack;
-    BOOST_CHECK(EvalScript(directStack, CScript(&direct[0], &direct[sizeof(direct)]), CTransaction(), 0, 0));
+    vector<unsigned char> vchLastScript;
+    BOOST_CHECK(EvalScript(directStack, CScript(&direct[0], &direct[sizeof(direct)]), CTransaction(), 0, 0, true, vchLastScript));
 
     vector<vector<unsigned char> > pushdata1Stack;
-    BOOST_CHECK(EvalScript(pushdata1Stack, CScript(&pushdata1[0], &pushdata1[sizeof(pushdata1)]), CTransaction(), 0, 0));
+    BOOST_CHECK(EvalScript(pushdata1Stack, CScript(&pushdata1[0], &pushdata1[sizeof(pushdata1)]), CTransaction(), 0, 0, true, vchLastScript));
     BOOST_CHECK(pushdata1Stack == directStack);
 
     vector<vector<unsigned char> > pushdata2Stack;
-    BOOST_CHECK(EvalScript(pushdata2Stack, CScript(&pushdata2[0], &pushdata2[sizeof(pushdata2)]), CTransaction(), 0, 0));
+    BOOST_CHECK(EvalScript(pushdata2Stack, CScript(&pushdata2[0], &pushdata2[sizeof(pushdata2)]), CTransaction(), 0, 0, true, vchLastScript));
     BOOST_CHECK(pushdata2Stack == directStack);
 
     vector<vector<unsigned char> > pushdata4Stack;
-    BOOST_CHECK(EvalScript(pushdata4Stack, CScript(&pushdata4[0], &pushdata4[sizeof(pushdata4)]), CTransaction(), 0, 0));
+    BOOST_CHECK(EvalScript(pushdata4Stack, CScript(&pushdata4[0], &pushdata4[sizeof(pushdata4)]), CTransaction(), 0, 0, true, vchLastScript));
     BOOST_CHECK(pushdata4Stack == directStack);
 }
 
diff --git a/src/test/sigopcount_tests.cpp b/src/test/sigopcount_tests.cpp
index d301313..098aa20 100644
--- a/src/test/sigopcount_tests.cpp
+++ b/src/test/sigopcount_tests.cpp
@@ -31,12 +31,6 @@ BOOST_AUTO_TEST_CASE(GetSigOpCount)
     BOOST_CHECK_EQUAL(s1.GetSigOpCount(true), 3);
     BOOST_CHECK_EQUAL(s1.GetSigOpCount(false), 21);
 
-    CScript p2sh;
-    p2sh.SetPayToScriptHash(s1);
-    CScript scriptSig;
-    scriptSig << OP_0 << Serialize(s1);
-    BOOST_CHECK_EQUAL(p2sh.GetSigOpCount(scriptSig), 3);
-
     std::vector<CKey> keys;
     for (int i = 0; i < 3; i++)
     {
@@ -48,13 +42,6 @@ BOOST_AUTO_TEST_CASE(GetSigOpCount)
     s2.SetMultisig(1, keys);
     BOOST_CHECK_EQUAL(s2.GetSigOpCount(true), 3);
     BOOST_CHECK_EQUAL(s2.GetSigOpCount(false), 20);
-
-    p2sh.SetPayToScriptHash(s2);
-    BOOST_CHECK_EQUAL(p2sh.GetSigOpCount(true), 0);
-    BOOST_CHECK_EQUAL(p2sh.GetSigOpCount(false), 0);
-    CScript scriptSig2;
-    scriptSig2 << OP_1 << dummy << dummy << Serialize(s2);
-    BOOST_CHECK_EQUAL(p2sh.GetSigOpCount(scriptSig2), 3);
 }
 
 BOOST_AUTO_TEST_SUITE_END()