diff --git a/contrib/testgen/README.md b/contrib/testgen/README.md index 773dac1278d9..ef6cd2f248e5 100644 --- a/contrib/testgen/README.md +++ b/contrib/testgen/README.md @@ -4,5 +4,5 @@ Utilities to generate test vectors for the data-driven Garlicoin tests. Usage: - gen_base58_test_vectors.py valid 50 > ../../src/test/data/base58_keys_valid.json - gen_base58_test_vectors.py invalid 50 > ../../src/test/data/base58_keys_invalid.json \ No newline at end of file + PYTHONPATH=../../test/functional/test_framework ./gen_key_io_test_vectors.py valid 50 > ../../src/test/data/base58_keys_valid.json + PYTHONPATH=../../test/functional/test_framework ./gen_key_io_test_vectors.py invalid 50 > ../../src/test/data/base58_keys_invalid.json \ No newline at end of file diff --git a/contrib/testgen/gen_base58_test_vectors.py b/contrib/testgen/gen_base58_test_vectors.py deleted file mode 100755 index 5abd6e97705e..000000000000 --- a/contrib/testgen/gen_base58_test_vectors.py +++ /dev/null @@ -1,131 +0,0 @@ -#!/usr/bin/env python -# Copyright (c) 2012-2017 The Bitcoin Core developers -# Distributed under the MIT software license, see the accompanying -# file COPYING or http://www.opensource.org/licenses/mit-license.php. -''' -Generate valid and invalid base58 address and private key test vectors. - -Usage: - gen_base58_test_vectors.py valid 50 > ../../src/test/data/base58_keys_valid.json - gen_base58_test_vectors.py invalid 50 > ../../src/test/data/base58_keys_invalid.json -''' -# 2012 Wladimir J. van der Laan -# Released under MIT License -import os -from itertools import islice -from base58 import b58encode_chk, b58decode_chk, b58chars -import random -from binascii import b2a_hex - -# key types -PUBKEY_ADDRESS = 48 -SCRIPT_ADDRESS = 5 -SCRIPT_ADDRESS2 = 50 -PUBKEY_ADDRESS_TEST = 111 -SCRIPT_ADDRESS_TEST = 196 -PRIVKEY = 176 -PRIVKEY_TEST = 239 - -metadata_keys = ['isPrivkey', 'isTestnet', 'addrType', 'isCompressed'] -# templates for valid sequences -templates = [ - # prefix, payload_size, suffix, metadata - # None = N/A - ((PUBKEY_ADDRESS,), 20, (), (False, False, 'pubkey', None)), - ((SCRIPT_ADDRESS,), 20, (), (False, False, 'script', None)), - ((SCRIPT_ADDRESS2,), 20, (), (False, False, 'script', None)), - ((PUBKEY_ADDRESS_TEST,), 20, (), (False, True, 'pubkey', None)), - ((SCRIPT_ADDRESS_TEST,), 20, (), (False, True, 'script', None)), - ((SCRIPT_ADDRESS_TEST2,), 20, (), (False, True, 'script', None)), - ((PRIVKEY,), 32, (), (True, False, None, False)), - ((PRIVKEY,), 32, (1,), (True, False, None, True)), - ((PRIVKEY_TEST,), 32, (), (True, True, None, False)), - ((PRIVKEY_TEST,), 32, (1,), (True, True, None, True)) -] - -def is_valid(v): - '''Check vector v for validity''' - result = b58decode_chk(v) - if result is None: - return False - for template in templates: - prefix = str(bytearray(template[0])) - suffix = str(bytearray(template[2])) - if result.startswith(prefix) and result.endswith(suffix): - if (len(result) - len(prefix) - len(suffix)) == template[1]: - return True - return False - -def gen_valid_vectors(): - '''Generate valid test vectors''' - while True: - for template in templates: - prefix = str(bytearray(template[0])) - payload = os.urandom(template[1]) - suffix = str(bytearray(template[2])) - rv = b58encode_chk(prefix + payload + suffix) - assert is_valid(rv) - metadata = dict([(x,y) for (x,y) in zip(metadata_keys,template[3]) if y is not None]) - yield (rv, b2a_hex(payload), metadata) - -def gen_invalid_vector(template, corrupt_prefix, randomize_payload_size, corrupt_suffix): - '''Generate possibly invalid vector''' - if corrupt_prefix: - prefix = os.urandom(1) - else: - prefix = str(bytearray(template[0])) - - if randomize_payload_size: - payload = os.urandom(max(int(random.expovariate(0.5)), 50)) - else: - payload = os.urandom(template[1]) - - if corrupt_suffix: - suffix = os.urandom(len(template[2])) - else: - suffix = str(bytearray(template[2])) - - return b58encode_chk(prefix + payload + suffix) - -def randbool(p = 0.5): - '''Return True with P(p)''' - return random.random() < p - -def gen_invalid_vectors(): - '''Generate invalid test vectors''' - # start with some manual edge-cases - yield "", - yield "x", - while True: - # kinds of invalid vectors: - # invalid prefix - # invalid payload length - # invalid (randomized) suffix (add random data) - # corrupt checksum - for template in templates: - val = gen_invalid_vector(template, randbool(0.2), randbool(0.2), randbool(0.2)) - if random.randint(0,10)<1: # line corruption - if randbool(): # add random character to end - val += random.choice(b58chars) - else: # replace random character in the middle - n = random.randint(0, len(val)) - val = val[0:n] + random.choice(b58chars) + val[n+1:] - if not is_valid(val): - yield val, - -if __name__ == '__main__': - import sys, json - iters = {'valid':gen_valid_vectors, 'invalid':gen_invalid_vectors} - try: - uiter = iters[sys.argv[1]] - except IndexError: - uiter = gen_valid_vectors - try: - count = int(sys.argv[2]) - except IndexError: - count = 0 - - data = list(islice(uiter(), count)) - json.dump(data, sys.stdout, sort_keys=True, indent=4) - sys.stdout.write('\n') - diff --git a/contrib/testgen/gen_key_io_test_vectors.py b/contrib/testgen/gen_key_io_test_vectors.py new file mode 100755 index 000000000000..febb504f3ee6 --- /dev/null +++ b/contrib/testgen/gen_key_io_test_vectors.py @@ -0,0 +1,249 @@ +#!/usr/bin/env python3 +# Copyright (c) 2012-2018 The Bitcoin Core developers +# Distributed under the MIT software license, see the accompanying +# file COPYING or http://www.opensource.org/licenses/mit-license.php. +''' +Generate valid and invalid base58 address and private key test vectors. + +Usage: + PYTHONPATH=../../test/functional/test_framework ./gen_key_io_test_vectors.py valid 50 > ../../src/test/data/base58_keys_valid.json + PYTHONPATH=../../test/functional/test_framework ./gen_key_io_test_vectors.py invalid 50 > ../../src/test/data/base58_keys_invalid.json +''' +# 2012 Wladimir J. van der Laan +# Released under MIT License +import os +from itertools import islice +from base58 import b58encode_chk, b58decode_chk, b58chars +import random +from binascii import b2a_hex +from segwit_addr import bech32_encode, decode, convertbits, CHARSET + +# key types +PUBKEY_ADDRESS = 38 +SCRIPT_ADDRESS = 50 +PUBKEY_ADDRESS_TEST = 111 +SCRIPT_ADDRESS_TEST = 58 +PUBKEY_ADDRESS_REGTEST = 111 +SCRIPT_ADDRESS_REGTEST = 58 +PRIVKEY = 176 +PRIVKEY_TEST = 239 +PRIVKEY_REGTEST = 239 + +# script +OP_0 = 0x00 +OP_1 = 0x51 +OP_2 = 0x52 +OP_16 = 0x60 +OP_DUP = 0x76 +OP_EQUAL = 0x87 +OP_EQUALVERIFY = 0x88 +OP_HASH160 = 0xa9 +OP_CHECKSIG = 0xac +pubkey_prefix = (OP_DUP, OP_HASH160, 20) +pubkey_suffix = (OP_EQUALVERIFY, OP_CHECKSIG) +script_prefix = (OP_HASH160, 20) +script_suffix = (OP_EQUAL,) +p2wpkh_prefix = (OP_0, 20) +p2wsh_prefix = (OP_0, 32) + +metadata_keys = ['isPrivkey', 'chain', 'isCompressed', 'tryCaseFlip'] +# templates for valid sequences +templates = [ + # prefix, payload_size, suffix, metadata, output_prefix, output_suffix + # None = N/A + ((PUBKEY_ADDRESS,), 20, (), (False, 'main', None, None), pubkey_prefix, pubkey_suffix), + ((SCRIPT_ADDRESS,), 20, (), (False, 'main', None, None), script_prefix, script_suffix), + ((PUBKEY_ADDRESS_TEST,), 20, (), (False, 'test', None, None), pubkey_prefix, pubkey_suffix), + ((SCRIPT_ADDRESS_TEST,), 20, (), (False, 'test', None, None), script_prefix, script_suffix), + ((PUBKEY_ADDRESS_REGTEST,), 20, (), (False, 'regtest', None, None), pubkey_prefix, pubkey_suffix), + ((SCRIPT_ADDRESS_REGTEST,), 20, (), (False, 'regtest', None, None), script_prefix, script_suffix), + ((PRIVKEY,), 32, (), (True, 'main', False, None), (), ()), + ((PRIVKEY,), 32, (1,), (True, 'main', True, None), (), ()), + ((PRIVKEY_TEST,), 32, (), (True, 'test', False, None), (), ()), + ((PRIVKEY_TEST,), 32, (1,), (True, 'test', True, None), (), ()), + ((PRIVKEY_REGTEST,), 32, (), (True, 'regtest', False, None), (), ()), + ((PRIVKEY_REGTEST,), 32, (1,), (True, 'regtest', True, None), (), ()) +] +# templates for valid bech32 sequences +bech32_templates = [ + # hrp, version, witprog_size, metadata, output_prefix + ('grlc', 0, 20, (False, 'main', None, True), p2wpkh_prefix), + ('grlc', 0, 32, (False, 'main', None, True), p2wsh_prefix), + ('grlc', 1, 2, (False, 'main', None, True), (OP_1, 2)), + ('tgrlc', 0, 20, (False, 'test', None, True), p2wpkh_prefix), + ('tgrlc', 0, 32, (False, 'test', None, True), p2wsh_prefix), + ('tgrlc', 2, 16, (False, 'test', None, True), (OP_2, 16)), + ('rgrlc', 0, 20, (False, 'regtest', None, True), p2wpkh_prefix), + ('rgrlc', 0, 32, (False, 'regtest', None, True), p2wsh_prefix), + ('rgrlc', 16, 40, (False, 'regtest', None, True), (OP_16, 40)) +] +# templates for invalid bech32 sequences +bech32_ng_templates = [ + # hrp, version, witprog_size, invalid_bech32, invalid_checksum, invalid_char + ('tc', 0, 20, False, False, False), + ('tgrlc', 17, 32, False, False, False), + ('rgrlc', 3, 1, False, False, False), + ('grlc', 15, 41, False, False, False), + ('tgrlc', 0, 16, False, False, False), + ('rgrlc', 0, 32, True, False, False), + ('grlc', 0, 16, True, False, False), + ('tgrlc', 0, 32, False, True, False), + ('rgrlc', 0, 20, False, False, True) +] + +def is_valid(v): + '''Check vector v for validity''' + if len(set(v) - set(b58chars)) > 0: + return is_valid_bech32(v) + result = b58decode_chk(v) + if result is None: + return is_valid_bech32(v) + for template in templates: + prefix = bytearray(template[0]) + suffix = bytearray(template[2]) + if result.startswith(prefix) and result.endswith(suffix): + if (len(result) - len(prefix) - len(suffix)) == template[1]: + return True + return is_valid_bech32(v) + +def is_valid_bech32(v): + '''Check vector v for bech32 validity''' + for hrp in ['grlc', 'tgrlc', 'rgrlc']: + if decode(hrp, v) != (None, None): + return True + return False + +def gen_valid_base58_vector(template): + '''Generate valid base58 vector''' + prefix = bytearray(template[0]) + payload = bytearray(os.urandom(template[1])) + suffix = bytearray(template[2]) + dst_prefix = bytearray(template[4]) + dst_suffix = bytearray(template[5]) + rv = b58encode_chk(prefix + payload + suffix) + return rv, dst_prefix + payload + dst_suffix + +def gen_valid_bech32_vector(template): + '''Generate valid bech32 vector''' + hrp = template[0] + witver = template[1] + witprog = bytearray(os.urandom(template[2])) + dst_prefix = bytearray(template[4]) + rv = bech32_encode(hrp, [witver] + convertbits(witprog, 8, 5)) + return rv, dst_prefix + witprog + +def gen_valid_vectors(): + '''Generate valid test vectors''' + glist = [gen_valid_base58_vector, gen_valid_bech32_vector] + tlist = [templates, bech32_templates] + while True: + for template, valid_vector_generator in [(t, g) for g, l in zip(glist, tlist) for t in l]: + rv, payload = valid_vector_generator(template) + assert is_valid(rv) + metadata = {x: y for x, y in zip(metadata_keys,template[3]) if y is not None} + hexrepr = b2a_hex(payload) + if isinstance(hexrepr, bytes): + hexrepr = hexrepr.decode('utf8') + yield (rv, hexrepr, metadata) + +def gen_invalid_base58_vector(template): + '''Generate possibly invalid vector''' + # kinds of invalid vectors: + # invalid prefix + # invalid payload length + # invalid (randomized) suffix (add random data) + # corrupt checksum + corrupt_prefix = randbool(0.2) + randomize_payload_size = randbool(0.2) + corrupt_suffix = randbool(0.2) + + if corrupt_prefix: + prefix = os.urandom(1) + else: + prefix = bytearray(template[0]) + + if randomize_payload_size: + payload = os.urandom(max(int(random.expovariate(0.5)), 50)) + else: + payload = os.urandom(template[1]) + + if corrupt_suffix: + suffix = os.urandom(len(template[2])) + else: + suffix = bytearray(template[2]) + + val = b58encode_chk(prefix + payload + suffix) + if random.randint(0,10)<1: # line corruption + if randbool(): # add random character to end + val += random.choice(b58chars) + else: # replace random character in the middle + n = random.randint(0, len(val)) + val = val[0:n] + random.choice(b58chars) + val[n+1:] + + return val + +def gen_invalid_bech32_vector(template): + '''Generate possibly invalid bech32 vector''' + no_data = randbool(0.1) + to_upper = randbool(0.1) + hrp = template[0] + witver = template[1] + witprog = bytearray(os.urandom(template[2])) + + if no_data: + rv = bech32_encode(hrp, []) + else: + data = [witver] + convertbits(witprog, 8, 5) + if template[3] and not no_data: + if template[2] % 5 in {2, 4}: + data[-1] |= 1 + else: + data.append(0) + rv = bech32_encode(hrp, data) + + if template[4]: + i = len(rv) - random.randrange(1, 7) + rv = rv[:i] + random.choice(CHARSET.replace(rv[i], '')) + rv[i + 1:] + if template[5]: + i = len(hrp) + 1 + random.randrange(0, len(rv) - len(hrp) - 4) + rv = rv[:i] + rv[i:i + 4].upper() + rv[i + 4:] + + if to_upper: + rv = rv.swapcase() + + return rv + +def randbool(p = 0.5): + '''Return True with P(p)''' + return random.random() < p + +def gen_invalid_vectors(): + '''Generate invalid test vectors''' + # start with some manual edge-cases + yield "", + yield "x", + glist = [gen_invalid_base58_vector, gen_invalid_bech32_vector] + tlist = [templates, bech32_ng_templates] + while True: + for template, invalid_vector_generator in [(t, g) for g, l in zip(glist, tlist) for t in l]: + val = invalid_vector_generator(template) + if not is_valid(val): + yield val, + +if __name__ == '__main__': + import sys + import json + iters = {'valid':gen_valid_vectors, 'invalid':gen_invalid_vectors} + try: + uiter = iters[sys.argv[1]] + except IndexError: + uiter = gen_valid_vectors + try: + count = int(sys.argv[2]) + except IndexError: + count = 0 + + data = list(islice(uiter(), count)) + json.dump(data, sys.stdout, sort_keys=True, indent=4) + sys.stdout.write('\n') + diff --git a/src/qt/test/rpcnestedtests.cpp b/src/qt/test/rpcnestedtests.cpp index e6aaa0317a82..e6cc2a25e72f 100644 --- a/src/qt/test/rpcnestedtests.cpp +++ b/src/qt/test/rpcnestedtests.cpp @@ -73,7 +73,7 @@ void RPCNestedTests::rpcNestedTests() QVERIFY(result == result2); RPCConsole::RPCExecuteCommandLine(result, "getblock(getbestblockhash())[tx][0]", &filtered); - QVERIFY(result == "97ddfbbae6be97fd6cdf3e7ca13232a3afff2353e29badfab7f73011edd4ced9"); + QVERIFY(result == "1d5ec9a0855cf4b2802635c8a473b30da17752d6212afde75264effd4c883476"); QVERIFY(filtered == "getblock(getbestblockhash())[tx][0]"); RPCConsole::RPCParseCommandLine(result, "importprivkey", false, &filtered); diff --git a/src/test/compress_tests.cpp b/src/test/compress_tests.cpp index 16b099fcb989..032ca4cde465 100644 --- a/src/test/compress_tests.cpp +++ b/src/test/compress_tests.cpp @@ -44,7 +44,7 @@ BOOST_AUTO_TEST_CASE(compress_amounts) BOOST_CHECK(TestPair( CENT, 0x7)); BOOST_CHECK(TestPair( COIN, 0x9)); BOOST_CHECK(TestPair( 50*COIN, 0x32)); - BOOST_CHECK(TestPair(69000000*COIN, 0x501BD00)); + BOOST_CHECK(TestPair(69000000*COIN, 0x41CDB40)); for (uint64_t i = 1; i <= NUM_MULTIPLES_UNIT; i++) BOOST_CHECK(TestEncode(i)); diff --git a/src/test/data/base58_keys_valid.json b/src/test/data/base58_keys_valid.json index 4656f8f09da9..6f2ad32c4906 100644 --- a/src/test/data/base58_keys_valid.json +++ b/src/test/data/base58_keys_valid.json @@ -1,533 +1,434 @@ [ [ - "LbRY3MfWxhv1W88P3DcH94WLpDGZ3qV8aP", - "76a914b1b2c8ecd1a48ef911bd5e6385a8950d3255937588ac", + "GU88zoUJ6FGD69czryRT8dKN3L9C4ji6Bw", + "76a91470c26a3c60a0c96d71d13d96a84210c18489552888ac", { - "isPrivkey": false, - "chain": "main" - } - ], - [ - "MDpbgJxvdDJk7YH5BVzsUfsKse3N9YCE3o", - "a91440f3ea941f260592f9c9433f0250dfe7e5fb128e87", - { - "isPrivkey": false, - "chain": "main" - } - ], - [ - "mphsD9aLCQ9kpysu4ecCwAvHWYcsbt31u9", - "76a91464c97697289c7f654ceeab26066537489238d32788ac", - { - "isPrivkey": false, - "chain": "test" + "chain": "main", + "isPrivkey": false } ], [ - "mphsD9aLCQ9kpysu4ecCwAvHWYcsbt31u9", - "76a91464c97697289c7f654ceeab26066537489238d32788ac", + "MPVdFLfPWAxFKnSaDs3YHzWqkKbZ7zoB3Z", + "a914ab0e94bd57ff2f291315a10878c351e3e4bda0b787", { - "isPrivkey": false, - "chain": "regtest" + "chain": "main", + "isPrivkey": false } ], [ - "Qg23fQdzYjbW3mo4MtJDMkZsWQgm3kVemM", - "a914d4f756e1a19ede4011f5839e309da0c43fbee4e887", + "mhdz9me5SAE7W85DepLs5UgBpvyEfE1QQJ", + "76a9141744b6ae378f50de95edcdb87c93353ebf35f5b488ac", { - "isPrivkey": false, - "chain": "test" + "chain": "test", + "isPrivkey": false } ], [ - "6w1p6pcTBjzx8cwm4otGNWjs6U7JGp73U2S4PjYFEdssBqb3ozw", - "f94cfafdc6a1291f3379f7527465f391d932853c0caf452b1d3d5ce26d47d3da", + "QYimhqzyMuigYfwnWPRdwX4DThidZoA1Yw", + "a91484ea1105c42b1b85d8c08ed6c3bbba0f5dcea61087", { - "isCompressed": false, - "isPrivkey": true, - "chain": "main" + "chain": "test", + "isPrivkey": false } ], [ - "T8d1EGiyxUNiMqheh7siBtbAxnpy5Scq9ACMH8gtHXvWZsJcHrxn", - "a62d79737a443b898b77bec8e98bc6c27acd9c8b4a222e0c0f2ca01591ff38fc", + "mrzJMZ8jHpfZ4Z69H28MPajLph4jBdUJeX", + "76a9147dd55c31c11c73307d844c20eede4be8faed3e2e88ac", { - "isCompressed": true, - "isPrivkey": true, - "chain": "main" + "chain": "regtest", + "isPrivkey": false } ], [ - "92Uz6EVHCNXUu77uKfedTaGor28x7qaERbNFG3vvnt7xML19K9P", - "7639e3b1907cf81533da2ed547f3ad3c122456afc47a00dbfbc795aa07e0fb01", + "QfEvsgNhnk7G8efUxLrB78GRpv8ZULWuxf", + "a914cc6ef4540db0b72a134b12736b6dbc25669423ce87", { - "isCompressed": false, - "isPrivkey": true, - "chain": "test" + "chain": "regtest", + "isPrivkey": false } ], [ - "92Uz6EVHCNXUu77uKfedTaGor28x7qaERbNFG3vvnt7xML19K9P", - "7639e3b1907cf81533da2ed547f3ad3c122456afc47a00dbfbc795aa07e0fb01", + "6vVEcD8cC4xaEpTExeTiajrH77SBevsgkLWUgD1Tk2nz2DF3zsi", + "b3deedd9033ce845b50d8701cb4703c65dd12a597690e2b889f8d2c034af0554", { + "chain": "main", "isCompressed": false, - "isPrivkey": true, - "chain": "regtest" - } - ], - [ - "cTToo8w9eJVfZSR8R5F8VzQ8rZb5oRwgABKbzer9g3HJqxfyj3ye", - "af7a53dbe5e1f9513e2f2620c58dff15730cebf3a9b560cbf4aaad2768d40fa4", - { - "isCompressed": true, - "isPrivkey": true, - "chain": "test" + "isPrivkey": true } ], [ - "cTToo8w9eJVfZSR8R5F8VzQ8rZb5oRwgABKbzer9g3HJqxfyj3ye", - "af7a53dbe5e1f9513e2f2620c58dff15730cebf3a9b560cbf4aaad2768d40fa4", + "T7wMv7pyJtZDGNRk229qn549nV6F2Gvn5BMYMEMzia3m6HP8a4an", + "91c89a5dcaaca9e81be4e767c7052a922a29b976f7f22ecc3e09ecaa71a98830", { + "chain": "main", "isCompressed": true, - "isPrivkey": true, - "chain": "regtest" - } - ], - [ - "Laq1dYLSYPifTjCeT9DCr1Puiy7k7Ewy5B", - "76a914ab2b41b4206db6c39f74c25453dfa5ff90074e2688ac", - { - "isPrivkey": false, - "chain": "main" - } - ], - [ - "MGrt3HGGHwL5vZ3ecCzdMEbmnFKcE9EeJW", - "a914624ac89642e04d39ce36976e861a022742cc127a87", - { - "isPrivkey": false, - "chain": "main" - } - ], - [ - "mhoT6gsCtPmeY5m5S93FPv5y11Zft7mDAv", - "76a914190ef38c041b5ae687f2ef20a6131e755e12a12188ac", - { - "isPrivkey": false, - "chain": "test" + "isPrivkey": true } ], [ - "QdieUEwPPkt5beUreupi9njiiqzpPqTKWP", - "a914bbbca803acbbe7a2153f0cac05491b624c72426b87", - { - "isPrivkey": false, - "chain": "test" - } - ], - [ - "6vfHCU94rDbNkXCid4iNw2aNbwYQrHch6ghjYfSpC8vMPK9CPjB", - "caadafa39dfa11d59f36b918a9b6ca057953f9eb2066796549d2d3a4124c273d", + "92G5dHky9MJj9XTgHNUkUP7u4yBvePYLLmGseT9sxrYACGcmTcJ", + "58ecbc25afb7521bcd2cbecea4f3cf896552265574a72121a0c4966e71012fb3", { + "chain": "test", "isCompressed": false, - "isPrivkey": true, - "chain": "main" + "isPrivkey": true } ], [ - "T45iMqhBgU8Qoer7dhGQb5UhmwvAQZLZbuHYorkneyaACDmij5Cm", - "1ebb18d9365fde2e29c7ef8494ac1d284fb332f24a0243d59a8070332940f573", + "cUhswcBSrFTvpp5Cn1LRjRbvo8sf8sx5BgxsSKMo7dngwajS2Hi6", + "d48ddc4a239acc9d211a2cc0fa3bf4534e3156cd0ac4925a3f2d088716d51742", { + "chain": "test", "isCompressed": true, - "isPrivkey": true, - "chain": "main" + "isPrivkey": true } ], [ - "93DVKyFYwSN6wEo3E2fCrFPUp17FtrtNi2Lf7n4G3garFb16CRj", - "d6bca256b5abc5602ec2e1c121a08b0da2556587430bcf7e1898af2224885203", + "92K1qFB8ZejW4M21vggJASmg1bptLFNRuQU4ra8d2BG9QBtYYvf", + "5f968cedef950120bd2a88b9e3e44500046cbaf647174522d0b13482610c4d6c", { + "chain": "regtest", "isCompressed": false, - "isPrivkey": true, - "chain": "test" + "isPrivkey": true } ], [ - "cTDVKtMGVYWTHCb1AFjmVbEbWjvKpKqKgMaR3QJxToMSQAhmCeTN", - "a81ca4e8f90181ec4b61b6a7eb998af17b2cb04de8a03b504b9e34c4c61db7d9", + "cTZy51Bp5SWSkHQy7621MH97gxhtdmjGpjdTVGJvSCJdihXjCCHF", + "b2a58f96e85cc350d1553ba966a4399a72aa010de903421877f98f27d56d64b4", { + "chain": "regtest", "isCompressed": true, - "isPrivkey": true, - "chain": "test" + "isPrivkey": true } ], [ - "LcCLxZSuwCMonMGeBcHqQ1SbsKyWKtVmBB", - "76a914ba2c4073e5355bfe37e06fdd9b42f644fb9ae76b88ac", + "grlc1q5gukrq47mtn4unevg7knpfz4an286r9427ll8g", + "0014a2396182bedae75e4f2c47ad30a455ecd47d0cb5", { + "chain": "main", "isPrivkey": false, - "chain": "main" + "tryCaseFlip": true } ], [ - "MKuuxLCpf575SnN6ouhfUmnDYbvyDTQBet", - "a91483c601cee58d9324d8797e04c360971a7222a25387", + "grlc1qzusyum545gaff8easvaf96r8qc26zxmfjfqvd5rd880m0ejrmjyqvmykfl", + "002017204e6e95a23a949f3d833a92e8670615a11b699240c6d06d39dfb7e643dc88", { + "chain": "main", "isPrivkey": false, - "chain": "main" + "tryCaseFlip": true } ], [ - "mgpyL2ueFkKYo8DigPfqi9mGaXhTpBfXFK", - "76a9140e6079f1d5522fc3643b684854d2caeb9f80b79388ac", + "grlc1p527qr3n2pk", + "5102a2bc", { + "chain": "main", "isPrivkey": false, - "chain": "test" + "tryCaseFlip": true } ], [ - "QaRx8KN1Rnh661srYaspaq1whQPdUpq4pF", - "a91497abf24db1094d659b319fafbdb5995ffc6e5ff487", + "tgrlc1qmrqnp230ggvxus393usf8nt0dqrj8qjhavdxen", + "0014d8c130aa2f42186e42258f2093cd6f6807238257", { + "chain": "test", "isPrivkey": false, - "chain": "test" - } - ], - [ - "6vNcAgpwLv5NVF4yNTSoi9Jsp6gWURmEnYJKVuYMumdG38s83fh", - "a4d20c8ade1d8af00ddb974c2f26207b21054d4a1f61c0615ca01a6b97ce7a28", - { - "isCompressed": false, - "isPrivkey": true, - "chain": "main" - } - ], - [ - "T4Fe1n9xDKUHWVFNqcM9z6GwoQeDm53xBqjtf1jgp1tKVJsLZHnv", - "23d630aec25b8a1dcaddd2b02e1eae7a37e105d9b7e8201b697e99f11e23b05a", - { - "isCompressed": true, - "isPrivkey": true, - "chain": "main" - } - ], - [ - "927W7aK3WFBvh4DQrC3rt7h9MyDTAysFkVtya7bFfmEmvQEHEQz", - "4572a355117fa704d8706ab21c0cae21624a563f36644f1363f101294f939906", - { - "isCompressed": false, - "isPrivkey": true, - "chain": "test" - } - ], - [ - "cULmtisjsoJ6tavY7sNYCcFc7GvU9PzaXdpm4yRpwH7VyVxFPx97", - "c9b2817ef47867ffa958cb8ecae6388ea7d4b6a72c85f97b15d555c9d2d70464", - { - "isCompressed": true, - "isPrivkey": true, - "chain": "test" + "tryCaseFlip": true } ], [ - "LbCdD5HhF8mtzqpAhAL44hRUpVXGthe3wv", - "76a914af41b0e60bddd25fd0986c061d2c38dc8d92f23d88ac", + "tgrlc1qaul8nu5f567fr288sjtn6w7787j5r5mm9ncvayuffwptg9a2fckqsd76g5", + "0020ef3e79f289a6bc91a8e784973d3bde3fa541d37b2cf0ce93894b82b417aa4e2c", { + "chain": "test", "isPrivkey": false, - "chain": "main" + "tryCaseFlip": true } ], [ - "MQrxASS6brp3bASypWeKFqTCFbvJLcwQPE", - "a914ba0f3b5ba0efb58cda3e55f13b18462c971e6df987", + "tgrlc1ztwd52y8zxst9mxhs98zc59v44vjtdn27", + "52105b9b4510e234165d9af029c58a1595ab", { + "chain": "test", "isPrivkey": false, - "chain": "main" + "tryCaseFlip": true } ], [ - "n3cBcftzi5PyYRCaqjnHB9LS9C1r8AUKtT", - "76a914f24ff783c81d1bbeca87b10e3e63300952ce644088ac", + "rgrlc1qwgl4n50xl3gflq60u6g4phkduj2r4quuwed229", + "0014723f59d1e6fc509f834fe69150decde4943a839c", { + "chain": "regtest", "isPrivkey": false, - "chain": "test" + "tryCaseFlip": true } ], [ - "QQo4rKLgyqkBLFsSEWFrgBwrH9eGhmcfbT", - "a9142df90970f496d9e6e165a69dacd1417f082c5cf587", + "rgrlc1qy4wm54pedjz2g3ypnwhaurnlersla8ggnh29fzreh7e4rkzgevcq44dyln", + "0020255dba54396c84a444819bafde0e7fc8e1fe9d089dd4548879bfb351d848cb30", { + "chain": "regtest", "isPrivkey": false, - "chain": "test" + "tryCaseFlip": true } ], [ - "6vof9cxLQzMQUA3GdMY7RPyN8v2uxGeYsvVBrJ2Csurini4gtiV", - "ddb3e9ec9271fb4ccf1a0782e87724359730f8c621698ede6a8a33a1b9bb0a46", + "rgrlc1s90ga6tv5es7wx57t5dqm83dqyyf3f9anf8kn4nclk6dqaa98lxjdkjwmd4am6z2cruskdg", + "60282bd1dd2d94cc3ce353cba341b3c5a021131497b349ed3acf1fb69a0ef4a7f9a4db49db6d7bbd0958", { - "isCompressed": false, - "isPrivkey": true, - "chain": "main" + "chain": "regtest", + "isPrivkey": false, + "tryCaseFlip": true } ], [ - "T7ZjgRCVmxcnffbXoJgzXfPUfUHUvQz5KUDz188ufR8jCQepDwXt", - "86a8b4cb9cabbe39f870b65cb9f7e59b4ae9ce0419dab18cf8bcd29a9575871d", + "GVkSg2tn8iu2gXJmDrZ951VSuQLMmG4yDk", + "76a9148298455a67be78639c3cb877a5a6484595978e8288ac", { - "isCompressed": true, - "isPrivkey": true, - "chain": "main" + "chain": "main", + "isPrivkey": false } ], [ - "92sia8ejeCaQ6gKmuraWqpUmv3S6qroQeAsc2nfQZrAiDMnyCQp", - "a9d7c81a8a30cde427c3c530c024e59fbe80a57d55960fffe9948e4366c02ac9", + "MJgt1JWUhj2qnLhYFuhp6rRYneo1hJWDxf", + "a9147656d8d61592077bab1c878ce18d3d525d10e9cd87", { - "isCompressed": false, - "isPrivkey": true, - "chain": "test" + "chain": "main", + "isPrivkey": false } ], [ - "92sia8ejeCaQ6gKmuraWqpUmv3S6qroQeAsc2nfQZrAiDMnyCQp", - "a9d7c81a8a30cde427c3c530c024e59fbe80a57d55960fffe9948e4366c02ac9", + "n4jevPC6yN1KRrhjMnng7HjSgvCsERbUkK", + "76a914feb1cc399136d3a4fba689d048d4885c66a7fd4488ac", { - "isCompressed": false, - "isPrivkey": true, - "chain": "regtest" + "chain": "test", + "isPrivkey": false } ], [ - "cQQ6SPSVoyTBUdstHJJF9YuCLUxfKLnnVAuwfQeREsnmLeTdrSRp", - "540e35fab67b2ff9c6fef795ba0da1114705721bcb387ee93f9c09412d2b3ab5", + "QM8cvs1wtmQdoWoj6DE5xFhuZ2gW2USMQ1", + "a91405cb36f6cdc7d70d1e90e1e19cb88366e499d46387", { - "isCompressed": true, - "isPrivkey": true, - "chain": "test" + "chain": "test", + "isPrivkey": false } ], [ - "LXbHo4W9BDZYwv6v9x57kLZ2r9YNyqBgWA", - "76a91487aa8c8a26a6cc0c7a7d438e61bfa49a33e9cbab88ac", + "n3d4fSLZDD3eUFwkH8ZFgPxbaWDynEi566", + "76a914f27a944e84dde13d3199ff9d40135af3a9894b8488ac", { - "isPrivkey": false, - "chain": "main" + "chain": "regtest", + "isPrivkey": false } ], [ - "MQS7zSkUt9PcbchboBEkg97g7ZojRxoXPW", - "a914b55d095bc6c28b86d87b313442aa3ee454e49cce87", + "Qisg9cxuSFEn8VXeb4LeV6uvskfg3fLFcV", + "a914f44a6e2f2f048a0bd19ee2f208c16d5e4e67168c87", { - "isPrivkey": false, - "chain": "main" + "chain": "regtest", + "isPrivkey": false } ], [ - "moJfnqA4SviQhxStcqR4PFvCU2bjYEx873", - "76a914556e3cee7b8d470f5c3f507c4c54781cfc179ea688ac", + "6vhDRPGW4VDZWc1KJroiCxzDfcybuhoTwXMNATBKzgCjZyohSnE", + "cf126367f67fdc4f418b0af93ceed0a3dfe6f6d22f6d19368262866996c842db", { - "isPrivkey": false, - "chain": "test" + "chain": "main", + "isCompressed": false, + "isPrivkey": true } ], [ - "QV5Ti6jZKGQF7D7erT2dkpFXf3UgfKAw9h", - "a9145cf346cd43ff078ca1d8dc62e39207470e2a496b87", + "T7M5bvoXSZxpxxkBmRSFju5ns4nsQCir1iDmfmA1aXTsA7Xi3CSu", + "8025e4c816711d4cca4f1abed3015a0c9b47dbdbc4476a23d4decee699bf2a2c", { - "isPrivkey": false, - "chain": "test" + "chain": "main", + "isCompressed": true, + "isPrivkey": true } ], [ - "6vwfYtMbBhF5Pn9yUHHP4GcW274C9bK8UgCvCMgCGmCdfwSND4p", - "efe22b1f976043089a51deff8d0b8c3df2b23748f4d0eadb6641503637c63869", + "92RU8kRquPyP4CXdJVW2LxD3MwKUUW5J6FYPWifZAHDj6i8vGC5", + "6e3dd3159c64b8c74a3c297d7449cefb4cab637001de79be38501ffc43518990", { + "chain": "test", "isCompressed": false, - "isPrivkey": true, - "chain": "main" + "isPrivkey": true } ], [ - "T6UPi92VfnBy24YJnkPthhpstCrUA1tLkbLud5tk9nEwoXqTQkZZ", - "661281d55763ba511ced34e909a99d0926daddbeb3109644937061b6cf913782", + "cNCAASTmY6jEu1a6ezSGQ18CQpyqCkgYkzyw4rLKBv2aU3385dtP", + "123d919d52ea3dd614ee5cb46f9c8d156f1d0da60f86180f7f17fe9c7f8f3d1f", { + "chain": "test", "isCompressed": true, - "isPrivkey": true, - "chain": "main" + "isPrivkey": true } ], [ - "92ZmYqEbmGrKfHp1usJrj5qAYnwvFihby1XYL82riva5EZhuvjj", - "8116986e76487416346994d08b5248622471e2836943f695d7351868f520ba6b", + "933xCdsHxNKMqHBq6Phd7zt3Gzo6xeE3zM9jLNdocsN3yKxrE24", + "c1152b50b6b2f6e655937cdbc0d251dbc2967d89958d565656a2fa0bb93b3744", { + "chain": "regtest", "isCompressed": false, - "isPrivkey": true, - "chain": "test" + "isPrivkey": true } ], [ - "cUAXZmhBU724DznSwsZnqjhixqrkqwXXWCGAZcJkBXdgPuBi4CZd", - "c46d03a638e031a5a0d025bac050875f5c79bef6d47b377ab5eff92563549e7b", + "cMcBSH8xsDpLaFkWFet39rxGoS5AX7PVFDgbd54JRmJy9UotSUnd", + "00c2cad26d070bd02e706a732cdf52757b8fb1210281a982e25dd497c0b306b8", { + "chain": "regtest", "isCompressed": true, - "isPrivkey": true, - "chain": "test" + "isPrivkey": true } ], [ - "LiRGLiaD9yaUNZbe9GKptX5PybiQZzioED", - "76a914fe6e8f1ff538103ede6451c57d5dcbeaf376821d88ac", + "grlc1qqmlh830d7399xyh8rvl5kvs24m86rru5ry4jp7", + "001406ff73c5edf44a5312e71b3f4b320aaecfa18f94", { + "chain": "main", "isPrivkey": false, - "chain": "main" + "tryCaseFlip": true } ], [ - "M7wQbFTJZextk1bjbWc1c2WgNmAj41meXv", - "a914006cd1745e13749236c7064614d93d4650a79e4887", + "grlc1quv6zmvpylne5wqjg4j9nx2mn7hvxa2uxzqf453ghe6vc72edx98s5jvxpl", + "0020e3342db024fcf3470248ac8b332b73f5d86eab8610135a4517ce998f2b2d314f", { + "chain": "main", "isPrivkey": false, - "chain": "main" + "tryCaseFlip": true } ], [ - "mfkrC62Px74E6mpQS137ecE6c3A7LzFMV7", - "76a91402a0baa2a00912fa6b7db5ec66f64ad3dafe650988ac", + "grlc1pef6s8hahhl", + "5102ca75", { + "chain": "main", "isPrivkey": false, - "chain": "test" + "tryCaseFlip": true } ], [ - "QeEUMazrWFAp7UTwHgxQ9aVtdER4e4E9aY", - "a914c160b11a8a042e801487f9f0c13be0246adff58687", + "tgrlc1qfn0vx8dcxerq5s0qmrmjs6j989z53y48c09ue5", + "00144cdec31db836460a41e0d8f7286a4539454892a7", { + "chain": "test", "isPrivkey": false, - "chain": "test" - } - ], - [ - "6vRJaVegzBxTXdgGEimmmSsEv1CLdAgfpaHsZbXUxkPfm9H8U7X", - "aaf19a8a8eacca26b2ec3678e47ee22a04fc1efac61bcd2a41af332be63bab8b", - { - "isCompressed": false, - "isPrivkey": true, - "chain": "main" + "tryCaseFlip": true } ], [ - "T7LHhPHG4mno7XPvBXajDrA5v2nLVSw16sTErD9y6Yki3bGTuHgf", - "7fbda89e59e07db5897cabfde8eb8036d4bebdfddfeac97319e74c74c02799f2", + "tgrlc1q8n8dvyrrkk9dvzyu2lt8vthrl0rtxswglh48f8amfn3ghedvldas0appnf", + "00203cced61063b58ad6089c57d6762ee3fbc6b341c8fdea749fbb4ce28be5acfb7b", { - "isCompressed": true, - "isPrivkey": true, - "chain": "main" + "chain": "test", + "isPrivkey": false, + "tryCaseFlip": true } ], [ - "93VwGxfztHBcUefSWA3JMzKsr6Jg4atmZdKvi1MXTgB9HLypXry", - "fc1528167b31735464059aef58cf71b501eaa146bae7e47f406c61f7ac28555c", + "tgrlc1zpqy8mmvs40tcm9axdvnzsy0utu78ayh6", + "521008087ded90abd78d97a66b262811fc5f", { - "isCompressed": false, - "isPrivkey": true, - "chain": "test" + "chain": "test", + "isPrivkey": false, + "tryCaseFlip": true } ], [ - "cW8HPuCThQ4EsLEU8S6Gborp7NfwXDc2uh2Aua83kmhjqN8GzEVk", - "fef231a9299de5b2d3ea012cd2471bdc80d38e489f5f4a7803ac3279a7d727a9", + "rgrlc1qrexg9p3r843ktpcfeet0y7la376yl5u4243npg", + "00141e4c8286233d63658709ce56f27bfd8fb44fd395", { - "isCompressed": true, - "isPrivkey": true, - "chain": "test" + "chain": "regtest", + "isPrivkey": false, + "tryCaseFlip": true } ], [ - "LeZc1mA2SgaNTJ4WE8pKegNKbZekqovqvK", - "76a914d421ce551279f3fdfb6e4f7390b06516c3daaaa288ac", + "rgrlc1qj7kzgppz54tgeg75y7d80gd66zx8rn9zj3pcxuttqt62zepxtp8swu5y59", + "002097ac240422a5568ca3d4279a77a1bad08c71cca2944383716b02f4a16426584f", { + "chain": "regtest", "isPrivkey": false, - "chain": "main" + "tryCaseFlip": true } ], [ - "M825mF1bLC3hPL6ZmaEVqZ2pouU5iRE72D", - "a914014f2e7072e9907c7f636d937759b8ceb1053feb87", + "rgrlc1sdy0quwk6lfflqv4vtayueugx8swpr9wr3s2g5elalnynd53yvla5c5ck86vk74gg42mgtq", + "6028691e0e3adafa53f032ac5f49ccf1063c1c1195c38c148a67fdfcc936d22467fb4c53163e996f5508", { + "chain": "regtest", "isPrivkey": false, - "chain": "main" + "tryCaseFlip": true } ], [ - "ltc1qw508d6qejxtdg4y5r3zarvary0c5xw7kgmn4n9", - "0014751e76e8199196d454941c45d1b3a323f1433bd6", + "GLxnt7nYbw2eSc1fZmn93stb9sSvEgpxYT", + "76a9142234ffddec664f175b815ff5f149dcb6db9be1da88ac", { - "isPrivkey": false, "chain": "main", - "tryCaseFlip": true + "isPrivkey": false } ], [ - "rltc1qw508d6qejxtdg4y5r3zarvary0c5xw7k693xs3", - "0014751e76e8199196d454941c45d1b3a323f1433bd6", + "MVtcjAC3Udqm8FAvkh9yac1jcrQu2ZpFdC", + "a914f13877ed87d023b3fd3e1fb387b939cdb5aa155a87", { - "isPrivkey": false, - "chain": "regtest", - "tryCaseFlip": true + "chain": "main", + "isPrivkey": false } ], [ - "tltc1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3qsnr4fp", - "00201863143c14c5166804bd19203356da136c985678cd4d27a1b8c6329604903262", + "n3Hq9VgPyktnBc7MtM5njwEjo8PBBsKr1F", + "76a914eed764ac43fd8a13cfafce081dfccd5801719b9788ac", { - "isPrivkey": false, "chain": "test", - "tryCaseFlip": true + "isPrivkey": false } ], [ - "ltc1pw508d6qejxtdg4y5r3zarvary0c5xw7kw508d6qejxtdg4y5r3zarvary0c5xw7k0tul4w", - "5128751e76e8199196d454941c45d1b3a323f1433bd6751e76e8199196d454941c45d1b3a323f1433bd6", + "QiDMT7sCYzgZs35FYws4HUFVQ4Eej3mXzS", + "a914ed0b03eaba642ef3ecc3de3ad5da27650a48862187", { - "isPrivkey": false, - "chain": "main", - "tryCaseFlip": true + "chain": "test", + "isPrivkey": false } ], [ - "ltc1sw50qzgydf5", - "6002751e", + "mwweLAEdTM3pa9K2MGZgA3zWyzJfqied3x", + "76a914b42d6a8f85e42085d18819c31f287749c724c5e488ac", { - "isPrivkey": false, - "chain": "main", - "tryCaseFlip": true + "chain": "regtest", + "isPrivkey": false } ], [ - "ltc1zw508d6qejxtdg4y5r3zarvaryvdzur3w", - "5210751e76e8199196d454941c45d1b3a323", + "QUPAszoT4ywyCXCt86UP3U67LaxSxU4CU2", + "a914555496f43c8fc0c2f0638a84dd8a54ee1f9bc08f87", { - "isPrivkey": false, - "chain": "main", - "tryCaseFlip": true + "chain": "regtest", + "isPrivkey": false } ], [ - "tltc1qqqqqp399et2xygdj5xreqhjjvcmzhxw4aywxecjdzew6hylgvsesu9tmgm", - "0020000000c4a5cad46221b2a187905e5266362b99d5e91c6ce24d165dab93e86433", + "6w3zwLRwbBCRDRG2WttJEt8Zft13WN9HkbRjdj7YgkLBdmS2eMT", + "fe44248109935b0c898218655722711b88e15334a5c00c1ae513b4603b42320e", { - "isPrivkey": false, - "chain": "test", - "tryCaseFlip": true + "chain": "main", + "isCompressed": false, + "isPrivkey": true } ], [ - "rltc1qqqqqp399et2xygdj5xreqhjjvcmzhxw4aywxecjdzew6hylgvsesxuhrdn", - "0020000000c4a5cad46221b2a187905e5266362b99d5e91c6ce24d165dab93e86433", + "T6jqsSNbzRUibgukWiKHovpbsNzpP1webM579pHPfa51HWvWdKLC", + "6e05594c2c4e5bc146cdeb09e5ec1906bbe2e9aba641e25edc57b7243c4165e0", { - "isPrivkey": false, - "chain": "regtest", - "tryCaseFlip": true + "chain": "main", + "isCompressed": true, + "isPrivkey": true } ] -] \ No newline at end of file +] diff --git a/src/test/main_tests.cpp b/src/test/main_tests.cpp index efba85b0345f..074215c71e69 100644 --- a/src/test/main_tests.cpp +++ b/src/test/main_tests.cpp @@ -55,7 +55,7 @@ BOOST_AUTO_TEST_CASE(subsidy_limit_test) nSum += nSubsidy * 1000; BOOST_CHECK(MoneyRange(nSum)); } - BOOST_CHECK_EQUAL(nSum, 8399999990760000ULL); + BOOST_CHECK_EQUAL(nSum, 6899999992410000ULL); } bool ReturnFalse() { return false; } diff --git a/src/test/miner_tests.cpp b/src/test/miner_tests.cpp index 72646da4b0ff..3ad37b872ec7 100644 --- a/src/test/miner_tests.cpp +++ b/src/test/miner_tests.cpp @@ -207,7 +207,7 @@ BOOST_AUTO_TEST_CASE(CreateNewBlock_validity) // Note that by default, these tests run with size accounting enabled. const auto chainParams = CreateChainParams(CBaseChainParams::MAIN); const CChainParams& chainparams = *chainParams; - CScript scriptPubKey = CScript() << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f") << OP_CHECKSIG; + CScript scriptPubKey = CScript() << ParseHex("696984710fa689ad5023690c80f3a49c8f13f8d45b8c857fbcbc8bc4a8e4d3eb4b10f4d4604fa08dce601aaf0f470216fe1b51850b4acf21b179c45070ac7b03a9") << OP_CHECKSIG; std::unique_ptr pblocktemplate; CMutableTransaction tx,tx2; CScript script; diff --git a/src/test/script_tests.cpp b/src/test/script_tests.cpp index c7a497f3a73c..4c76bb1b1411 100644 --- a/src/test/script_tests.cpp +++ b/src/test/script_tests.cpp @@ -1472,7 +1472,7 @@ BOOST_AUTO_TEST_CASE(script_can_append_self) BOOST_CHECK(s == d); // check doubling a script that's large enough to require reallocation - static const char hex[] = "04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f"; + static const char hex[] = "696984710fa689ad5023690c80f3a49c8f13f8d45b8c857fbcbc8bc4a8e4d3eb4b10f4d4604fa08dce601aaf0f470216fe1b51850b4acf21b179c45070ac7b03a9"; s = CScript() << ParseHex(hex) << OP_CHECKSIG; d = CScript() << ParseHex(hex) << OP_CHECKSIG << ParseHex(hex) << OP_CHECKSIG; s += s; diff --git a/src/test/util_tests.cpp b/src/test/util_tests.cpp index 4b2da3e2193a..1ae25d816671 100644 --- a/src/test/util_tests.cpp +++ b/src/test/util_tests.cpp @@ -54,7 +54,7 @@ BOOST_AUTO_TEST_CASE(util_ParseHex) std::vector result; std::vector expected(ParseHex_expected, ParseHex_expected + sizeof(ParseHex_expected)); // Basic test vector - result = ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f"); + result = ParseHex("696984710fa689ad5023690c80f3a49c8f13f8d45b8c857fbcbc8bc4a8e4d3eb4b10f4d4604fa08dce601aaf0f470216fe1b51850b4acf21b179c45070ac7b03a9"); BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(), result.end(), expected.begin(), expected.end()); // Spaces between bytes must be supported @@ -74,7 +74,7 @@ BOOST_AUTO_TEST_CASE(util_HexStr) { BOOST_CHECK_EQUAL( HexStr(ParseHex_expected, ParseHex_expected + sizeof(ParseHex_expected)), - "04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f"); + "696984710fa689ad5023690c80f3a49c8f13f8d45b8c857fbcbc8bc4a8e4d3eb4b10f4d4604fa08dce601aaf0f470216fe1b51850b4acf21b179c45070ac7b03a9"); BOOST_CHECK_EQUAL( HexStr(ParseHex_expected, ParseHex_expected + 5, true), diff --git a/test/functional/test_framework/address.py b/test/functional/test_framework/address.py index 2f1bfb30efe4..5745eeac3b58 100644 --- a/test/functional/test_framework/address.py +++ b/test/functional/test_framework/address.py @@ -57,7 +57,7 @@ def program_to_witness(version, program, main = False): assert 0 <= version <= 16 assert 2 <= len(program) <= 40 assert version > 0 or len(program) in [20, 32] - return segwit_addr.encode("ltc" if main else "rltc", version, program) + return segwit_addr.encode("grlc" if main else "rgrlc", version, program) def script_to_p2wsh(script, main = False): script = check_script(script) diff --git a/test/functional/test_framework/test_framework.py b/test/functional/test_framework/test_framework.py index 2aa628226df5..116ffc5bc55f 100755 --- a/test/functional/test_framework/test_framework.py +++ b/test/functional/test_framework/test_framework.py @@ -221,7 +221,7 @@ def add_nodes(self, num_nodes, extra_args=None, rpchost=None, timewait=None, bin self.nodes.append(TestNode(i, self.options.tmpdir, extra_args[i], rpchost, timewait=timewait, binary=binary[i], stderr=None, mocktime=self.mocktime, coverage_dir=self.options.coveragedir, use_cli=self.options.usecli)) def start_node(self, i, *args, **kwargs): - """Start a litecoind""" + """Start a garlicoind""" node = self.nodes[i] @@ -232,7 +232,7 @@ def start_node(self, i, *args, **kwargs): coverage.write_all_rpc_commands(self.options.coveragedir, node.rpc) def start_nodes(self, extra_args=None, *args, **kwargs): - """Start multiple litecoinds""" + """Start multiple garlicoinds""" if extra_args is None: extra_args = [None] * self.num_nodes @@ -252,12 +252,12 @@ def start_nodes(self, extra_args=None, *args, **kwargs): coverage.write_all_rpc_commands(self.options.coveragedir, node.rpc) def stop_node(self, i): - """Stop a litecoind test node""" + """Stop a garlicoind test node""" self.nodes[i].stop_node() self.nodes[i].wait_until_stopped() def stop_nodes(self): - """Stop multiple litecoind test nodes""" + """Stop multiple garlicoind test nodes""" for node in self.nodes: # Issue RPC to stop nodes node.stop_node() @@ -277,7 +277,7 @@ def assert_start_raises_init_error(self, i, extra_args=None, expected_msg=None, self.start_node(i, extra_args, stderr=log_stderr, *args, **kwargs) self.stop_node(i) except Exception as e: - assert 'litecoind exited' in str(e) # node must have shutdown + assert 'garlicoind exited' in str(e) # node must have shutdown self.nodes[i].running = False self.nodes[i].process = None if expected_msg is not None: @@ -444,7 +444,7 @@ def _initialize_chain_clean(self): class ComparisonTestFramework(BitcoinTestFramework): """Test framework for doing p2p comparison testing - Sets up some litecoind binaries: + Sets up some garlicoind binaries: - 1 binary: test binary - 2 binaries: 1 test binary, 1 ref binary - n>2 binaries: 1 test binary, n-1 ref binaries""" diff --git a/test/functional/test_framework/test_node.py b/test/functional/test_framework/test_node.py index b1ed5876740d..e3acc910428f 100755 --- a/test/functional/test_framework/test_node.py +++ b/test/functional/test_framework/test_node.py @@ -52,7 +52,7 @@ def __init__(self, i, dirname, extra_args, rpchost, timewait, binary, stderr, mo # Wait for up to 60 seconds for the RPC server to respond self.rpc_timeout = 60 if binary is None: - self.binary = os.getenv("LITECOIND", "litecoind") + self.binary = os.getenv("GARLICOIND", "garlicoind") else: self.binary = binary self.stderr = stderr @@ -61,7 +61,7 @@ def __init__(self, i, dirname, extra_args, rpchost, timewait, binary, stderr, mo self.extra_args = extra_args self.args = [self.binary, "-datadir=" + self.datadir, "-server", "-keypool=1", "-discover=0", "-rest", "-logtimemicros", "-debug", "-debugexclude=libevent", "-debugexclude=leveldb", "-mocktime=" + str(mocktime), "-uacomment=testnode%d" % i] - self.cli = TestNodeCLI(os.getenv("LITECOINCLI", "garlicoin-cli"), self.datadir) + self.cli = TestNodeCLI(os.getenv("GARLICOINCLI", "garlicoin-cli"), self.datadir) self.use_cli = use_cli self.running = False @@ -89,14 +89,14 @@ def start(self, extra_args=None, stderr=None, *args, **kwargs): stderr = self.stderr self.process = subprocess.Popen(self.args + extra_args, stderr=stderr, *args, **kwargs) self.running = True - self.log.debug("litecoind started, waiting for RPC to come up") + self.log.debug("garlicoind started, waiting for RPC to come up") def wait_for_rpc_connection(self): """Sets up an RPC connection to the bitcoind process. Returns False if unable to connect.""" # Poll at a rate of four times per second poll_per_s = 4 for _ in range(poll_per_s * self.rpc_timeout): - assert self.process.poll() is None, "litecoind exited with status %i during initialization" % self.process.returncode + assert self.process.poll() is None, "garlicoind exited with status %i during initialization" % self.process.returncode try: self.rpc = get_rpc_proxy(rpc_url(self.datadir, self.index, self.rpchost), self.index, timeout=self.rpc_timeout, coveragedir=self.coverage_dir) self.rpc.getblockcount() @@ -115,7 +115,7 @@ def wait_for_rpc_connection(self): if "No RPC credentials" not in str(e): raise time.sleep(1.0 / poll_per_s) - raise AssertionError("Unable to connect to litecoind") + raise AssertionError("Unable to connect to garlicoind") def get_wallet_rpc(self, wallet_name): if self.use_cli: