aboutsummaryrefslogtreecommitdiff
path: root/qa/rpc-tests/script_test.py
blob: 860fa56b64f301905cdcf8446c2dda16ed5da29a (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
#!/usr/bin/env python2
#
# Distributed under the MIT/X11 software license, see the accompanying
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
#

'''
Test notes:
This test uses the script_valid and script_invalid tests from the unittest
framework to do end-to-end testing where we compare that two nodes agree on
whether blocks containing a given test script are valid.

We generally ignore the script flags associated with each test (since we lack
the precision to test each script using those flags in this framework), but
for tests with SCRIPT_VERIFY_P2SH, we can use a block time after the BIP16 
switchover date to try to test with that flag enabled (and for tests without
that flag, we use a block time before the switchover date).

NOTE: This test is very slow and may take more than 40 minutes to run.
'''

from test_framework.test_framework import ComparisonTestFramework
from test_framework.util import *
from test_framework.comptool import TestInstance, TestManager
from test_framework.mininode import *
from test_framework.blocktools import *
from test_framework.script import *
import logging
import copy
import json

script_valid_file   = "../../src/test/data/script_valid.json"
script_invalid_file = "../../src/test/data/script_invalid.json"

# Pass in a set of json files to open. 
class ScriptTestFile(object):

    def __init__(self, files):
        self.files = files
        self.index = -1
        self.data = []

    def load_files(self):
        for f in self.files:
            self.data.extend(json.loads(open(os.path.dirname(os.path.abspath(__file__))+"/"+f).read()))

    # Skip over records that are not long enough to be tests
    def get_records(self):
        while (self.index < len(self.data)):
            if len(self.data[self.index]) >= 3:
                yield self.data[self.index]
            self.index += 1


# Helper for parsing the flags specified in the .json files
SCRIPT_VERIFY_NONE = 0
SCRIPT_VERIFY_P2SH = 1 
SCRIPT_VERIFY_STRICTENC = 1 << 1
SCRIPT_VERIFY_DERSIG = 1 << 2
SCRIPT_VERIFY_LOW_S = 1 << 3
SCRIPT_VERIFY_NULLDUMMY = 1 << 4
SCRIPT_VERIFY_SIGPUSHONLY = 1 << 5
SCRIPT_VERIFY_MINIMALDATA = 1 << 6
SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS = 1 << 7
SCRIPT_VERIFY_CLEANSTACK = 1 << 8

flag_map = { 
    "": SCRIPT_VERIFY_NONE,
    "NONE": SCRIPT_VERIFY_NONE, 
    "P2SH": SCRIPT_VERIFY_P2SH,
    "STRICTENC": SCRIPT_VERIFY_STRICTENC,
    "DERSIG": SCRIPT_VERIFY_DERSIG,
    "LOW_S": SCRIPT_VERIFY_LOW_S,
    "NULLDUMMY": SCRIPT_VERIFY_NULLDUMMY,
    "SIGPUSHONLY": SCRIPT_VERIFY_SIGPUSHONLY,
    "MINIMALDATA": SCRIPT_VERIFY_MINIMALDATA,
    "DISCOURAGE_UPGRADABLE_NOPS": SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS,
    "CLEANSTACK": SCRIPT_VERIFY_CLEANSTACK,
}

def ParseScriptFlags(flag_string):
    flags = 0
    for x in flag_string.split(","):
        if x in flag_map:
            flags |= flag_map[x]
        else:
            print "Error: unrecognized script flag: ", x
    return flags

'''
Given a string that is a scriptsig or scriptpubkey from the .json files above,
convert it to a CScript()
'''
# Replicates behavior from core_read.cpp
def ParseScript(json_script):
    script = json_script.split(" ")
    parsed_script = CScript()
    for x in script:
        if len(x) == 0:
            # Empty string, ignore.
            pass
        elif x.isdigit() or (len(x) >= 1 and x[0] == "-" and x[1:].isdigit()):
            # Number
            n = int(x, 0)
            if (n == -1) or (n >= 1 and n <= 16):
                parsed_script = CScript(bytes(parsed_script) + bytes(CScript([n])))
            else:
                parsed_script += CScriptNum(int(x, 0))
        elif x.startswith("0x"):
            # Raw hex data, inserted NOT pushed onto stack:
            for i in xrange(2, len(x), 2):
                parsed_script = CScript(bytes(parsed_script) + bytes(chr(int(x[i:i+2],16))))
        elif x.startswith("'") and x.endswith("'") and len(x) >= 2:
            # Single-quoted string, pushed as data.
            parsed_script += CScript([x[1:-1]])
        else:
            # opcode, e.g. OP_ADD or ADD:
            tryopname = "OP_" + x
            if tryopname in OPCODES_BY_NAME:
                parsed_script += CScriptOp(OPCODES_BY_NAME["OP_" + x])
            else:
                print "ParseScript: error parsing '%s'" % x
                return ""
    return parsed_script
            
class TestBuilder(object):
    def create_credit_tx(self, scriptPubKey):
        # self.tx1 is a coinbase transaction, modeled after the one created by script_tests.cpp
        # This allows us to reuse signatures created in the unit test framework.
        self.tx1 = create_coinbase()                 # this has a bip34 scriptsig,
        self.tx1.vin[0].scriptSig = CScript([0, 0])  # but this matches the unit tests
        self.tx1.vout[0].nValue = 0
        self.tx1.vout[0].scriptPubKey = scriptPubKey
        self.tx1.rehash()
    def create_spend_tx(self, scriptSig):
        self.tx2 = create_transaction(self.tx1, 0, CScript(), 0)
        self.tx2.vin[0].scriptSig = scriptSig
        self.tx2.vout[0].scriptPubKey = CScript()
        self.tx2.rehash()
    def rehash(self):
        self.tx1.rehash()
        self.tx2.rehash()

# This test uses the (default) two nodes provided by ComparisonTestFramework,
# specified on the command line with --testbinary and --refbinary.
# See comptool.py
class ScriptTest(ComparisonTestFramework):

    def run_test(self):
        # Set up the comparison tool TestManager
        test = TestManager(self, self.options.tmpdir)
        test.add_all_connections(self.nodes)

        # Load scripts
        self.scripts = ScriptTestFile([script_valid_file, script_invalid_file])
        self.scripts.load_files()

        # Some variables we re-use between test instances (to build blocks)
        self.tip = None
        self.block_time = None

        NetworkThread().start()  # Start up network handling in another thread
        test.run()

    def generate_test_instance(self, pubkeystring, scriptsigstring):
        scriptpubkey = ParseScript(pubkeystring)
        scriptsig = ParseScript(scriptsigstring)

        test = TestInstance(sync_every_block=False)
        test_build = TestBuilder()
        test_build.create_credit_tx(scriptpubkey)
        test_build.create_spend_tx(scriptsig)
        test_build.rehash()

        block = create_block(self.tip, test_build.tx1, self.block_time)
        self.block_time += 1
        block.solve()
        self.tip = block.sha256
        test.blocks_and_transactions = [[block, True]]

        for i in xrange(100):
            block = create_block(self.tip, create_coinbase(), self.block_time)
            self.block_time += 1
            block.solve()
            self.tip = block.sha256
            test.blocks_and_transactions.append([block, True])

        block = create_block(self.tip, create_coinbase(), self.block_time)
        self.block_time += 1
        block.vtx.append(test_build.tx2)
        block.hashMerkleRoot = block.calc_merkle_root()
        block.rehash()
        block.solve()
        test.blocks_and_transactions.append([block, None])
        return test   

    # This generates the tests for TestManager.
    def get_tests(self):
        self.tip = int ("0x" + self.nodes[0].getbestblockhash() + "L", 0)
        self.block_time = 1333230000  # before the BIP16 switchover

        '''
        Create a new block with an anyone-can-spend coinbase
        '''
        block = create_block(self.tip, create_coinbase(), self.block_time)
        self.block_time += 1
        block.solve()
        self.tip = block.sha256
        yield TestInstance(objects=[[block, True]])

        '''
        Build out to 100 blocks total, maturing the coinbase.
        '''
        test = TestInstance(objects=[], sync_every_block=False, sync_every_tx=False)
        for i in xrange(100):
            b = create_block(self.tip, create_coinbase(), self.block_time)
            b.solve()
            test.blocks_and_transactions.append([b, True])
            self.tip = b.sha256
            self.block_time += 1
        yield test
 
        ''' Iterate through script tests. '''
        counter = 0
        for script_test in self.scripts.get_records():
            ''' Reset the blockchain to genesis block + 100 blocks. '''
            if self.nodes[0].getblockcount() > 101:
                self.nodes[0].invalidateblock(self.nodes[0].getblockhash(102))
                self.nodes[1].invalidateblock(self.nodes[1].getblockhash(102))

            self.tip = int ("0x" + self.nodes[0].getbestblockhash() + "L", 0)

            [scriptsig, scriptpubkey, flags] = script_test[0:3]
            flags = ParseScriptFlags(flags)

            # We can use block time to determine whether the nodes should be
            # enforcing BIP16.
            #
            # We intentionally let the block time grow by 1 each time.
            # This forces the block hashes to differ between tests, so that
            # a call to invalidateblock doesn't interfere with a later test.
            if (flags & SCRIPT_VERIFY_P2SH):
                self.block_time = 1333238400 + counter # Advance to enforcing BIP16
            else:
                self.block_time = 1333230000 + counter # Before the BIP16 switchover

            print "Script test: [%s]" % script_test

            yield self.generate_test_instance(scriptpubkey, scriptsig)
            counter += 1

if __name__ == '__main__':
    ScriptTest().main()