Browse Source

Remove unused variables and/or function calls

0.16
practicalswift 7 years ago
parent
commit
2e6080bbf3
  1. 2
      test/functional/bip68-sequence.py
  2. 2
      test/functional/bumpfee.py
  3. 1
      test/functional/fundrawtransaction.py
  4. 1
      test/functional/import-rescan.py
  5. 13
      test/functional/importmulti.py
  6. 5
      test/functional/importprunedfunds.py
  7. 18
      test/functional/p2p-fullblocktest.py
  8. 1
      test/functional/p2p-segwit.py
  9. 2
      test/functional/rawtransactions.py
  10. 6
      test/functional/replace-by-fee.py
  11. 1
      test/functional/segwit.py
  12. 10
      test/functional/test_framework/address.py
  13. 39
      test/functional/test_framework/bignum.py
  14. 10
      test/functional/test_framework/blockstore.py
  15. 11
      test/functional/test_framework/mininode.py
  16. 20
      test/functional/test_framework/netutil.py
  17. 245
      test/functional/test_framework/script.py
  18. 2
      test/functional/wallet.py

2
test/functional/bip68-sequence.py

@ -387,7 +387,7 @@ class BIP68Test(BitcoinTestFramework):
tx = FromHex(CTransaction(), rawtxfund) tx = FromHex(CTransaction(), rawtxfund)
tx.nVersion = 2 tx.nVersion = 2
tx_signed = self.nodes[1].signrawtransaction(ToHex(tx))["hex"] tx_signed = self.nodes[1].signrawtransaction(ToHex(tx))["hex"]
tx_id = self.nodes[1].sendrawtransaction(tx_signed) self.nodes[1].sendrawtransaction(tx_signed)
if __name__ == '__main__': if __name__ == '__main__':
BIP68Test().main() BIP68Test().main()

2
test/functional/bumpfee.py

@ -167,7 +167,7 @@ def test_bumpfee_with_descendant_fails(rbf_node, rbf_node_address, dest_address)
parent_id = spend_one_input(rbf_node, rbf_node_address) parent_id = spend_one_input(rbf_node, rbf_node_address)
tx = rbf_node.createrawtransaction([{"txid": parent_id, "vout": 0}], {dest_address: 0.00020000}) tx = rbf_node.createrawtransaction([{"txid": parent_id, "vout": 0}], {dest_address: 0.00020000})
tx = rbf_node.signrawtransaction(tx) tx = rbf_node.signrawtransaction(tx)
txid = rbf_node.sendrawtransaction(tx["hex"]) rbf_node.sendrawtransaction(tx["hex"])
assert_raises_jsonrpc(-8, "Transaction has descendants in the wallet", rbf_node.bumpfee, parent_id) assert_raises_jsonrpc(-8, "Transaction has descendants in the wallet", rbf_node.bumpfee, parent_id)

1
test/functional/fundrawtransaction.py

@ -312,7 +312,6 @@ class RawTransactionsTest(BitcoinTestFramework):
############################################## ##############################################
# test a fundrawtransaction with invalid vin # # test a fundrawtransaction with invalid vin #
############################################## ##############################################
listunspent = self.nodes[2].listunspent()
inputs = [ {'txid' : "1c7f966dab21119bac53213a2bc7532bff1fa844c124fd750a7d0b1332440bd1", 'vout' : 0} ] #invalid vin! inputs = [ {'txid' : "1c7f966dab21119bac53213a2bc7532bff1fa844c124fd750a7d0b1332440bd1", 'vout' : 0} ] #invalid vin!
outputs = { self.nodes[0].getnewaddress() : 1.0} outputs = { self.nodes[0].getnewaddress() : 1.0}
rawtx = self.nodes[2].createrawtransaction(inputs, outputs) rawtx = self.nodes[2].createrawtransaction(inputs, outputs)

1
test/functional/import-rescan.py

@ -161,7 +161,6 @@ class ImportRescanTest(BitcoinTestFramework):
variant.check() variant.check()
# Create new transactions sending to each address. # Create new transactions sending to each address.
fee = self.nodes[0].getnetworkinfo()["relayfee"]
for i, variant in enumerate(IMPORT_VARIANTS): for i, variant in enumerate(IMPORT_VARIANTS):
variant.sent_amount = 10 - (2 * i + 1) / 8.0 variant.sent_amount = 10 - (2 * i + 1) / 8.0
variant.sent_txid = self.nodes[0].sendtoaddress(variant.address["address"], variant.sent_amount) variant.sent_txid = self.nodes[0].sendtoaddress(variant.address["address"], variant.sent_amount)

13
test/functional/importmulti.py

