LBRYCommunity/lbrycrd
1
0
Fork 0
Code Issues 29 Pull requests 1 Projects Releases 32 Packages Wiki Activity

[tests] Remove 'account' API from wallet functional tests

Browse source 
Removes usage of account API from the following functional tests:

- wallet_listreceivedby.py
- wallet_basic.py
- wallet_keypool_topup.py
- wallet_txn_clone.py
- wallet_listsinceblock.py
- wallet_import_rescan.py
- wallet_listtransactions.py
- wallet_txn_doublespend.py
This commit is contained in:
John Newbery 2018-04-24 14:50:00 -05:00
parent baf6b4e3f9
commit 5d536619ab
8 changed files with 78 additions and 126 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

32
test/functional/wallet_basic.py
View file

@ -22,10 +22,9 @@ class WalletTest(BitcoinTestFramework):
def set_test_params(self): def set_test_params(self):
self.num_nodes = 4 self.num_nodes = 4
self.setup_clean_chain = True self.setup_clean_chain = True
self.extra_args = [['-deprecatedrpc=accounts']] * 4
def setup_network(self): def setup_network(self):
self.add_nodes(4, self.extra_args) self.add_nodes(4)
self.start_node(0) self.start_node(0)
self.start_node(1) self.start_node(1)
self.start_node(2) self.start_node(2)
@ -151,7 +150,7 @@ class WalletTest(BitcoinTestFramework):
inputs = [] inputs = []
outputs = {} outputs = {}
inputs.append({"txid": utxo["txid"], "vout": utxo["vout"]}) inputs.append({"txid": utxo["txid"], "vout": utxo["vout"]})
outputs[self.nodes[2].getnewaddress("from1")] = utxo["amount"] - 3 outputs[self.nodes[2].getnewaddress()] = utxo["amount"] - 3
raw_tx = self.nodes[0].createrawtransaction(inputs, outputs) raw_tx = self.nodes[0].createrawtransaction(inputs, outputs)
txns_to_send.append(self.nodes[0].signrawtransactionwithwallet(raw_tx)) txns_to_send.append(self.nodes[0].signrawtransactionwithwallet(raw_tx))
@ -165,7 +164,6 @@ class WalletTest(BitcoinTestFramework):
assert_equal(self.nodes[0].getbalance(), 0) assert_equal(self.nodes[0].getbalance(), 0)
assert_equal(self.nodes[2].getbalance(), 94) assert_equal(self.nodes[2].getbalance(), 94)
assert_equal(self.nodes[2].getbalance("from1"), 94 - 21)
# Verify that a spent output cannot be locked anymore # Verify that a spent output cannot be locked anymore
spent_0 = {"txid": node0utxos[0]["txid"], "vout": node0utxos[0]["vout"]} spent_0 = {"txid": node0utxos[0]["txid"], "vout": node0utxos[0]["vout"]}
@ -190,7 +188,7 @@ class WalletTest(BitcoinTestFramework):
node_0_bal = self.check_fee_amount(self.nodes[0].getbalance(), Decimal('20'), fee_per_byte, self.get_vsize(self.nodes[2].getrawtransaction(txid))) node_0_bal = self.check_fee_amount(self.nodes[0].getbalance(), Decimal('20'), fee_per_byte, self.get_vsize(self.nodes[2].getrawtransaction(txid)))
# Sendmany 10 BTC # Sendmany 10 BTC
txid = self.nodes[2].sendmany('from1', {address: 10}, 0, "", []) txid = self.nodes[2].sendmany('', {address: 10}, 0, "", [])
self.nodes[2].generate(1) self.nodes[2].generate(1)
self.sync_all([self.nodes[0:3]]) self.sync_all([self.nodes[0:3]])
node_0_bal += Decimal('10') node_0_bal += Decimal('10')
@ -198,7 +196,7 @@ class WalletTest(BitcoinTestFramework):
assert_equal(self.nodes[0].getbalance(), node_0_bal) assert_equal(self.nodes[0].getbalance(), node_0_bal)
# Sendmany 10 BTC with subtract fee from amount # Sendmany 10 BTC with subtract fee from amount
txid = self.nodes[2].sendmany('from1', {address: 10}, 0, "", [address]) txid = self.nodes[2].sendmany('', {address: 10}, 0, "", [address])
self.nodes[2].generate(1) self.nodes[2].generate(1)
self.sync_all([self.nodes[0:3]]) self.sync_all([self.nodes[0:3]])
node_2_bal -= Decimal('10') node_2_bal -= Decimal('10')
@ -365,14 +363,14 @@ class WalletTest(BitcoinTestFramework):
# - True: unicode escaped as \u.... # - True: unicode escaped as \u....
# - False: unicode directly as UTF-8 # - False: unicode directly as UTF-8
for mode in [True, False]: for mode in [True, False]:
self.nodes[0].ensure_ascii = mode self.nodes[0].rpc.ensure_ascii = mode
# unicode check: Basic Multilingual Plane, Supplementary Plane respectively # unicode check: Basic Multilingual Plane, Supplementary Plane respectively
for s in [u'рыба', u'𝅘𝅥𝅯']: for label in [u'рыба', u'𝅘𝅥𝅯']:
addr = self.nodes[0].getaccountaddress(s) addr = self.nodes[0].getnewaddress()
label = self.nodes[0].getaccount(addr) self.nodes[0].setlabel(addr, label)
assert_equal(label, s) assert_equal(self.nodes[0].getaddressinfo(addr)['label'], label)
assert(s in self.nodes[0].listaccounts().keys()) assert(label in self.nodes[0].listlabels())
self.nodes[0].ensure_ascii = True # restore to default self.nodes[0].rpc.ensure_ascii = True # restore to default
# maintenance tests # maintenance tests
maintenance = [ maintenance = [
@ -388,9 +386,9 @@ class WalletTest(BitcoinTestFramework):
self.log.info("check " + m) self.log.info("check " + m)
self.stop_nodes() self.stop_nodes()
# set lower ancestor limit for later # set lower ancestor limit for later
self.start_node(0, [m, "-deprecatedrpc=accounts", "-limitancestorcount=" + str(chainlimit)]) self.start_node(0, [m, "-limitancestorcount=" + str(chainlimit)])
self.start_node(1, [m, "-deprecatedrpc=accounts", "-limitancestorcount=" + str(chainlimit)]) self.start_node(1, [m, "-limitancestorcount=" + str(chainlimit)])
self.start_node(2, [m, "-deprecatedrpc=accounts", "-limitancestorcount=" + str(chainlimit)]) self.start_node(2, [m, "-limitancestorcount=" + str(chainlimit)])
if m == '-reindex': if m == '-reindex':
# reindex will leave rpc warm up "early"; Wait for it to finish # reindex will leave rpc warm up "early"; Wait for it to finish
wait_until(lambda: [block_count] * 3 == [self.nodes[i].getblockcount() for i in range(3)]) wait_until(lambda: [block_count] * 3 == [self.nodes[i].getblockcount() for i in range(3)])
@ -438,7 +436,7 @@ class WalletTest(BitcoinTestFramework):
# Try with walletrejectlongchains # Try with walletrejectlongchains
# Double chain limit but require combining inputs, so we pass SelectCoinsMinConf # Double chain limit but require combining inputs, so we pass SelectCoinsMinConf
self.stop_node(0) self.stop_node(0)
self.start_node(0, extra_args=["-deprecatedrpc=accounts", "-walletrejectlongchains", "-limitancestorcount=" + str(2 * chainlimit)]) self.start_node(0, extra_args=["-walletrejectlongchains", "-limitancestorcount=" + str(2 * chainlimit)])
# wait for loadmempool # wait for loadmempool
timeout = 10 timeout = 10

44
test/functional/wallet_import_rescan.py
View file

@ -42,16 +42,15 @@ class Variant(collections.namedtuple("Variant", "call data rescan prune")):
def do_import(self, timestamp): def do_import(self, timestamp):
"""Call one key import RPC.""" """Call one key import RPC."""
rescan = self.rescan == Rescan.yes
if self.call == Call.single: if self.call == Call.single:
if self.data == Data.address: if self.data == Data.address:
response = self.try_rpc(self.node.importaddress, self.address["address"], self.label, response = self.try_rpc(self.node.importaddress, address=self.address["address"], rescan=rescan)
self.rescan == Rescan.yes)
elif self.data == Data.pub: elif self.data == Data.pub:
response = self.try_rpc(self.node.importpubkey, self.address["pubkey"], self.label, response = self.try_rpc(self.node.importpubkey, pubkey=self.address["pubkey"], rescan=rescan)
self.rescan == Rescan.yes)
elif self.data == Data.priv: elif self.data == Data.priv:
response = self.try_rpc(self.node.importprivkey, self.key, self.label, self.rescan == Rescan.yes) response = self.try_rpc(self.node.importprivkey, privkey=self.key, rescan=rescan)
assert_equal(response, None) assert_equal(response, None)
elif self.call == Call.multi: elif self.call == Call.multi:
@ -62,30 +61,22 @@ class Variant(collections.namedtuple("Variant", "call data rescan prune")):
"timestamp": timestamp + TIMESTAMP_WINDOW + (1 if self.rescan == Rescan.late_timestamp else 0), "timestamp": timestamp + TIMESTAMP_WINDOW + (1 if self.rescan == Rescan.late_timestamp else 0),
"pubkeys": [self.address["pubkey"]] if self.data == Data.pub else [], "pubkeys": [self.address["pubkey"]] if self.data == Data.pub else [],
"keys": [self.key] if self.data == Data.priv else [], "keys": [self.key] if self.data == Data.priv else [],
"label": self.label,
"watchonly": self.data != Data.priv "watchonly": self.data != Data.priv
}], {"rescan": self.rescan in (Rescan.yes, Rescan.late_timestamp)}) }], {"rescan": self.rescan in (Rescan.yes, Rescan.late_timestamp)})
assert_equal(response, [{"success": True}]) assert_equal(response, [{"success": True}])
def check(self, txid=None, amount=None, confirmations=None): def check(self, txid=None, amount=None, confirmations=None):
"""Verify that getbalance/listtransactions return expected values.""" """Verify that listreceivedbyaddress returns expected values."""
balance = self.node.getbalance(self.label, 0, True) addresses = self.node.listreceivedbyaddress(minconf=0, include_watchonly=True, address_filter=self.address['address'])
assert_equal(balance, self.expected_balance) if self.expected_txs:
assert_equal(len(addresses[0]["txids"]), self.expected_txs)
txs = self.node.listtransactions(self.label, 10000, 0, True)
assert_equal(len(txs), self.expected_txs)
if txid is not None: if txid is not None:
tx, = [tx for tx in txs if tx["txid"] == txid] address, = [ad for ad in addresses if txid in ad["txids"]]
assert_equal(tx["label"], self.label) assert_equal(address["address"], self.address["address"])
assert_equal(tx["address"], self.address["address"]) assert_equal(address["amount"], self.expected_balance)
assert_equal(tx["amount"], amount) assert_equal(address["confirmations"], confirmations)
assert_equal(tx["category"], "receive")
assert_equal(tx["label"], self.label)
assert_equal(tx["txid"], txid)
assert_equal(tx["confirmations"], confirmations)
assert_equal("trusted" not in tx, True)
# Verify the transaction is correctly marked watchonly depending on # Verify the transaction is correctly marked watchonly depending on
# whether the transaction pays to an imported public key or # whether the transaction pays to an imported public key or
# imported private key. The test setup ensures that transaction # imported private key. The test setup ensures that transaction
@ -93,9 +84,9 @@ class Variant(collections.namedtuple("Variant", "call data rescan prune")):
# involvesWatchonly will be true if either the transaction output # involvesWatchonly will be true if either the transaction output
# or inputs are watchonly). # or inputs are watchonly).
if self.data != Data.priv: if self.data != Data.priv:
assert_equal(tx["involvesWatchonly"], True) assert_equal(address["involvesWatchonly"], True)
else: else:
assert_equal("involvesWatchonly" not in tx, True) assert_equal("involvesWatchonly" not in address, True)
# List of Variants for each way a key or address could be imported. # List of Variants for each way a key or address could be imported.
@ -119,7 +110,7 @@ class ImportRescanTest(BitcoinTestFramework):
self.num_nodes = 2 + len(IMPORT_NODES) self.num_nodes = 2 + len(IMPORT_NODES)
def setup_network(self): def setup_network(self):
extra_args = [["-addresstype=legacy", '-deprecatedrpc=accounts'] for _ in range(self.num_nodes)] extra_args = [["-addresstype=legacy"] for _ in range(self.num_nodes)]
for i, import_node in enumerate(IMPORT_NODES, 2): for i, import_node in enumerate(IMPORT_NODES, 2):
if import_node.prune: if import_node.prune:
extra_args[i] += ["-prune=1"] extra_args[i] += ["-prune=1"]
@ -130,11 +121,10 @@ class ImportRescanTest(BitcoinTestFramework):
connect_nodes(self.nodes[i], 0) connect_nodes(self.nodes[i], 0)
def run_test(self): def run_test(self):
# Create one transaction on node 0 with a unique amount and label for # Create one transaction on node 0 with a unique amount for
# each possible type of wallet import RPC. # each possible type of wallet import RPC.
for i, variant in enumerate(IMPORT_VARIANTS): for i, variant in enumerate(IMPORT_VARIANTS):
variant.label = "label {} {}".format(i, variant) variant.address = self.nodes[1].getaddressinfo(self.nodes[1].getnewaddress())
variant.address = self.nodes[1].getaddressinfo(self.nodes[1].getnewaddress(variant.label))
variant.key = self.nodes[1].dumpprivkey(variant.address["address"]) variant.key = self.nodes[1].dumpprivkey(variant.address["address"])
variant.initial_amount = 10 - (i + 1) / 4.0 variant.initial_amount = 10 - (i + 1) / 4.0
variant.initial_txid = self.nodes[0].sendtoaddress(variant.address["address"], variant.initial_amount) variant.initial_txid = self.nodes[0].sendtoaddress(variant.address["address"], variant.initial_amount)

2
test/functional/wallet_keypool_topup.py
View file

@ -25,7 +25,7 @@ class KeypoolRestoreTest(BitcoinTestFramework):
def set_test_params(self): def set_test_params(self):
self.setup_clean_chain = True self.setup_clean_chain = True
self.num_nodes = 2 self.num_nodes = 2
self.extra_args = [['-deprecatedrpc=accounts'], ['-deprecatedrpc=accounts', '-keypool=100', '-keypoolmin=20']] self.extra_args = [[], ['-keypool=100']]
def run_test(self): def run_test(self):
wallet_path = os.path.join(self.nodes[1].datadir, "regtest", "wallets", "wallet.dat") wallet_path = os.path.join(self.nodes[1].datadir, "regtest", "wallets", "wallet.dat")

7
test/functional/wallet_listreceivedby.py
View file

@ -14,7 +14,6 @@ from test_framework.util import (assert_array_result,
class ReceivedByTest(BitcoinTestFramework): class ReceivedByTest(BitcoinTestFramework):
def set_test_params(self): def set_test_params(self):
self.num_nodes = 2 self.num_nodes = 2
self.extra_args = [['-deprecatedrpc=accounts']] * 2
def run_test(self): def run_test(self):
# Generate block to get out of IBD # Generate block to get out of IBD
@ -112,8 +111,9 @@ class ReceivedByTest(BitcoinTestFramework):
self.log.info("listreceivedbylabel + getreceivedbylabel Test") self.log.info("listreceivedbylabel + getreceivedbylabel Test")
# set pre-state # set pre-state
label = ''
address = self.nodes[1].getnewaddress() address = self.nodes[1].getnewaddress()
label = self.nodes[1].getaccount(address) assert_equal(self.nodes[1].getaddressinfo(address)['label'], label)
received_by_label_json = [r for r in self.nodes[1].listreceivedbylabel() if r["label"] == label][0] received_by_label_json = [r for r in self.nodes[1].listreceivedbylabel() if r["label"] == label][0]
balance_by_label = self.nodes[1].getreceivedbylabel(label) balance_by_label = self.nodes[1].getreceivedbylabel(label)
@ -141,7 +141,8 @@ class ReceivedByTest(BitcoinTestFramework):
assert_equal(balance, balance_by_label + Decimal("0.1")) assert_equal(balance, balance_by_label + Decimal("0.1"))
# Create a new label named "mynewlabel" that has a 0 balance # Create a new label named "mynewlabel" that has a 0 balance
self.nodes[1].getlabeladdress(label="mynewlabel", force=True) address = self.nodes[1].getnewaddress()
self.nodes[1].setlabel(address, "mynewlabel")
received_by_label_json = [r for r in self.nodes[1].listreceivedbylabel(0, True) if r["label"] == "mynewlabel"][0] received_by_label_json = [r for r in self.nodes[1].listreceivedbylabel(0, True) if r["label"] == "mynewlabel"][0]
# Test includeempty of listreceivedbylabel # Test includeempty of listreceivedbylabel

1
test/functional/wallet_listsinceblock.py
View file

@ -11,7 +11,6 @@ class ListSinceBlockTest (BitcoinTestFramework):
def set_test_params(self): def set_test_params(self):
self.num_nodes = 4 self.num_nodes = 4
self.setup_clean_chain = True self.setup_clean_chain = True
self.extra_args = [['-deprecatedrpc=accounts']] * 4
def run_test(self): def run_test(self):
self.nodes[2].generate(101) self.nodes[2].generate(101)

26
test/functional/wallet_listtransactions.py
View file

@ -25,7 +25,6 @@ def tx_from_hex(hexstring):
class ListTransactionsTest(BitcoinTestFramework): class ListTransactionsTest(BitcoinTestFramework):
def set_test_params(self): def set_test_params(self):
self.num_nodes = 2 self.num_nodes = 2
self.extra_args = [['-deprecatedrpc=accounts']] * 2
self.enable_mocktime() self.enable_mocktime()
def run_test(self): def run_test(self):
@ -34,19 +33,19 @@ class ListTransactionsTest(BitcoinTestFramework):
self.sync_all() self.sync_all()
assert_array_result(self.nodes[0].listtransactions(), assert_array_result(self.nodes[0].listtransactions(),
{"txid": txid}, {"txid": txid},
{"category": "send", "account": "", "amount": Decimal("-0.1"), "confirmations": 0}) {"category": "send", "amount": Decimal("-0.1"), "confirmations": 0})
assert_array_result(self.nodes[1].listtransactions(), assert_array_result(self.nodes[1].listtransactions(),
{"txid": txid}, {"txid": txid},
{"category": "receive", "account": "", "amount": Decimal("0.1"), "confirmations": 0}) {"category": "receive", "amount": Decimal("0.1"), "confirmations": 0})
# mine a block, confirmations should change: # mine a block, confirmations should change:
self.nodes[0].generate(1) self.nodes[0].generate(1)
self.sync_all() self.sync_all()
assert_array_result(self.nodes[0].listtransactions(), assert_array_result(self.nodes[0].listtransactions(),
{"txid": txid}, {"txid": txid},
{"category": "send", "account": "", "amount": Decimal("-0.1"), "confirmations": 1}) {"category": "send", "amount": Decimal("-0.1"), "confirmations": 1})
assert_array_result(self.nodes[1].listtransactions(), assert_array_result(self.nodes[1].listtransactions(),
{"txid": txid}, {"txid": txid},
{"category": "receive", "account": "", "amount": Decimal("0.1"), "confirmations": 1}) {"category": "receive", "amount": Decimal("0.1"), "confirmations": 1})
# send-to-self: # send-to-self:
txid = self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), 0.2) txid = self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), 0.2)
@ -60,8 +59,8 @@ class ListTransactionsTest(BitcoinTestFramework):
# sendmany from node1: twice to self, twice to node2: # sendmany from node1: twice to self, twice to node2:
send_to = {self.nodes[0].getnewaddress(): 0.11, send_to = {self.nodes[0].getnewaddress(): 0.11,
self.nodes[1].getnewaddress(): 0.22, self.nodes[1].getnewaddress(): 0.22,
self.nodes[0].getaccountaddress("from1"): 0.33, self.nodes[0].getnewaddress(): 0.33,
self.nodes[1].getaccountaddress("toself"): 0.44} self.nodes[1].getnewaddress(): 0.44}
txid = self.nodes[1].sendmany("", send_to) txid = self.nodes[1].sendmany("", send_to)
self.sync_all() self.sync_all()
assert_array_result(self.nodes[1].listtransactions(), assert_array_result(self.nodes[1].listtransactions(),
@ -81,13 +80,13 @@ class ListTransactionsTest(BitcoinTestFramework):
{"txid": txid}) {"txid": txid})
assert_array_result(self.nodes[0].listtransactions(), assert_array_result(self.nodes[0].listtransactions(),
{"category": "receive", "amount": Decimal("0.33")}, {"category": "receive", "amount": Decimal("0.33")},
{"txid": txid, "account": "from1"}) {"txid": txid})
assert_array_result(self.nodes[1].listtransactions(), assert_array_result(self.nodes[1].listtransactions(),
{"category": "send", "amount": Decimal("-0.44")}, {"category": "send", "amount": Decimal("-0.44")},
{"txid": txid, "account": ""}) {"txid": txid})
assert_array_result(self.nodes[1].listtransactions(), assert_array_result(self.nodes[1].listtransactions(),
{"category": "receive", "amount": Decimal("0.44")}, {"category": "receive", "amount": Decimal("0.44")},
{"txid": txid, "account": "toself"}) {"txid": txid})
pubkey = self.nodes[1].getaddressinfo(self.nodes[1].getnewaddress())['pubkey'] pubkey = self.nodes[1].getaddressinfo(self.nodes[1].getnewaddress())['pubkey']
multisig = self.nodes[1].createmultisig(1, [pubkey]) multisig = self.nodes[1].createmultisig(1, [pubkey])
@ -95,10 +94,9 @@ class ListTransactionsTest(BitcoinTestFramework):
txid = self.nodes[1].sendtoaddress(multisig["address"], 0.1) txid = self.nodes[1].sendtoaddress(multisig["address"], 0.1)
self.nodes[1].generate(1) self.nodes[1].generate(1)
self.sync_all() self.sync_all()
assert(len(self.nodes[0].listtransactions("watchonly", 100, 0, False)) == 0) assert not [tx for tx in self.nodes[0].listtransactions(dummy="*", count=100, skip=0, include_watchonly=False) if "label" in tx and tx["label"] == "watchonly"]
assert_array_result(self.nodes[0].listtransactions("watchonly", 100, 0, True), txs = [tx for tx in self.nodes[0].listtransactions(dummy="*", count=100, skip=0, include_watchonly=True) if "label" in tx and tx['label'] == 'watchonly']
{"category": "receive", "amount": Decimal("0.1")}, assert_array_result(txs, {"category": "receive", "amount": Decimal("0.1")}, {"txid": txid})
{"txid": txid, "account": "watchonly"})
self.run_rbf_opt_in_test() self.run_rbf_opt_in_test()