@ -21,16 +21,7 @@ class ImportMultiTest (BitcoinTestFramework):
self.nodes[1].generate(1) self.nodes[1].generate(1)
timestamp = self.nodes[1].getblock(self.nodes[1].getbestblockhash())['mediantime'] timestamp = self.nodes[1].getblock(self.nodes[1].getbestblockhash())['mediantime']
# keyword definition
PRIV_KEY = 'privkey'
PUB_KEY = 'pubkey'
ADDRESS_KEY = 'address'
SCRIPT_KEY = 'script'
node0_address1 = self.nodes[0].validateaddress(self.nodes[0].getnewaddress()) node0_address1 = self.nodes[0].validateaddress(self.nodes[0].getnewaddress())
node0_address2 = self.nodes[0].validateaddress(self.nodes[0].getnewaddress())
node0_address3 = self.nodes[0].validateaddress(self.nodes[0].getnewaddress())
#Check only one address #Check only one address
assert_equal(node0_address1['ismine'], True) assert_equal(node0_address1['ismine'], True)
@ -230,7 +221,6 @@ class ImportMultiTest (BitcoinTestFramework):
transactionid = self.nodes[1].sendtoaddress(multi_sig_script['address'], 10.00) transactionid = self.nodes[1].sendtoaddress(multi_sig_script['address'], 10.00)
self.nodes[1].generate(1) self.nodes[1].generate(1)
timestamp = self.nodes[1].getblock(self.nodes[1].getbestblockhash())['mediantime'] timestamp = self.nodes[1].getblock(self.nodes[1].getbestblockhash())['mediantime']
transaction = self.nodes[1].gettransaction(transactionid)
self.log.info("Should import a p2sh") self.log.info("Should import a p2sh")
result = self.nodes[1].importmulti([{ result = self.nodes[1].importmulti([{
@ -258,7 +248,6 @@ class ImportMultiTest (BitcoinTestFramework):
transactionid = self.nodes[1].sendtoaddress(multi_sig_script['address'], 10.00) transactionid = self.nodes[1].sendtoaddress(multi_sig_script['address'], 10.00)
self.nodes[1].generate(1) self.nodes[1].generate(1)
timestamp = self.nodes[1].getblock(self.nodes[1].getbestblockhash())['mediantime'] timestamp = self.nodes[1].getblock(self.nodes[1].getbestblockhash())['mediantime']
transaction = self.nodes[1].gettransaction(transactionid)
self.log.info("Should import a p2sh with respective redeem script") self.log.info("Should import a p2sh with respective redeem script")
result = self.nodes[1].importmulti([{ result = self.nodes[1].importmulti([{
@ -286,7 +275,6 @@ class ImportMultiTest (BitcoinTestFramework):
transactionid = self.nodes[1].sendtoaddress(multi_sig_script['address'], 10.00) transactionid = self.nodes[1].sendtoaddress(multi_sig_script['address'], 10.00)
self.nodes[1].generate(1) self.nodes[1].generate(1)
timestamp = self.nodes[1].getblock(self.nodes[1].getbestblockhash())['mediantime'] timestamp = self.nodes[1].getblock(self.nodes[1].getbestblockhash())['mediantime']
transaction = self.nodes[1].gettransaction(transactionid)
self.log.info("Should import a p2sh with respective redeem script and private keys") self.log.info("Should import a p2sh with respective redeem script and private keys")
result = self.nodes[1].importmulti([{ result = self.nodes[1].importmulti([{
@ -314,7 +302,6 @@ class ImportMultiTest (BitcoinTestFramework):
transactionid = self.nodes[1].sendtoaddress(multi_sig_script['address'], 10.00) transactionid = self.nodes[1].sendtoaddress(multi_sig_script['address'], 10.00)
self.nodes[1].generate(1) self.nodes[1].generate(1)
timestamp = self.nodes[1].getblock(self.nodes[1].getbestblockhash())['mediantime'] timestamp = self.nodes[1].getblock(self.nodes[1].getbestblockhash())['mediantime']
transaction = self.nodes[1].gettransaction(transactionid)
self.log.info("Should import a p2sh with respective redeem script and private keys") self.log.info("Should import a p2sh with respective redeem script and private keys")
result = self.nodes[1].importmulti([{ result = self.nodes[1].importmulti([{

5
test/functional/importprunedfunds.py

@ -24,7 +24,6 @@ class ImportPrunedFundsTest(BitcoinTestFramework):
address1 = self.nodes[0].getnewaddress() address1 = self.nodes[0].getnewaddress()
# pubkey # pubkey
address2 = self.nodes[0].getnewaddress() address2 = self.nodes[0].getnewaddress()
address2_pubkey = self.nodes[0].validateaddress(address2)['pubkey'] # Using pubkey
# privkey # privkey
address3 = self.nodes[0].getnewaddress() address3 = self.nodes[0].getnewaddress()
address3_privkey = self.nodes[0].dumpprivkey(address3) # Using privkey address3_privkey = self.nodes[0].dumpprivkey(address3) # Using privkey
@ -77,13 +76,13 @@ class ImportPrunedFundsTest(BitcoinTestFramework):
#Import with affiliated address with no rescan #Import with affiliated address with no rescan
self.nodes[1].importaddress(address2, "add2", False) self.nodes[1].importaddress(address2, "add2", False)
result2 = self.nodes[1].importprunedfunds(rawtxn2, proof2) self.nodes[1].importprunedfunds(rawtxn2, proof2)
balance2 = self.nodes[1].getbalance("add2", 0, True) balance2 = self.nodes[1].getbalance("add2", 0, True)
assert_equal(balance2, Decimal('0.05')) assert_equal(balance2, Decimal('0.05'))
#Import with private key with no rescan #Import with private key with no rescan
self.nodes[1].importprivkey(address3_privkey, "add3", False) self.nodes[1].importprivkey(address3_privkey, "add3", False)
result3 = self.nodes[1].importprunedfunds(rawtxn3, proof3) self.nodes[1].importprunedfunds(rawtxn3, proof3)
balance3 = self.nodes[1].getbalance("add3", 0, False) balance3 = self.nodes[1].getbalance("add3", 0, False)
assert_equal(balance3, Decimal('0.025')) assert_equal(balance3, Decimal('0.025'))
balance3 = self.nodes[1].getbalance("*", 0, True) balance3 = self.nodes[1].getbalance("*", 0, True)

18
test/functional/p2p-fullblocktest.py

@ -397,7 +397,7 @@ class FullBlockTest(ComparisonTestFramework):
yield rejected(RejectResult(16, b'bad-cb-length')) yield rejected(RejectResult(16, b'bad-cb-length'))
# Extend the b26 chain to make sure bitcoind isn't accepting b26 # Extend the b26 chain to make sure bitcoind isn't accepting b26
b27 = block(27, spend=out[7]) block(27, spend=out[7])
yield rejected(False) yield rejected(False)
# Now try a too-large-coinbase script # Now try a too-large-coinbase script
@ -409,7 +409,7 @@ class FullBlockTest(ComparisonTestFramework):
yield rejected(RejectResult(16, b'bad-cb-length')) yield rejected(RejectResult(16, b'bad-cb-length'))
# Extend the b28 chain to make sure bitcoind isn't accepting b28 # Extend the b28 chain to make sure bitcoind isn't accepting b28
b29 = block(29, spend=out[7]) block(29, spend=out[7])
yield rejected(False) yield rejected(False)
# b30 has a max-sized coinbase scriptSig. # b30 has a max-sized coinbase scriptSig.
@ -581,7 +581,7 @@ class FullBlockTest(ComparisonTestFramework):
# same as b40, but one less sigop # same as b40, but one less sigop
tip(39) tip(39)
b41 = block(41, spend=None) block(41, spend=None)
update_block(41, b40.vtx[1:-1]) update_block(41, b40.vtx[1:-1])
b41_sigops_to_fill = b40_sigops_to_fill - 1 b41_sigops_to_fill = b40_sigops_to_fill - 1
tx = CTransaction() tx = CTransaction()
@ -927,7 +927,7 @@ class FullBlockTest(ComparisonTestFramework):
# -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17) -> b64 (18) -> b65 (19) # -> b42 (12) -> b43 (13) -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17) -> b64 (18) -> b65 (19)
# #
tip(64) tip(64)
b65 = block(65) block(65)
tx1 = create_and_sign_tx(out[19].tx, out[19].n, out[19].tx.vout[0].nValue) tx1 = create_and_sign_tx(out[19].tx, out[19].n, out[19].tx.vout[0].nValue)
tx2 = create_and_sign_tx(tx1, 0, 0) tx2 = create_and_sign_tx(tx1, 0, 0)
update_block(65, [tx1, tx2]) update_block(65, [tx1, tx2])
@ -939,7 +939,7 @@ class FullBlockTest(ComparisonTestFramework):
# -> b43 (13) -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17) -> b64 (18) -> b65 (19) # -> b43 (13) -> b53 (14) -> b55 (15) -> b57 (16) -> b60 (17) -> b64 (18) -> b65 (19)
# \-> b66 (20) # \-> b66 (20)
tip(65) tip(65)
b66 = block(66) block(66)
tx1 = create_and_sign_tx(out[20].tx, out[20].n, out[20].tx.vout[0].nValue) tx1 = create_and_sign_tx(out[20].tx, out[20].n, out[20].tx.vout[0].nValue)
tx2 = create_and_sign_tx(tx1, 0, 1) tx2 = create_and_sign_tx(tx1, 0, 1)
update_block(66, [tx2, tx1]) update_block(66, [tx2, tx1])
@ -952,7 +952,7 @@ class FullBlockTest(ComparisonTestFramework):
# #
# #
tip(65) tip(65)
b67 = block(67) block(67)
tx1 = create_and_sign_tx(out[20].tx, out[20].n, out[20].tx.vout[0].nValue) tx1 = create_and_sign_tx(out[20].tx, out[20].n, out[20].tx.vout[0].nValue)
tx2 = create_and_sign_tx(tx1, 0, 1) tx2 = create_and_sign_tx(tx1, 0, 1)
tx3 = create_and_sign_tx(tx1, 0, 2) tx3 = create_and_sign_tx(tx1, 0, 2)
@ -972,7 +972,7 @@ class FullBlockTest(ComparisonTestFramework):
# this succeeds # this succeeds
# #
tip(65) tip(65)
b68 = block(68, additional_coinbase_value=10) block(68, additional_coinbase_value=10)
tx = create_and_sign_tx(out[20].tx, out[20].n, out[20].tx.vout[0].nValue-9) tx = create_and_sign_tx(out[20].tx, out[20].n, out[20].tx.vout[0].nValue-9)
update_block(68, [tx]) update_block(68, [tx])
yield rejected(RejectResult(16, b'bad-cb-amount')) yield rejected(RejectResult(16, b'bad-cb-amount'))
@ -1175,7 +1175,7 @@ class FullBlockTest(ComparisonTestFramework):
# #
# -> b81 (26) -> b82 (27) -> b83 (28) # -> b81 (26) -> b82 (27) -> b83 (28)
# #
b83 = block(83) block(83)
op_codes = [OP_IF, OP_INVALIDOPCODE, OP_ELSE, OP_TRUE, OP_ENDIF] op_codes = [OP_IF, OP_INVALIDOPCODE, OP_ELSE, OP_TRUE, OP_ENDIF]
script = CScript(op_codes) script = CScript(op_codes)
tx1 = create_and_sign_tx(out[28].tx, out[28].n, out[28].tx.vout[0].nValue, script) tx1 = create_and_sign_tx(out[28].tx, out[28].n, out[28].tx.vout[0].nValue, script)
@ -1195,7 +1195,7 @@ class FullBlockTest(ComparisonTestFramework):
# \-> b85 (29) -> b86 (30) \-> b89a (32) # \-> b85 (29) -> b86 (30) \-> b89a (32)
# #
# #
b84 = block(84) block(84)
tx1 = create_tx(out[29].tx, out[29].n, 0, CScript([OP_RETURN])) tx1 = create_tx(out[29].tx, out[29].n, 0, CScript([OP_RETURN]))
tx1.vout.append(CTxOut(0, CScript([OP_TRUE]))) tx1.vout.append(CTxOut(0, CScript([OP_TRUE])))
tx1.vout.append(CTxOut(0, CScript([OP_TRUE]))) tx1.vout.append(CTxOut(0, CScript([OP_TRUE])))

1
test/functional/p2p-segwit.py

@ -17,7 +17,6 @@ from binascii import hexlify
# The versionbit bit used to signal activation of SegWit # The versionbit bit used to signal activation of SegWit
VB_WITNESS_BIT = 1 VB_WITNESS_BIT = 1
VB_PERIOD = 144 VB_PERIOD = 144
VB_ACTIVATION_THRESHOLD = 108
VB_TOP_BITS = 0x20000000 VB_TOP_BITS = 0x20000000
MAX_SIGOP_COST = 80000 MAX_SIGOP_COST = 80000

2
test/functional/rawtransactions.py

@ -63,7 +63,6 @@ class RawTransactionsTest(BitcoinTestFramework):
addr2Obj = self.nodes[2].validateaddress(addr2) addr2Obj = self.nodes[2].validateaddress(addr2)
mSigObj = self.nodes[2].addmultisigaddress(2, [addr1Obj['pubkey'], addr2Obj['pubkey']]) mSigObj = self.nodes[2].addmultisigaddress(2, [addr1Obj['pubkey'], addr2Obj['pubkey']])
mSigObjValid = self.nodes[2].validateaddress(mSigObj)
#use balance deltas instead of absolute values #use balance deltas instead of absolute values
bal = self.nodes[2].getbalance() bal = self.nodes[2].getbalance()
@ -87,7 +86,6 @@ class RawTransactionsTest(BitcoinTestFramework):
addr3Obj = self.nodes[2].validateaddress(addr3) addr3Obj = self.nodes[2].validateaddress(addr3)
mSigObj = self.nodes[2].addmultisigaddress(2, [addr1Obj['pubkey'], addr2Obj['pubkey'], addr3Obj['pubkey']]) mSigObj = self.nodes[2].addmultisigaddress(2, [addr1Obj['pubkey'], addr2Obj['pubkey'], addr3Obj['pubkey']])
mSigObjValid = self.nodes[2].validateaddress(mSigObj)
txId = self.nodes[0].sendtoaddress(mSigObj, 2.2) txId = self.nodes[0].sendtoaddress(mSigObj, 2.2)
decTx = self.nodes[0].gettransaction(txId) decTx = self.nodes[0].gettransaction(txId)

6
test/functional/replace-by-fee.py

@ -270,7 +270,7 @@ class ReplaceByFeeTest(BitcoinTestFramework):
tx1a.vin = [CTxIn(tx0_outpoint, nSequence=0)] tx1a.vin = [CTxIn(tx0_outpoint, nSequence=0)]
tx1a.vout = [CTxOut(1*COIN, CScript([b'a']))] tx1a.vout = [CTxOut(1*COIN, CScript([b'a']))]
tx1a_hex = txToHex(tx1a) tx1a_hex = txToHex(tx1a)
tx1a_txid = self.nodes[0].sendrawtransaction(tx1a_hex, True) self.nodes[0].sendrawtransaction(tx1a_hex, True)
# Higher fee, but the fee per KB is much lower, so the replacement is # Higher fee, but the fee per KB is much lower, so the replacement is
# rejected. # rejected.
@ -331,7 +331,7 @@ class ReplaceByFeeTest(BitcoinTestFramework):
tx1.vin = [CTxIn(confirmed_utxo)] tx1.vin = [CTxIn(confirmed_utxo)]
tx1.vout = [CTxOut(1*COIN, CScript([b'a']))] tx1.vout = [CTxOut(1*COIN, CScript([b'a']))]
tx1_hex = txToHex(tx1) tx1_hex = txToHex(tx1)
tx1_txid = self.nodes[0].sendrawtransaction(tx1_hex, True) self.nodes[0].sendrawtransaction(tx1_hex, True)
tx2 = CTransaction() tx2 = CTransaction()
tx2.vin = [CTxIn(confirmed_utxo), CTxIn(unconfirmed_utxo)] tx2.vin = [CTxIn(confirmed_utxo), CTxIn(unconfirmed_utxo)]
@ -499,7 +499,7 @@ class ReplaceByFeeTest(BitcoinTestFramework):
tx2a.vin = [CTxIn(tx1_outpoint, nSequence=0)] tx2a.vin = [CTxIn(tx1_outpoint, nSequence=0)]
tx2a.vout = [CTxOut(1*COIN, CScript([b'a']))] tx2a.vout = [CTxOut(1*COIN, CScript([b'a']))]
tx2a_hex = txToHex(tx2a) tx2a_hex = txToHex(tx2a)
tx2a_txid = self.nodes[0].sendrawtransaction(tx2a_hex, True) self.nodes[0].sendrawtransaction(tx2a_hex, True)
# Lower fee, but we'll prioritise it # Lower fee, but we'll prioritise it
tx2b = CTransaction() tx2b = CTransaction()

1
test/functional/segwit.py

@ -12,7 +12,6 @@ from test_framework.script import CScript, OP_HASH160, OP_CHECKSIG, OP_0, hash16
from io import BytesIO from io import BytesIO
NODE_0 = 0 NODE_0 = 0
NODE_1 = 1
NODE_2 = 2 NODE_2 = 2
WIT_V0 = 0 WIT_V0 = 0
WIT_V1 = 1 WIT_V1 = 1

10
test/functional/test_framework/address.py

@ -44,16 +44,6 @@ def script_to_p2sh(script, main = False):
script = check_script(script) script = check_script(script)
return scripthash_to_p2sh(hash160(script), main) return scripthash_to_p2sh(hash160(script), main)
def key_to_p2sh_p2wpkh(key, main = False):
key = check_key(key)
p2shscript = CScript([OP_0, hash160(key)])
return script_to_p2sh(p2shscript, main)
def script_to_p2sh_p2wsh(script, main = False):
script = check_script(script)
p2shscript = CScript([OP_0, sha256(script)])
return script_to_p2sh(p2shscript, main)
def check_key(key): def check_key(key):
if (type(key) is str): if (type(key) is str):
key = hex_str_to_bytes(key) # Assuming this is hex string key = hex_str_to_bytes(key) # Assuming this is hex string

39
test/functional/test_framework/bignum.py

@ -26,12 +26,6 @@ def bn2bin(v):
i -= 1 i -= 1
return s return s
def bin2bn(s):
l = 0
for ch in s:
l = (l << 8) | ch
return l
def bn2mpi(v): def bn2mpi(v):
have_ext = False have_ext = False
if v.bit_length() > 0: if v.bit_length() > 0:
@ -54,30 +48,6 @@ def bn2mpi(v):
v_bin[0] |= 0x80 v_bin[0] |= 0x80
return s + ext + v_bin return s + ext + v_bin
def mpi2bn(s):
if len(s) < 4:
return None
s_size = bytes(s[:4])
v_len = struct.unpack(b">I", s_size)[0]
if len(s) != (v_len + 4):
return None
if v_len == 0:
return 0
v_str = bytearray(s[4:])
neg = False
i = v_str[0]
if i & 0x80:
neg = True
i &= ~0x80
v_str[0] = i
v = bin2bn(v_str)
if neg:
return -v
return v
# bitcoin-specific little endian format, with implicit size # bitcoin-specific little endian format, with implicit size
def mpi2vch(s): def mpi2vch(s):
r = s[4:] # strip size r = s[4:] # strip size
@ -86,12 +56,3 @@ def mpi2vch(s):
def bn2vch(v): def bn2vch(v):
return bytes(mpi2vch(bn2mpi(v))) return bytes(mpi2vch(bn2mpi(v)))
def vch2mpi(s):
r = struct.pack(b">I", len(s)) # size
r += s[::-1] # reverse string, converting LE->BE
return r
def vch2bn(s):
return mpi2bn(vch2mpi(s))

10
test/functional/test_framework/blockstore.py

@ -143,16 +143,6 @@ class TxStore(object):
return None return None
return value return value
def get_transaction(self, txhash):
ret = None
serialized_tx = self.get(txhash)
if serialized_tx is not None:
f = BytesIO(serialized_tx)
ret = CTransaction()
ret.deserialize(f)
ret.calc_sha256()
return ret
def add_transaction(self, tx): def add_transaction(self, tx):
tx.calc_sha256() tx.calc_sha256()
try: try:

11
test/functional/test_framework/mininode.py

@ -48,8 +48,8 @@ MAX_BLOCK_BASE_SIZE = 1000000
COIN = 100000000 # 1 btc in satoshis COIN = 100000000 # 1 btc in satoshis
NODE_NETWORK = (1 << 0) NODE_NETWORK = (1 << 0)
NODE_GETUTXO = (1 << 1) # NODE_GETUTXO = (1 << 1)
NODE_BLOOM = (1 << 2) # NODE_BLOOM = (1 << 2)
NODE_WITNESS = (1 << 3) NODE_WITNESS = (1 << 3)
NODE_UNSUPPORTED_SERVICE_BIT_5 = (1 << 5) NODE_UNSUPPORTED_SERVICE_BIT_5 = (1 << 5)
NODE_UNSUPPORTED_SERVICE_BIT_7 = (1 << 7) NODE_UNSUPPORTED_SERVICE_BIT_7 = (1 << 7)
@ -1479,9 +1479,6 @@ class NodeConnCB(object):
# before acquiring the global lock and delivering the next message. # before acquiring the global lock and delivering the next message.
self.deliver_sleep_time = None self.deliver_sleep_time = None
# Remember the services our peer has advertised
self.peer_services = None
# Message receiving methods # Message receiving methods
def deliver(self, conn, message): def deliver(self, conn, message):
@ -1506,10 +1503,6 @@ class NodeConnCB(object):
print("ERROR delivering %s (%s)" % (repr(message), print("ERROR delivering %s (%s)" % (repr(message),
sys.exc_info()[0])) sys.exc_info()[0]))
def set_deliver_sleep_time(self, value):
with mininode_lock:
self.deliver_sleep_time = value
def get_deliver_sleep_time(self): def get_deliver_sleep_time(self):
with mininode_lock: with mininode_lock:
return self.deliver_sleep_time return self.deliver_sleep_time

20
test/functional/test_framework/netutil.py

@ -15,17 +15,17 @@ import array
import os import os
from binascii import unhexlify, hexlify from binascii import unhexlify, hexlify
STATE_ESTABLISHED = '01' # STATE_ESTABLISHED = '01'
STATE_SYN_SENT = '02' # STATE_SYN_SENT = '02'
STATE_SYN_RECV = '03' # STATE_SYN_RECV = '03'
STATE_FIN_WAIT1 = '04' # STATE_FIN_WAIT1 = '04'
STATE_FIN_WAIT2 = '05' # STATE_FIN_WAIT2 = '05'
STATE_TIME_WAIT = '06' # STATE_TIME_WAIT = '06'
STATE_CLOSE = '07' # STATE_CLOSE = '07'
STATE_CLOSE_WAIT = '08' # STATE_CLOSE_WAIT = '08'
STATE_LAST_ACK = '09' # STATE_LAST_ACK = '09'
STATE_LISTEN = '0A' STATE_LISTEN = '0A'
STATE_CLOSING = '0B' # STATE_CLOSING = '0B'
def get_socket_inodes(pid): def get_socket_inodes(pid):
''' '''

245
test/functional/test_framework/script.py

@ -23,9 +23,7 @@ import struct
from .bignum import bn2vch from .bignum import bn2vch
MAX_SCRIPT_SIZE = 10000
MAX_SCRIPT_ELEMENT_SIZE = 520 MAX_SCRIPT_ELEMENT_SIZE = 520
MAX_SCRIPT_OPCODES = 201
OPCODE_NAMES = {} OPCODE_NAMES = {}
@ -242,131 +240,6 @@ OP_PUBKEY = CScriptOp(0xfe)
OP_INVALIDOPCODE = CScriptOp(0xff) OP_INVALIDOPCODE = CScriptOp(0xff)
VALID_OPCODES = {
OP_1NEGATE,
OP_RESERVED,
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,
OP_NOP,
OP_VER,
OP_IF,
OP_NOTIF,
OP_VERIF,
OP_VERNOTIF,
OP_ELSE,
OP_ENDIF,
OP_VERIFY,
OP_RETURN,
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,
OP_CAT,
OP_SUBSTR,
OP_LEFT,
OP_RIGHT,
OP_SIZE,
OP_INVERT,
OP_AND,
OP_OR,
OP_XOR,
OP_EQUAL,
OP_EQUALVERIFY,
OP_RESERVED1,
OP_RESERVED2,
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,
OP_RIPEMD160,
OP_SHA1,
OP_SHA256,
OP_HASH160,
OP_HASH256,
OP_CODESEPARATOR,
OP_CHECKSIG,
OP_CHECKSIGVERIFY,
OP_CHECKMULTISIG,
OP_CHECKMULTISIGVERIFY,
OP_NOP1,
OP_CHECKLOCKTIMEVERIFY,
OP_CHECKSEQUENCEVERIFY,
OP_NOP4,
OP_NOP5,
OP_NOP6,
OP_NOP7,
OP_NOP8,
OP_NOP9,
OP_NOP10,
OP_SMALLINTEGER,
OP_PUBKEYS,
OP_PUBKEYHASH,
OP_PUBKEY,
}
OPCODE_NAMES.update({ OPCODE_NAMES.update({
OP_0 : 'OP_0', OP_0 : 'OP_0',
OP_PUSHDATA1 : 'OP_PUSHDATA1', OP_PUSHDATA1 : 'OP_PUSHDATA1',
@ -486,124 +359,6 @@ OPCODE_NAMES.update({
OP_INVALIDOPCODE : 'OP_INVALIDOPCODE', OP_INVALIDOPCODE : 'OP_INVALIDOPCODE',
}) })
OPCODES_BY_NAME = {
'OP_0' : OP_0,
'OP_PUSHDATA1' : OP_PUSHDATA1,
'OP_PUSHDATA2' : OP_PUSHDATA2,
'OP_PUSHDATA4' : OP_PUSHDATA4,
'OP_1NEGATE' : OP_1NEGATE,
'OP_RESERVED' : OP_RESERVED,
'OP_1' : OP_1,
'OP_2' : OP_2,
'OP_3' : OP_3,
'OP_4' : OP_4,
'OP_5' : OP_5,
'OP_6' : OP_6,
'OP_7' : OP_7,
'OP_8' : OP_8,
'OP_9' : OP_9,
'OP_10' : OP_10,
'OP_11' : OP_11,
'OP_12' : OP_12,
'OP_13' : OP_13,
'OP_14' : OP_14,
'OP_15' : OP_15,
'OP_16' : OP_16,
'OP_NOP' : OP_NOP,
'OP_VER' : OP_VER,
'OP_IF' : OP_IF,
'OP_NOTIF' : OP_NOTIF,
'OP_VERIF' : OP_VERIF,
'OP_VERNOTIF' : OP_VERNOTIF,
'OP_ELSE' : OP_ELSE,
'OP_ENDIF' : OP_ENDIF,
'OP_VERIFY' : OP_VERIFY,
'OP_RETURN' : OP_RETURN,
'OP_TOALTSTACK' : OP_TOALTSTACK,
'OP_FROMALTSTACK' : OP_FROMALTSTACK,
'OP_2DROP' : OP_2DROP,
'OP_2DUP' : OP_2DUP,
'OP_3DUP' : OP_3DUP,
'OP_2OVER' : OP_2OVER,
'OP_2ROT' : OP_2ROT,
'OP_2SWAP' : OP_2SWAP,
'OP_IFDUP' : OP_IFDUP,
'OP_DEPTH' : OP_DEPTH,
'OP_DROP' : OP_DROP,
'OP_DUP' : OP_DUP,
'OP_NIP' : OP_NIP,
'OP_OVER' : OP_OVER,
'OP_PICK' : OP_PICK,
'OP_ROLL' : OP_ROLL,
'OP_ROT' : OP_ROT,
'OP_SWAP' : OP_SWAP,
'OP_TUCK' : OP_TUCK,
'OP_CAT' : OP_CAT,
'OP_SUBSTR' : OP_SUBSTR,
'OP_LEFT' : OP_LEFT,
'OP_RIGHT' : OP_RIGHT,
'OP_SIZE' : OP_SIZE,
'OP_INVERT' : OP_INVERT,
'OP_AND' : OP_AND,
'OP_OR' : OP_OR,
'OP_XOR' : OP_XOR,
'OP_EQUAL' : OP_EQUAL,
'OP_EQUALVERIFY' : OP_EQUALVERIFY,
'OP_RESERVED1' : OP_RESERVED1,
'OP_RESERVED2' : OP_RESERVED2,
'OP_1ADD' : OP_1ADD,
'OP_1SUB' : OP_1SUB,
'OP_2MUL' : OP_2MUL,
'OP_2DIV' : OP_2DIV,
'OP_NEGATE' : OP_NEGATE,
'OP_ABS' : OP_ABS,
'OP_NOT' : OP_NOT,
'OP_0NOTEQUAL' : OP_0NOTEQUAL,
'OP_ADD' : OP_ADD,
'OP_SUB' : OP_SUB,
'OP_MUL' : OP_MUL,
'OP_DIV' : OP_DIV,
'OP_MOD' : OP_MOD,
'OP_LSHIFT' : OP_LSHIFT,
'OP_RSHIFT' : OP_RSHIFT,
'OP_BOOLAND' : OP_BOOLAND,
'OP_BOOLOR' : OP_BOOLOR,
'OP_NUMEQUAL' : OP_NUMEQUAL,
'OP_NUMEQUALVERIFY' : OP_NUMEQUALVERIFY,
'OP_NUMNOTEQUAL' : OP_NUMNOTEQUAL,
'OP_LESSTHAN' : OP_LESSTHAN,
'OP_GREATERTHAN' : OP_GREATERTHAN,
'OP_LESSTHANOREQUAL' : OP_LESSTHANOREQUAL,
'OP_GREATERTHANOREQUAL' : OP_GREATERTHANOREQUAL,
'OP_MIN' : OP_MIN,
'OP_MAX' : OP_MAX,
'OP_WITHIN' : OP_WITHIN,
'OP_RIPEMD160' : OP_RIPEMD160,
'OP_SHA1' : OP_SHA1,
'OP_SHA256' : OP_SHA256,
'OP_HASH160' : OP_HASH160,
'OP_HASH256' : OP_HASH256,
'OP_CODESEPARATOR' : OP_CODESEPARATOR,
'OP_CHECKSIG' : OP_CHECKSIG,
'OP_CHECKSIGVERIFY' : OP_CHECKSIGVERIFY,
'OP_CHECKMULTISIG' : OP_CHECKMULTISIG,
'OP_CHECKMULTISIGVERIFY' : OP_CHECKMULTISIGVERIFY,
'OP_NOP1' : OP_NOP1,
'OP_CHECKLOCKTIMEVERIFY' : OP_CHECKLOCKTIMEVERIFY,
'OP_CHECKSEQUENCEVERIFY' : OP_CHECKSEQUENCEVERIFY,
'OP_NOP4' : OP_NOP4,
'OP_NOP5' : OP_NOP5,
'OP_NOP6' : OP_NOP6,
'OP_NOP7' : OP_NOP7,
'OP_NOP8' : OP_NOP8,
'OP_NOP9' : OP_NOP9,
'OP_NOP10' : OP_NOP10,
'OP_SMALLINTEGER' : OP_SMALLINTEGER,
'OP_PUBKEYS' : OP_PUBKEYS,
'OP_PUBKEYHASH' : OP_PUBKEYHASH,
'OP_PUBKEY' : OP_PUBKEY,
}
class CScriptInvalidError(Exception): class CScriptInvalidError(Exception):
"""Base class for CScript exceptions""" """Base class for CScript exceptions"""
pass pass

2
test/functional/wallet.py

@ -206,7 +206,7 @@ class WalletTest(BitcoinTestFramework):
signedRawTx = self.nodes[1].signrawtransaction(rawTx) signedRawTx = self.nodes[1].signrawtransaction(rawTx)
decRawTx = self.nodes[1].decoderawtransaction(signedRawTx['hex']) decRawTx = self.nodes[1].decoderawtransaction(signedRawTx['hex'])
zeroValueTxid= decRawTx['txid'] zeroValueTxid= decRawTx['txid']
sendResp = self.nodes[1].sendrawtransaction(signedRawTx['hex']) self.nodes[1].sendrawtransaction(signedRawTx['hex'])
self.sync_all() self.sync_all()
self.nodes[1].generate(1) #mine a block self.nodes[1].generate(1) #mine a block

Loading…
Cancel
Save