51
test/functional/wallet_txn_clone.py
View file

@ -15,7 +15,6 @@ from test_framework.util import (
class TxnMallTest(BitcoinTestFramework): class TxnMallTest(BitcoinTestFramework):
def set_test_params(self): def set_test_params(self):
self.num_nodes = 4 self.num_nodes = 4
self.extra_args = [['-deprecatedrpc=accounts']] * 4
def add_options(self, parser): def add_options(self, parser):
parser.add_option("--mineblock", dest="mine_block", default=False, action="store_true", parser.add_option("--mineblock", dest="mine_block", default=False, action="store_true",
@ -39,28 +38,27 @@ class TxnMallTest(BitcoinTestFramework):
starting_balance = 1250 starting_balance = 1250
for i in range(4): for i in range(4):
assert_equal(self.nodes[i].getbalance(), starting_balance) assert_equal(self.nodes[i].getbalance(), starting_balance)
self.nodes[i].getnewaddress("") # bug workaround, coins generated assigned to first getnewaddress! self.nodes[i].getnewaddress() # bug workaround, coins generated assigned to first getnewaddress!
# Assign coins to foo and bar accounts:
self.nodes[0].settxfee(.001) self.nodes[0].settxfee(.001)
node0_address_foo = self.nodes[0].getnewaddress("foo", output_type) node0_address1 = self.nodes[0].getnewaddress(address_type=output_type)
fund_foo_txid = self.nodes[0].sendfrom("", node0_address_foo, 1219) node0_txid1 = self.nodes[0].sendtoaddress(node0_address1, 1219)
fund_foo_tx = self.nodes[0].gettransaction(fund_foo_txid) node0_tx1 = self.nodes[0].gettransaction(node0_txid1)
node0_address_bar = self.nodes[0].getnewaddress("bar", output_type) node0_address2 = self.nodes[0].getnewaddress(address_type=output_type)
fund_bar_txid = self.nodes[0].sendfrom("", node0_address_bar, 29) node0_txid2 = self.nodes[0].sendtoaddress(node0_address2, 29)
fund_bar_tx = self.nodes[0].gettransaction(fund_bar_txid) node0_tx2 = self.nodes[0].gettransaction(node0_txid2)
assert_equal(self.nodes[0].getbalance(""), assert_equal(self.nodes[0].getbalance(),
starting_balance - 1219 - 29 + fund_foo_tx["fee"] + fund_bar_tx["fee"]) starting_balance + node0_tx1["fee"] + node0_tx2["fee"])
# Coins are sent to node1_address # Coins are sent to node1_address
node1_address = self.nodes[1].getnewaddress("from0") node1_address = self.nodes[1].getnewaddress()
# Send tx1, and another transaction tx2 that won't be cloned # Send tx1, and another transaction tx2 that won't be cloned
txid1 = self.nodes[0].sendfrom("foo", node1_address, 40, 0) txid1 = self.nodes[0].sendtoaddress(node1_address, 40)
txid2 = self.nodes[0].sendfrom("bar", node1_address, 20, 0) txid2 = self.nodes[0].sendtoaddress(node1_address, 20)
# Construct a clone of tx1, to be malleated # Construct a clone of tx1, to be malleated
rawtx1 = self.nodes[0].getrawtransaction(txid1, 1) rawtx1 = self.nodes[0].getrawtransaction(txid1, 1)
@ -96,28 +94,22 @@ class TxnMallTest(BitcoinTestFramework):
# Node0's balance should be starting balance, plus 50BTC for another # Node0's balance should be starting balance, plus 50BTC for another
# matured block, minus tx1 and tx2 amounts, and minus transaction fees: # matured block, minus tx1 and tx2 amounts, and minus transaction fees:
expected = starting_balance + fund_foo_tx["fee"] + fund_bar_tx["fee"] expected = starting_balance + node0_tx1["fee"] + node0_tx2["fee"]
if self.options.mine_block: if self.options.mine_block:
expected += 50 expected += 50
expected += tx1["amount"] + tx1["fee"] expected += tx1["amount"] + tx1["fee"]
expected += tx2["amount"] + tx2["fee"] expected += tx2["amount"] + tx2["fee"]
assert_equal(self.nodes[0].getbalance(), expected) assert_equal(self.nodes[0].getbalance(), expected)
# foo and bar accounts should be debited:
assert_equal(self.nodes[0].getbalance("foo", 0), 1219 + tx1["amount"] + tx1["fee"])
assert_equal(self.nodes[0].getbalance("bar", 0), 29 + tx2["amount"] + tx2["fee"])
if self.options.mine_block: if self.options.mine_block:
assert_equal(tx1["confirmations"], 1) assert_equal(tx1["confirmations"], 1)
assert_equal(tx2["confirmations"], 1) assert_equal(tx2["confirmations"], 1)
# Node1's "from0" balance should be both transaction amounts:
assert_equal(self.nodes[1].getbalance("from0"), -(tx1["amount"] + tx2["amount"]))
else: else:
assert_equal(tx1["confirmations"], 0) assert_equal(tx1["confirmations"], 0)
assert_equal(tx2["confirmations"], 0) assert_equal(tx2["confirmations"], 0)
# Send clone and its parent to miner # Send clone and its parent to miner
self.nodes[2].sendrawtransaction(fund_foo_tx["hex"]) self.nodes[2].sendrawtransaction(node0_tx1["hex"])
txid1_clone = self.nodes[2].sendrawtransaction(tx1_clone["hex"]) txid1_clone = self.nodes[2].sendrawtransaction(tx1_clone["hex"])
if self.options.segwit: if self.options.segwit:
assert_equal(txid1, txid1_clone) assert_equal(txid1, txid1_clone)
@ -128,7 +120,7 @@ class TxnMallTest(BitcoinTestFramework):
# Reconnect the split network, and sync chain: # Reconnect the split network, and sync chain:
connect_nodes(self.nodes[1], 2) connect_nodes(self.nodes[1], 2)
self.nodes[2].sendrawtransaction(fund_bar_tx["hex"]) self.nodes[2].sendrawtransaction(node0_tx2["hex"])
self.nodes[2].sendrawtransaction(tx2["hex"]) self.nodes[2].sendrawtransaction(tx2["hex"])
self.nodes[2].generate(1) # Mine another block to make sure we sync self.nodes[2].generate(1) # Mine another block to make sure we sync
sync_blocks(self.nodes) sync_blocks(self.nodes)
@ -149,19 +141,6 @@ class TxnMallTest(BitcoinTestFramework):
if (self.options.mine_block): if (self.options.mine_block):
expected -= 50 expected -= 50
assert_equal(self.nodes[0].getbalance(), expected) assert_equal(self.nodes[0].getbalance(), expected)
assert_equal(self.nodes[0].getbalance("*", 0), expected)
# Check node0's individual account balances.
# "foo" should have been debited by the equivalent clone of tx1
assert_equal(self.nodes[0].getbalance("foo"), 1219 + tx1["amount"] + tx1["fee"])
# "bar" should have been debited by (possibly unconfirmed) tx2
assert_equal(self.nodes[0].getbalance("bar", 0), 29 + tx2["amount"] + tx2["fee"])
# "" should have starting balance, less funding txes, plus subsidies
assert_equal(self.nodes[0].getbalance("", 0),
starting_balance - 1219 + fund_foo_tx["fee"] - 29 + fund_bar_tx["fee"] + 100)
# Node1's "from0" account balance
assert_equal(self.nodes[1].getbalance("from0", 0), -(tx1["amount"] + tx2["amount"]))
if __name__ == '__main__': if __name__ == '__main__':
TxnMallTest().main() TxnMallTest().main()

41
test/functional/wallet_txn_doublespend.py
View file

@ -17,7 +17,6 @@ from test_framework.util import (
class TxnMallTest(BitcoinTestFramework): class TxnMallTest(BitcoinTestFramework):
def set_test_params(self): def set_test_params(self):
self.num_nodes = 4 self.num_nodes = 4
self.extra_args = [['-deprecatedrpc=accounts']] * 4
def add_options(self, parser): def add_options(self, parser):
parser.add_option("--mineblock", dest="mine_block", default=False, action="store_true", parser.add_option("--mineblock", dest="mine_block", default=False, action="store_true",
@ -36,20 +35,20 @@ class TxnMallTest(BitcoinTestFramework):
assert_equal(self.nodes[i].getbalance(), starting_balance) assert_equal(self.nodes[i].getbalance(), starting_balance)
self.nodes[i].getnewaddress("") # bug workaround, coins generated assigned to first getnewaddress! self.nodes[i].getnewaddress("") # bug workaround, coins generated assigned to first getnewaddress!
# Assign coins to foo and bar accounts: # Assign coins to foo and bar addresses:
node0_address_foo = self.nodes[0].getnewaddress("foo") node0_address_foo = self.nodes[0].getnewaddress()
fund_foo_txid = self.nodes[0].sendfrom("", node0_address_foo, 1219) fund_foo_txid = self.nodes[0].sendtoaddress(node0_address_foo, 1219)
fund_foo_tx = self.nodes[0].gettransaction(fund_foo_txid) fund_foo_tx = self.nodes[0].gettransaction(fund_foo_txid)
node0_address_bar = self.nodes[0].getnewaddress("bar") node0_address_bar = self.nodes[0].getnewaddress()
fund_bar_txid = self.nodes[0].sendfrom("", node0_address_bar, 29) fund_bar_txid = self.nodes[0].sendtoaddress(node0_address_bar, 29)
fund_bar_tx = self.nodes[0].gettransaction(fund_bar_txid) fund_bar_tx = self.nodes[0].gettransaction(fund_bar_txid)
assert_equal(self.nodes[0].getbalance(""), assert_equal(self.nodes[0].getbalance(),
starting_balance - 1219 - 29 + fund_foo_tx["fee"] + fund_bar_tx["fee"]) starting_balance + fund_foo_tx["fee"] + fund_bar_tx["fee"])
# Coins are sent to node1_address # Coins are sent to node1_address
node1_address = self.nodes[1].getnewaddress("from0") node1_address = self.nodes[1].getnewaddress()
# First: use raw transaction API to send 1240 BTC to node1_address, # First: use raw transaction API to send 1240 BTC to node1_address,
# but don't broadcast: # but don't broadcast:
@ -70,8 +69,8 @@ class TxnMallTest(BitcoinTestFramework):
assert_equal(doublespend["complete"], True) assert_equal(doublespend["complete"], True)
# Create two spends using 1 50 BTC coin each # Create two spends using 1 50 BTC coin each
txid1 = self.nodes[0].sendfrom("foo", node1_address, 40, 0) txid1 = self.nodes[0].sendtoaddress(node1_address, 40)
txid2 = self.nodes[0].sendfrom("bar", node1_address, 20, 0) txid2 = self.nodes[0].sendtoaddress(node1_address, 20)
# Have node0 mine a block: # Have node0 mine a block:
if (self.options.mine_block): if (self.options.mine_block):
@ -90,15 +89,11 @@ class TxnMallTest(BitcoinTestFramework):
expected += tx2["amount"] + tx2["fee"] expected += tx2["amount"] + tx2["fee"]
assert_equal(self.nodes[0].getbalance(), expected) assert_equal(self.nodes[0].getbalance(), expected)
# foo and bar accounts should be debited:
assert_equal(self.nodes[0].getbalance("foo", 0), 1219 + tx1["amount"] + tx1["fee"])
assert_equal(self.nodes[0].getbalance("bar", 0), 29 + tx2["amount"] + tx2["fee"])
if self.options.mine_block: if self.options.mine_block:
assert_equal(tx1["confirmations"], 1) assert_equal(tx1["confirmations"], 1)
assert_equal(tx2["confirmations"], 1) assert_equal(tx2["confirmations"], 1)
# Node1's "from0" balance should be both transaction amounts: # Node1's balance should be both transaction amounts:
assert_equal(self.nodes[1].getbalance("from0"), -(tx1["amount"] + tx2["amount"])) assert_equal(self.nodes[1].getbalance(), starting_balance - tx1["amount"] - tx2["amount"])
else: else:
assert_equal(tx1["confirmations"], 0) assert_equal(tx1["confirmations"], 0)
assert_equal(tx2["confirmations"], 0) assert_equal(tx2["confirmations"], 0)
@ -129,17 +124,9 @@ class TxnMallTest(BitcoinTestFramework):
# negative): # negative):
expected = starting_balance + 100 - 1240 + fund_foo_tx["fee"] + fund_bar_tx["fee"] + doublespend_fee expected = starting_balance + 100 - 1240 + fund_foo_tx["fee"] + fund_bar_tx["fee"] + doublespend_fee
assert_equal(self.nodes[0].getbalance(), expected) assert_equal(self.nodes[0].getbalance(), expected)
assert_equal(self.nodes[0].getbalance("*"), expected)
# Final "" balance is starting_balance - amount moved to accounts - doublespend + subsidies + # Node1's balance should be its initial balance (1250 for 25 block rewards) plus the doublespend:
# fees (which are negative) assert_equal(self.nodes[1].getbalance(), 1250 + 1240)
assert_equal(self.nodes[0].getbalance("foo"), 1219)
assert_equal(self.nodes[0].getbalance("bar"), 29)
assert_equal(self.nodes[0].getbalance(""),
starting_balance - 1219 - 29 - 1240 + 100 + fund_foo_tx["fee"] + fund_bar_tx["fee"] + doublespend_fee)
# Node1's "from0" account balance should be just the doublespend:
assert_equal(self.nodes[1].getbalance("from0"), 1240)
if __name__ == '__main__': if __name__ == '__main__':
TxnMallTest().main() TxnMallTest().main()