GlcoinCore/elements
1
0
Fork 0
mirror of https://github.com/ElementsProject/elements.git synced 2026-08-13 12:33:42 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Merge 2e82af46e2 into merged_master (Bitcoin PR bitcoin/bitcoin#23207)

Browse source
This commit is contained in:
Byron Hambly 2023-05-12 09:55:10 +00:00
commit f80332fee5
30 changed files with 184 additions and 170 deletions
Download patch file Download diff file Expand all files Collapse all files

3
test/functional/feature_assetsdir.py
View file

@ -29,7 +29,7 @@ class AssetdirTests(BitcoinTestFramework):
self.setup_nodes()
def run_test(self):
self.nodes[0].generate(101)
self.generate(self.nodes[0], 101)
self.nodes[0].syncwithvalidationinterfacequeue()
#Issue two assets that we will later label using the assetdir parameter
@ -68,4 +68,3 @@ class AssetdirTests(BitcoinTestFramework):
if __name__ == '__main__':
AssetdirTests().main()

4
test/functional/feature_block_subsidy.py
View file

@ -40,7 +40,7 @@ class BlockSubsidyTest(BitcoinTestFramework):
# Block will have 10 satoshi output, node 1 will ban
addr = self.nodes[0].getnewaddress()
sub_block = self.nodes[0].generatetoaddress(1, addr)
sub_block = self.generatetoaddress(self.nodes[0], 1, addr)
raw_coinbase = self.nodes[0].getrawtransaction(self.nodes[0].getblock(sub_block[0])["tx"][0], False, sub_block[0])
decoded_coinbase = self.nodes[0].decoderawtransaction(raw_coinbase)
@ -56,7 +56,7 @@ class BlockSubsidyTest(BitcoinTestFramework):
assert found_ten
# Block will have 0 satoshis outputs only at height 1
no_sub_block = self.nodes[1].generatetoaddress(1, addr)
no_sub_block = self.generatetoaddress(self.nodes[1], 1, addr)
raw_coinbase = self.nodes[1].getrawtransaction(self.nodes[1].getblock(no_sub_block[0])["tx"][0], False, no_sub_block[0])
decoded_coinbase = self.nodes[1].decoderawtransaction(raw_coinbase)
for vout in decoded_coinbase["vout"]:

2
test/functional/feature_block_v4.py
View file

@ -55,7 +55,7 @@ class BlockV4Test(BitcoinTestFramework):
self.log.info("Test that a version 4 block with a valid-according-to-CLTV transaction is accepted")
# Generate 100 blocks so that first coinbase matures
generated_blocks = self.nodes[0].generate(100)
generated_blocks = self.generate(self.nodes[0], 100)
spendable_coinbase_txid = self.nodes[0].getblock(generated_blocks[0])['tx'][0]
coinbase_value = self.nodes[0].decoderawtransaction(self.nodes[0].gettransaction(spendable_coinbase_txid)["hex"])["vout"][0]["value"]
tip = generated_blocks[-1]

30
test/functional/feature_confidential_transactions.py
View file

@ -86,7 +86,7 @@ class CTTest (BitcoinTestFramework):
assert_equal(wrong_info["ismine"], False)
# Setting seed should get us more info, still not "ours" until blinding key
rec.generatetoaddress(1, rec.getnewaddress()) # get out of IBD
self.generatetoaddress(self.nodes[0], 1, rec.getnewaddress()) # get out of IBD
rec.sethdseed(True, found_seed)
wrong_blind_info = rec.getaddressinfo(blind_addr)
@ -106,7 +106,7 @@ class CTTest (BitcoinTestFramework):
os.remove(file_path)
def test_null_rangeproof_enforcement(self):
self.nodes[0].generate(1)
self.generate(self.nodes[0], 1)
# 1. Produce a transaction. This is coming out of initialfreecoins so
# no signatures are needed, which slightly simplifies the test
@ -187,9 +187,9 @@ class CTTest (BitcoinTestFramework):
node1 = 0
node2 = 0
self.nodes[0].generate(101)
self.generate(self.nodes[0], 101)
txid = self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), node0, "", "", True)
self.nodes[0].generate(101)
self.generate(self.nodes[0], 101)
self.sync_all()
assert_equal(self.nodes[0].getbalance()["bitcoin"], node0)
assert_equal(self.nodes[1].getbalance("*", 1, False, False, "bitcoin"), node1)
@ -201,7 +201,7 @@ class CTTest (BitcoinTestFramework):
unconfidential_address = self.nodes[2].validateaddress(address)["unconfidential"]
value0 = 3
self.nodes[0].sendtoaddress(unconfidential_address, value0)
self.nodes[0].generate(101)
self.generate(self.nodes[0], 101)
self.sync_all()
node0 = node0 - value0
@ -216,7 +216,7 @@ class CTTest (BitcoinTestFramework):
unconfidential_address2 = self.nodes[2].validateaddress(address2)["unconfidential"]
value1 = 5
confidential_tx_id = self.nodes[0].sendtoaddress(address2, value1)
self.nodes[0].generate(101)
self.generate(self.nodes[0], 101)
self.sync_all()
node0 = node0 - value1
@ -244,7 +244,7 @@ class CTTest (BitcoinTestFramework):
tx = self.nodes[0].blindrawtransaction(tx)
tx_signed = self.nodes[0].signrawtransactionwithwallet(tx)
raw_tx_id = self.nodes[0].sendrawtransaction(tx_signed['hex'])
self.nodes[0].generate(101)
self.generate(self.nodes[0], 101)
self.sync_all()
node0 -= (value2 + value3)
@ -332,7 +332,7 @@ class CTTest (BitcoinTestFramework):
tx_signed = self.nodes[0].signrawtransactionwithwallet(tx)
txid = self.nodes[0].sendrawtransaction(tx_signed['hex'])
decodedtx = self.nodes[0].decoderawtransaction(tx_signed["hex"])
self.nodes[0].generate(101)
self.generate(self.nodes[0], 101)
self.sync_all()
unblindfound = False
@ -426,7 +426,7 @@ class CTTest (BitcoinTestFramework):
assert_equal(issued["asset"], raw_details["vin"][issued["vin"]]["issuance"]["asset"])
assert_equal(issued["token"], raw_details["vin"][issued["vin"]]["issuance"]["token"])
self.nodes[0].generate(1)
self.generate(self.nodes[0], 1)
self.sync_all()
issued2 = self.nodes[0].issueasset(2, 1)
@ -483,7 +483,7 @@ class CTTest (BitcoinTestFramework):
# And finally send
self.nodes[2].sendrawtransaction(signed_assets['hex'])
self.nodes[2].generate(101)
self.generate(self.nodes[0], 101)
self.sync_all()
issuancedata = self.nodes[2].issueasset(0, Decimal('0.00000006')) #0 of asset, 6 reissuance token
@ -493,12 +493,12 @@ class CTTest (BitcoinTestFramework):
# node 1 needs to know about a (re)issuance to reissue itself
self.nodes[1].importaddress(self.nodes[2].gettransaction(issuancedata["txid"])["details"][0]["address"])
# also send some bitcoin
self.nodes[2].generate(1)
self.generate(self.nodes[2], 1)
self.sync_all()
self.nodes[1].reissueasset(issuancedata["asset"], Decimal('0.05'))
self.nodes[2].reissueasset(issuancedata["asset"], Decimal('0.025'))
self.nodes[1].generate(1)
self.generate(self.nodes[1], 1)
self.sync_all()
# Check for value accounting when asset issuance is null but token not, ie unblinded
@ -515,7 +515,7 @@ class CTTest (BitcoinTestFramework):
# Check for value when receiving different assets by same address.
self.nodes[0].sendtoaddress(unconfidential_address2, Decimal('0.00000001'), "", "", False, False, 1, "UNSET", False, test_asset)
self.nodes[0].sendtoaddress(unconfidential_address2, Decimal('0.00000002'), "", "", False, False, 1, "UNSET", False, test_asset)
self.nodes[0].generate(1)
self.generate(self.nodes[0], 1)
self.sync_all()
received_by_address = self.nodes[1].listreceivedbyaddress(0, False, True)
multi_asset_amount = [x for x in received_by_address if x['address'] == unconfidential_address2][0]['amount']
@ -545,7 +545,7 @@ class CTTest (BitcoinTestFramework):
# Issue new asset, to use different assets in one transaction when doing
# partial blinding. Just to make these tests a bit more elaborate :-)
issued3 = self.nodes[2].issueasset(1, 0)
self.nodes[2].generate(1)
self.generate(self.nodes[2], 1)
self.sync_all()
node2_balance = self.nodes[2].getbalance()
assert issued3['asset'] in node2_balance
@ -668,7 +668,7 @@ class CTTest (BitcoinTestFramework):
stx2 = self.nodes[1].signrawtransactionwithwallet(blindtx)
stx = self.nodes[0].signrawtransactionwithwallet(stx2['hex'])
txid = self.nodes[2].sendrawtransaction(stx['hex'])
self.nodes[2].generate(1)
self.generate(self.nodes[2], 1)
assert self.nodes[2].gettransaction(txid)['confirmations'] == 1
self.sync_all()

6
test/functional/feature_default_asset_name.py
View file

@ -34,7 +34,7 @@ class NamedDefaultAssetTest(BitcoinTestFramework):
def run_test(self):
#Claim all anyone-can-spend coins and test that calling sendtoaddress without providing the assetlabel parameter results in the specified default pegged asset being sent.
self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), 21000000, "", "", True)
self.nodes[0].generate(101)
self.generate(self.nodes[0], 101)
self.sync_all()
#Check the default asset is named correctly
@ -43,7 +43,7 @@ class NamedDefaultAssetTest(BitcoinTestFramework):
#Send some of the default asset to the second node
self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 1, "", "", False)
self.nodes[0].generate(101)
self.generate(self.nodes[0], 101)
self.sync_all()
#Check balances are correct and asset is named correctly
@ -56,7 +56,7 @@ class NamedDefaultAssetTest(BitcoinTestFramework):
#Check we send the default 'testasset' when calling 'sendmany' without needing to provide the relevant asset label
outputs = {self.nodes[1].getnewaddress(): 1.0, self.nodes[1].getnewaddress(): 3.0}
self.nodes[0].sendmany("", outputs)
self.nodes[0].generate(101)
self.generate(self.nodes[0], 101)
self.sync_all()
#Check balances are correct and asset is named correctly

54
test/functional/feature_dynafed.py
View file

@ -32,11 +32,6 @@ new_extension = [initial_offline+initial_online]
ERR_MP_INVALID_PEGOUT = "invalid-pegout-proof"
ERR_MP_INVALID_PEGIN = "pegin-no-witness"
def go_to_epoch_end(node):
epoch_info = node.getblockchaininfo()
blocks_to_mine = epoch_info["epoch_length"] - epoch_info["epoch_age"] - 1
node.generatetoaddress(blocks_to_mine, node.getnewaddress())
def validate_no_vote_op_true(node, block, first_dynafed_active_block):
block_info = node.getblock(block)
dynamic_parameters = block_info["dynamic_parameters"]
@ -64,6 +59,11 @@ def validate_no_vote_op_true(node, block, first_dynafed_active_block):
assert not "extension_space" in dynamic_parameters["proposed"]
class DynaFedTest(BitcoinTestFramework):
def go_to_epoch_end(self, node):
epoch_info = node.getblockchaininfo()
blocks_to_mine = epoch_info["epoch_length"] - epoch_info["epoch_age"] - 1
self.generatetoaddress(node, blocks_to_mine, node.getnewaddress())
def set_test_params(self):
self.setup_clean_chain = True
self.num_nodes = 2
@ -122,15 +122,15 @@ class DynaFedTest(BitcoinTestFramework):
# Signaling window is in height, not time, so first block that will signal is
# at height 1008 which is evenly disible by 144(regtest bip9 window size)
# Giving funds to node 1 to avoid a transaction size blowup when sweeping later
blocks = self.nodes[0].generatetoaddress(1006, self.nodes[1].getnewaddress())
blocks = self.generatetoaddress(self.nodes[0], 1006, self.nodes[1].getnewaddress())
assert_equal(self.nodes[0].getblockchaininfo()["softforks"]["dynafed"]["bip9"]["status"], "defined")
blocks += self.nodes[0].generatetoaddress(1, self.nodes[0].getnewaddress())
blocks += self.generatetoaddress(self.nodes[0], 1, self.nodes[0].getnewaddress())
assert_equal(self.nodes[0].getblockchaininfo()["softforks"]["dynafed"]["bip9"]["status"], "started")
blocks += self.nodes[0].generatetoaddress(144, self.nodes[0].getnewaddress())
blocks += self.generatetoaddress(self.nodes[0], 144, self.nodes[0].getnewaddress())
assert_equal(self.nodes[0].getblockchaininfo()["softforks"]["dynafed"]["bip9"]["status"], "locked_in")
# Move chain forward to activation, any new blocks will be enforced
blocks += self.nodes[0].generatetoaddress(144, self.nodes[0].getnewaddress())
blocks += self.generatetoaddress(self.nodes[0], 144, self.nodes[0].getnewaddress())
self.sync_blocks(timeout=240)
assert_equal(self.nodes[0].getblockchaininfo()["softforks"]["dynafed"]["bip9"]["status"], "active")
@ -139,7 +139,7 @@ class DynaFedTest(BitcoinTestFramework):
assert "dynamic_parameters" not in self.nodes[0].getblock(block)
# Next block is first dynamic federation block
block = self.nodes[0].generatetoaddress(1, self.nodes[0].getnewaddress())[0]
block = self.generatetoaddress(self.nodes[0], 1, self.nodes[0].getnewaddress())[0]
self.sync_all()
# We publish full block on BIP9 transition
for i in range(self.num_nodes):
@ -164,10 +164,10 @@ class DynaFedTest(BitcoinTestFramework):
def test_no_vote(self):
self.log.info("Testing no-vote epoch...")
go_to_epoch_end(self.nodes[0])
self.go_to_epoch_end(self.nodes[0])
# Mine epoch_length blocks with no proposals
blocks = self.nodes[0].generatetoaddress(10, self.nodes[0].getnewaddress())
blocks = self.generatetoaddress(self.nodes[0], 10, self.nodes[0].getnewaddress())
self.sync_all()
for i in range(self.num_nodes):
@ -175,7 +175,7 @@ class DynaFedTest(BitcoinTestFramework):
validate_no_vote_op_true(self.nodes[i], block, False)
# Now transition using vanilla getnewblockhex, nothing changed
block = self.nodes[0].generatetoaddress(1, self.nodes[0].getnewaddress())[0]
block = self.generatetoaddress(self.nodes[0], 1, self.nodes[0].getnewaddress())[0]
self.sync_all()
for i in range(self.num_nodes):
@ -183,7 +183,7 @@ class DynaFedTest(BitcoinTestFramework):
def test_under_vote(self):
self.log.info("Testing failed voting epoch...")
go_to_epoch_end(self.nodes[0])
self.go_to_epoch_end(self.nodes[0])
# Mine 7 blocks with agreeing proposals for single-sig, falls short of 4/5 of 10
new_signblock = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress("", "bech32"))["scriptPubKey"]
@ -194,9 +194,9 @@ class DynaFedTest(BitcoinTestFramework):
self.sync_all()
assert_equal(self.nodes[0].getblockcount(), cur_height+7)
# Now mine 3 blank blocks
self.nodes[0].generatetoaddress(3, self.nodes[0].getnewaddress())
self.generatetoaddress(self.nodes[0], 3, self.nodes[0].getnewaddress())
# No transition will take place, generatetoaddress still works for new epoch
block = self.nodes[0].generatetoaddress(1, self.nodes[0].getnewaddress())[0]
block = self.generatetoaddress(self.nodes[0], 1, self.nodes[0].getnewaddress())[0]
self.sync_all()
for i in range(self.num_nodes):
@ -204,7 +204,7 @@ class DynaFedTest(BitcoinTestFramework):
def test_four_fifth_vote(self):
self.log.info("Testing just-successful transition epoch...")
go_to_epoch_end(self.nodes[0])
self.go_to_epoch_end(self.nodes[0])
# Mine 8 blocks with agreeing proposals for single-sig, triggering transition
new_signblock = self.nodes[0].getaddressinfo(self.nodes[0].getnewaddress("", "bech32"))["scriptPubKey"]
@ -226,7 +226,7 @@ class DynaFedTest(BitcoinTestFramework):
assert_equal(self.nodes[0].getblockcount(), cur_height+8)
# Now mine 1 blank block
self.nodes[0].generatetoaddress(1, self.nodes[0].getnewaddress())
self.generatetoaddress(self.nodes[0], 1, self.nodes[0].getnewaddress())
self.sync_all()
# Old parameters still enforced for next block...
@ -239,7 +239,7 @@ class DynaFedTest(BitcoinTestFramework):
assert_equal(fedpeg_info["current_fedpegscripts"], ["51", "51"])
# Last blank block
self.nodes[0].generatetoaddress(1, self.nodes[0].getnewaddress())
self.generatetoaddress(self.nodes[0], 1, self.nodes[0].getnewaddress())
self.sync_all()
# We have now transitioned, next block must have signature
@ -338,7 +338,7 @@ class DynaFedTest(BitcoinTestFramework):
peg_tx = self.nodes[0].gettransaction(peg_id)["hex"]
self.nodes[0].testmempoolaccept([peg_tx])
# only one confirm needed in this setup, we do 10 to sync with epoch_length
self.nodes[0].generatetoaddress(10, self.nodes[0].getnewaddress())
self.generatetoaddress(self.nodes[0], 10, self.nodes[0].getnewaddress())
proof = self.nodes[0].gettxoutproof([peg_id])
raw_tx = self.nodes[0].gettransaction(peg_id)["hex"]
@ -363,7 +363,7 @@ class DynaFedTest(BitcoinTestFramework):
assert_equal(self.nodes[1].getrawmempool(), [])
# Now generate an epoch of blocks on node 1 to show that non-transitions don't dump
# PAK or peg-in transactions from mempool
self.nodes[1].generatetoaddress(10, self.nodes[1].getnewaddress())
self.generatetoaddress(self.nodes[1], 10, self.nodes[1].getnewaddress())
self.sync_blocks()
assert_equal(self.nodes[0].getblockchaininfo()["epoch_age"], 9)
@ -457,7 +457,7 @@ class DynaFedTest(BitcoinTestFramework):
def test_valid_epochs(self):
self.log.info("Testing pegins and pegouts stay valid for some epochs")
# previous test leaves us at age 9
self.nodes[0].generatetoaddress(1, self.nodes[0].getnewaddress())
self.generatetoaddress(self.nodes[0], 1, self.nodes[0].getnewaddress())
self.sync_all()
assert_equal(self.nodes[1].getblockchaininfo()["epoch_age"], 0)
@ -494,7 +494,7 @@ class DynaFedTest(BitcoinTestFramework):
peg_tx = self.nodes[0].gettransaction(peg_id)["hex"]
# we need the confirmation of the peg tx, so we can't easily assert
# that the pegin tx would be accepted at this very point
self.nodes[0].generatetoaddress(1, self.nodes[0].getnewaddress())
self.generatetoaddress(self.nodes[0], 1, self.nodes[0].getnewaddress())
proof = self.nodes[0].gettxoutproof([peg_id])
pegin_tx = self.nodes[0].createrawpegin(peg_tx, proof, fund_info["claim_script"])["hex"]
pegin_tx = self.nodes[0].signrawtransactionwithwallet(pegin_tx)["hex"]
@ -505,7 +505,7 @@ class DynaFedTest(BitcoinTestFramework):
# let's generate 20 blocks to pass through 2 new epochs without there being a transition
for _ in range(20):
self.nodes[0].generatetoaddress(1, self.nodes[0].getnewaddress())
self.generatetoaddress(self.nodes[0], 1, self.nodes[0].getnewaddress())
self.assert_accepted(pegin_tx)
self.assert_accepted(pegout_tx)
assert_equal(self.nodes[0].getsidechaininfo()["current_fedpegscripts"], ["51", "51"])
@ -546,7 +546,7 @@ class DynaFedTest(BitcoinTestFramework):
for _ in range(9):
self.assert_accepted(pegin_tx)
assert_equal(self.nodes[0].testmempoolaccept([pegout_tx])[0]["reject-reason"], ERR_MP_INVALID_PEGOUT)
self.nodes[1].generatetoaddress(1, self.nodes[1].getnewaddress())
self.generatetoaddress(self.nodes[1], 1, self.nodes[1].getnewaddress())
self.sync_blocks()
# so on the last block both should not be allowed
@ -558,12 +558,12 @@ class DynaFedTest(BitcoinTestFramework):
self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
# first use the pegin tx created earlier
pegin_txid = self.nodes[0].sendrawtransaction(pegin_tx)
self.nodes[0].generatetoaddress(1, self.nodes[0].getnewaddress())
self.generatetoaddress(self.nodes[0], 1, self.nodes[0].getnewaddress())
assert_equal(self.nodes[0].gettransaction(pegin_txid)["confirmations"], 1)
# make sure that using claimpegin directly also works
self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
pegin_txid = self.nodes[0].claimpegin(peg_tx, proof, fund_info["claim_script"])
self.nodes[0].generatetoaddress(1, self.nodes[0].getnewaddress())
self.generatetoaddress(self.nodes[0], 1, self.nodes[0].getnewaddress())
assert_equal(self.nodes[0].gettransaction(pegin_txid)["confirmations"], 1)
def run_test(self):

16
test/functional/feature_elements_taproot_activation.py
View file

@ -35,7 +35,7 @@ class TaprootActivationTest(BitcoinTestFramework):
assert_equal(rpc.getblockcount(), 0)
blocks = rpc.generatetoaddress(activation_height - 2, rpc.getnewaddress())
blocks = self.generatetoaddress(rpc, activation_height - 2, rpc.getnewaddress())
assert_equal(rpc.getblockcount(), activation_height - 2)
for n, block in enumerate(blocks):
@ -51,11 +51,11 @@ class TaprootActivationTest(BitcoinTestFramework):
assert_equal(rpc.getblockchaininfo()["softforks"]["taproot"]["bip9"]["status"], "defined")
# The 1023rd block does not signal, but changes the signalling state
# to "started" from "defined"
blocks = rpc.generatetoaddress(1, rpc.getnewaddress())
blocks = self.generatetoaddress(rpc, 1, rpc.getnewaddress())
assert_equal(rpc.getblockchaininfo()["softforks"]["taproot"]["bip9"]["status"], "started")
assert_equal(rpc.getblockheader(blocks[0])["versionHex"], "20000000")
blocks = rpc.generatetoaddress(127, rpc.getnewaddress())
blocks = self.generatetoaddress(rpc, 127, rpc.getnewaddress())
for n, block in enumerate(blocks):
decode = rpc.getblockheader(block)
assert_equal (decode["versionHex"], "20000004")
@ -71,18 +71,18 @@ class TaprootActivationTest(BitcoinTestFramework):
assert_equal(rpc.getblockchaininfo()["softforks"]["taproot"]["bip9"]["status"], "started")
# Run through another 128 blocks, without failing to signal
blocks = rpc.generatetoaddress(127, rpc.getnewaddress())
blocks = self.generatetoaddress(rpc, 127, rpc.getnewaddress())
for n, block in enumerate(blocks):
decode = rpc.getblockheader(block)
assert_equal (decode["versionHex"], "20000004")
assert_equal(rpc.getblockchaininfo()["softforks"]["taproot"]["bip9"]["status"], "started")
# The 128th block then switches from "started" to "locked_in"
blocks = rpc.generatetoaddress(1, rpc.getnewaddress())
blocks = self.generatetoaddress(rpc, 1, rpc.getnewaddress())
assert_equal(rpc.getblockchaininfo()["softforks"]["taproot"]["bip9"]["status"], "locked_in")
assert_equal(rpc.getblockheader(blocks[0])["versionHex"], "20000004")
# Run through another 128 blocks, which will go from "locked in" to "active" regardless of signalling
blocks = rpc.generatetoaddress(127, rpc.getnewaddress())
blocks = self.generatetoaddress(rpc, 127, rpc.getnewaddress())
for n, block in enumerate(blocks):
decode = rpc.getblockheader(block)
assert_equal (decode["versionHex"], "20000004")
@ -93,14 +93,14 @@ class TaprootActivationTest(BitcoinTestFramework):
assert_equal(rpc.getblockchaininfo()["softforks"]["taproot"]["bip9"]["status"], "active")
# After the state is "active", signallng stops by default.
blocks = rpc.generatetoaddress(1, self.nodes[0].getnewaddress())
blocks = self.generatetoaddress(rpc, 1, self.nodes[0].getnewaddress())
assert_equal(rpc.getblockchaininfo()["softforks"]["taproot"]["bip9"]["status"], "active")
assert_equal(rpc.getblockheader(blocks[0])["versionHex"], "20000000")
def run_test(self):
# Test that regtest nodes never signal taproot by default
self.log.info("Testing node not configured to activate taproot")
blocks = self.nodes[0].generatetoaddress(2500, self.nodes[0].getnewaddress())
blocks = self.generatetoaddress(self.nodes[0], 2500, self.nodes[0].getnewaddress())
assert_equal(self.nodes[0].getblockcount(), 2500)
for n, block in enumerate(blocks):
decode = self.nodes[0].getblockheader(block)

50
test/functional/feature_fedpeg.py
View file

@ -180,7 +180,7 @@ class FedPegTest(BitcoinTestFramework):
pegout_tested = True
break
assert pegout_tested
sidechain.generatetoaddress(1, sidechain.getnewaddress())
self.generatetoaddress(self.nodes[2], 1, sidechain.getnewaddress())
assert_equal(sidechain.gettransaction(pegout_txid)["confirmations"], 1)
def run_test(self):
@ -210,8 +210,8 @@ class FedPegTest(BitcoinTestFramework):
node.importprivkey(privkey=node.get_deterministic_priv_key().key, label="mining")
util.node_fastmerkle = sidechain
parent.generate(101)
sidechain.generate(101)
self.generate(parent, 101)
self.generate(sidechain, 101)
self.log.info("sidechain info: {}".format(sidechain.getsidechaininfo()))
addrs = sidechain.getpeginaddress()
@ -221,7 +221,7 @@ class FedPegTest(BitcoinTestFramework):
vout = find_vout_for_address(parent, txid1, addr)
# 10+2 confirms required to get into mempool and confirm
assert_equal(sidechain.getsidechaininfo()["pegin_confirmation_depth"], 10)
parent.generate(1)
self.generate(parent, 1)
time.sleep(2)
proof = parent.gettxoutproof([txid1])
@ -244,7 +244,7 @@ class FedPegTest(BitcoinTestFramework):
assert "Peg-in Bitcoin transaction needs more confirmations to be sent." in e.error["message"]
# Second attempt simply doesn't hit mempool bar
parent.generate(10)
self.generate(parent, 10)
try:
pegtxid = sidechain.claimpegin(raw, proof)
raise Exception("Peg-in should not be mature enough yet, need another block.")
@ -266,7 +266,7 @@ class FedPegTest(BitcoinTestFramework):
assert "Given claim_script does not match the given Bitcoin transaction." in e.error["message"]
# 12 confirms allows in mempool
parent.generate(1)
self.generate(parent, 1)
# Make sure that a tx with a duplicate pegin claim input gets rejected.
raw_pegin = sidechain.createrawpegin(raw, proof)["hex"]
@ -363,10 +363,10 @@ class FedPegTest(BitcoinTestFramework):
# Will invalidate the block that confirms this transaction later
for node_group in self.node_groups:
self.sync_all(node_group)
blockhash = sidechain2.generate(1)
blockhash = self.generate(sidechain2, 1)
for node_group in self.node_groups:
self.sync_all(node_group)
sidechain.generate(5)
self.generate(sidechain, 5)
tx1 = sidechain.gettransaction(pegtxid1)
@ -410,7 +410,7 @@ class FedPegTest(BitcoinTestFramework):
assert_raises_rpc_error(-25, "bad-txns-double-pegin", sidechain.testproposedblock, block_hex, True)
# Re-enters block
sidechain.generate(1)
self.generate(sidechain, 1)
if sidechain.gettransaction(pegtxid1)["confirmations"] != 1:
raise Exception("Peg-in should have one confirm on side block.")
sidechain.reconsiderblock(blockhash[0])
@ -435,25 +435,25 @@ class FedPegTest(BitcoinTestFramework):
print("Flooding mempool with a few claims")
pegtxs = []
sidechain.generate(101)
self.generate(sidechain, 101)
# Do mixture of raw peg-in and automatic peg-in tx construction
# where raw creation is done on another node
for i in range(n_claims):
addrs = sidechain.getpeginaddress()
txid = parent.sendtoaddress(addrs["mainchain_address"], 1)
parent.generate(1)
self.generate(parent, 1)
proof = parent.gettxoutproof([txid])
raw = parent.gettransaction(txid)["hex"]
if i % 2 == 0:
parent.generate(11)
self.generate(parent, 11)
pegtxs += [sidechain.claimpegin(raw, proof)]
else:
# The raw API doesn't check for the additional 2 confirmation buffer
# So we only get 10 confirms then send off. Miners will add to block anyways.
# Don't mature whole way yet to test signing immature peg-in input
parent.generate(8)
self.generate(parent, 8)
# Wallet in sidechain2 gets funds instead of sidechain
raw_pegin = sidechain2.createrawpegin(raw, proof, addrs["claim_script"])["hex"]
# First node should also be able to make a valid transaction with or without 3rd arg
@ -464,12 +464,12 @@ class FedPegTest(BitcoinTestFramework):
assert signed_pegin["complete"]
assert "warning" in signed_pegin # warning for immature peg-in
# fully mature them now
parent.generate(1)
self.generate(parent, 1)
pegtxs += [sidechain.sendrawtransaction(signed_pegin["hex"])]
for node_group in self.node_groups:
self.sync_all(node_group)
sidechain2.generate(1)
self.generate(sidechain2, 1)
for i, pegtxid in enumerate(pegtxs):
if i % 2 == 0:
tx = sidechain.gettransaction(pegtxid)
@ -499,7 +499,7 @@ class FedPegTest(BitcoinTestFramework):
print("Test pegout Garbage valid")
prev_txid = sidechain.sendtoaddress(sidechain.getnewaddress(), 1)
sidechain.generate(1)
self.generate(sidechain, 1)
pegout_chain = 'a' * 64
pegout_hex = 'b' * 500
inputs = [{"txid": prev_txid, "vout": 0}]
@ -524,11 +524,11 @@ class FedPegTest(BitcoinTestFramework):
print("Now test failure to validate peg-ins based on intermittent bitcoind rpc failure")
self.stop_node(1)
txid = parent.sendtoaddress(addr, 1)
parent.generate(12)
self.generate(parent, 12)
proof = parent.gettxoutproof([txid])
raw = parent.gettransaction(txid)["hex"]
sidechain.claimpegin(raw, proof) # stuck peg
sidechain.generate(1)
self.generate(sidechain, 1)
print("Waiting to ensure block is being rejected by sidechain2")
time.sleep(5)
@ -542,7 +542,7 @@ class FedPegTest(BitcoinTestFramework):
# https://github.com/ElementsProject/elements/issues/891 (sporadic
# failures when catching up after loss of parent daemon connectivity.)
print("Generating some blocks, to stress-test handling of parent daemon reconnection")
sidechain.generate(10)
self.generate(sidechain, 10)
print("Now waiting for node to re-evaluate peg-in witness failed block... should take a few seconds")
for node_group in self.node_groups:
@ -615,7 +615,7 @@ class FedPegTest(BitcoinTestFramework):
mainchain_addr = pegin_info["mainchain_address"]
# Watch the address so we can get tx without txindex
parent.importaddress(mainchain_addr)
claim_block = parent.generatetoaddress(50, mainchain_addr)[0]
claim_block = self.generatetoaddress(parent, 50, mainchain_addr)[0]
for node_group in self.node_groups:
self.sync_all(node_group)
block_coinbase = parent.getblock(claim_block, 2)["tx"][0]
@ -632,14 +632,14 @@ class FedPegTest(BitcoinTestFramework):
assert_raises_rpc_error(-26, "bad-pegin-witness, Needs more confirmations.", sidechain.sendrawtransaction, signed_pegin)
# 50 more blocks to allow wallet to make it succeed by relay and consensus
parent.generatetoaddress(50, parent.getnewaddress())
self.generatetoaddress(parent, 50, parent.getnewaddress())
for node_group in self.node_groups:
self.sync_all(node_group)
# Wallet still doesn't want to for 2 more confirms
assert_equal(sidechain.createrawpegin(claim_tx, claim_proof)["mature"], False)
# But we can just shoot it off
claim_txid = sidechain.sendrawtransaction(signed_pegin)
sidechain.generatetoaddress(1, sidechain.getnewaddress())
self.generatetoaddress(sidechain, 1, sidechain.getnewaddress())
for node_group in self.node_groups:
self.sync_all(node_group)
assert_equal(sidechain.gettransaction(claim_txid)["confirmations"], 1)
@ -652,7 +652,7 @@ class FedPegTest(BitcoinTestFramework):
pegin_addr = addrs["mainchain_address"]
txid_fund = parent.sendtoaddress(pegin_addr, 10)
# 10+2 confirms required to get into mempool and confirm
parent.generate(11)
self.generate(parent, 11)
for node_group in self.node_groups:
self.sync_all(node_group)
proof = parent.gettxoutproof([txid_fund])
@ -666,7 +666,7 @@ class FedPegTest(BitcoinTestFramework):
pegin_addr = addrs["mainchain_address"]
txid_fund = parent.sendtoaddress(pegin_addr, 10)
# 10+2 confirms required to get into mempool and confirm
parent.generate(11)
self.generate(parent, 11)
for node_group in self.node_groups:
self.sync_all(node_group)
proof = parent.gettxoutproof([txid_fund])
@ -678,7 +678,7 @@ class FedPegTest(BitcoinTestFramework):
# now add an extra input and output from listunspent; we need a blinded output for this
blind_addr = sidechain.getnewaddress("", "blech32")
sidechain.sendtoaddress(blind_addr, 15)
sidechain.generate(6)
self.generate(sidechain, 6)
# Make sure sidechain2 knows about the same input
for node_group in self.node_groups:
self.sync_all(node_group)

10
test/functional/feature_initial_reissuance_token.py
View file

@ -32,7 +32,7 @@ class InitialReissuanceTokenTest(BitcoinTestFramework):
self.sync_all()
def run_test(self):
self.nodes[0].generate(101)
self.generate(self.nodes[0], 101)
self.sync_all()
walletinfo = self.nodes[0].getwalletinfo()
@ -48,7 +48,7 @@ class InitialReissuanceTokenTest(BitcoinTestFramework):
# Claim all anyone-can-spend reissuance tokens, which also blinds the token output
# which is required for re-issuance: https://github.com/ElementsProject/elements/issues/259
self.nodes[0].sendtoaddress(self.nodes[0].getnewaddress(), 2, "", "", False, False, 6, "UNSET", False, token)
self.nodes[0].generate(101)
self.generate(self.nodes[0], 101)
self.sync_all()
#Check balances
@ -58,7 +58,7 @@ class InitialReissuanceTokenTest(BitcoinTestFramework):
#Reissue some of the default asset
self.nodes[0].reissueasset("bitcoin", 1234)
self.nodes[0].generate(101)
self.generate(self.nodes[0], 101)
self.sync_all()
#Check the reissuance worked
@ -70,12 +70,12 @@ class InitialReissuanceTokenTest(BitcoinTestFramework):
#Send a reissuance token to node 2 so they can reissue the default asset
self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 1, "", "", False, False, 6, "UNSET", False, token)
self.nodes[0].generate(101)
self.generate(self.nodes[0], 101)
self.sync_all()
#Reissue some of the default asset
self.nodes[1].reissueasset("bitcoin", 1000)
self.nodes[1].generate(101)
self.generate(self.nodes[1], 101)
self.sync_all()
#Check balance is the 1 'bitcoin' sent from node 1 plus the 1000 'bitcoin' reissued by node 2

67
test/functional/feature_issuance.py
View file

@ -11,7 +11,7 @@ from decimal import Decimal
" Tests issued assets functionality including (re)issuance, and de-issuance "
# Creates a raw issuance transaction based on the passed in list, checking important details after
def process_raw_issuance(node, issuance_list):
def process_raw_issuance(test, node, issuance_list):
if len(issuance_list) > 5:
raise Exception('Issuance list too long')
# Make enough outputs for any subsequent spend
@ -30,7 +30,7 @@ def process_raw_issuance(node, issuance_list):
blind_tx = node.blindrawtransaction(issued_tx, False, [], issuance_list[0]["blind"])
signed_tx = node.signrawtransactionwithwallet(blind_tx)
tx_id = node.sendrawtransaction(signed_tx['hex'])
node.generate(1)
test.generate(node, 1)
assert_equal(node.gettransaction(tx_id)["confirmations"], 1)
num_issuance = 0
decoded_tx = node.decoderawtransaction(signed_tx['hex'])
@ -104,8 +104,11 @@ class IssuanceTest(BitcoinTestFramework):
self.connect_nodes(1, 2)
self.sync_all()
def raw_issuance(self, node, issuance_list):
process_raw_issuance(self, node, issuance_list)
def run_test(self):
self.nodes[0].generate(105)
self.generate(self.nodes[0], 105)
# Make sure test starts with no initial issuance.
assert_equal(len(self.nodes[0].listissuances()), 0)
@ -118,7 +121,7 @@ class IssuanceTest(BitcoinTestFramework):
# Quick unblinded reissuance check, making 2*COIN total
self.nodes[0].reissueasset(issued["asset"], 1)
self.nodes[0].generate(1)
self.generate(self.nodes[0], 1)
self.sync_all()
contract_hash = "deadbeee"*8
@ -132,17 +135,17 @@ class IssuanceTest(BitcoinTestFramework):
# Send bitcoin to node 1 and then from 1 to 2 to force node 1 to
# spend confidential money.
self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 4)
self.nodes[0].generate(1)
self.generate(self.nodes[0], 1)
self.sync_all()
self.nodes[1].sendtoaddress(self.nodes[2].getnewaddress(), 3, "", "", False, False, 1, "UNSET", False, "", False)
self.sync_all()
self.nodes[0].generate(1)
self.generate(self.nodes[0], 1)
self.sync_all()
# Destroy assets
pre_destroy_btc_balance = self.nodes[2].getwalletinfo()['balance']['bitcoin']
self.nodes[2].destroyamount('bitcoin', 2) # Destroy 2 BTC
self.nodes[2].generate(1)
self.generate(self.nodes[2], 1)
self.sync_all()
assert_greater_than_or_equal(pre_destroy_btc_balance - Decimal('2'), self.nodes[2].getbalance()['bitcoin'])
@ -150,14 +153,14 @@ class IssuanceTest(BitcoinTestFramework):
assert_equal(issuedamount, Decimal('1.0'))
self.nodes[0].destroyamount(issued["token"], issuedamount) # Destroy all reissuance tokens of one type
self.nodes[0].generate(1)
self.generate(self.nodes[0], 1)
self.sync_all()
assert issued["token"] not in self.nodes[0].getwalletinfo()['balance']
# Test various issuance and auditing paths
issuancedata = self.nodes[0].issueasset(Decimal('0.00000002'), Decimal('0.00000001')) #2 of asset, 1 reissuance token
self.nodes[1].generate(1)
self.generate(self.nodes[1], 1)
self.sync_all()
assert_equal(self.nodes[0].getwalletinfo()["balance"][issuancedata["asset"]], Decimal('0.00000002'))
assert_equal(self.nodes[0].getwalletinfo()["balance"][issuancedata["token"]], Decimal('0.00000001'))
@ -187,7 +190,7 @@ class IssuanceTest(BitcoinTestFramework):
# node 1 needs to know about a (re)issuance to reissue itself
self.nodes[1].importaddress(self.nodes[2].gettransaction(issuancedata["txid"])["details"][0]["address"])
# also send some bitcoin
self.nodes[2].generate(1)
self.generate(self.nodes[2], 1)
self.sync_all()
assert_equal(self.nodes[2].getwalletinfo()["balance"][issuancedata["token"]], Decimal('0.00000005'))
@ -197,7 +200,7 @@ class IssuanceTest(BitcoinTestFramework):
self.sync_all()
# Watch-only issuances won't show up in wallet until confirmed
self.nodes[1].generate(1)
self.generate(self.nodes[1], 1)
self.sync_all()
# Now have node 0 audit these issuances
@ -263,7 +266,7 @@ class IssuanceTest(BitcoinTestFramework):
# See: https://github.com/ElementsProject/elements/issues/473
total_amount = self.nodes[0].getbalance()['bitcoin']
self.nodes[0].sendtoaddress(nonblind_addr, total_amount, "", "", True)
self.nodes[1].generate(1)
self.generate(self.nodes[1], 1)
raw_tx = self.nodes[0].createrawtransaction([], [{nonblind_addr: 1}])
funded_tx = self.nodes[0].fundrawtransaction(raw_tx)['hex']
issued_tx = self.nodes[2].rawissueasset(funded_tx, [{"asset_amount":1, "asset_address":nonblind_addr, "blind":False}])[0]["hex"]
@ -274,24 +277,24 @@ class IssuanceTest(BitcoinTestFramework):
# Make single blinded output to ensure we work around above issue
total_amount = self.nodes[0].getbalance()['bitcoin']
self.nodes[0].sendtoaddress(blind_addr, total_amount, "", "", True)
self.nodes[1].generate(1)
self.generate(self.nodes[1], 1)
# Start with single issuance input, unblinded (makes 5 outputs for later larger issuances)
process_raw_issuance(self.nodes[0], [{"asset_amount": 2, "asset_address": nonblind_addr, "blind": False}])
process_raw_issuance(self.nodes[0], [{"asset_amount": 2, "asset_address": nonblind_addr, "blind": True}])
process_raw_issuance(self.nodes[0], [{"token_amount": 5, "token_address": nonblind_addr, "blind": False}])
process_raw_issuance(self.nodes[0], [{"asset_amount": 7, "asset_address": nonblind_addr, "token_amount":2, "token_address":nonblind_addr, "blind":False}])
process_raw_issuance(self.nodes[0], [{"asset_amount": 7, "asset_address": nonblind_addr, "token_amount":2, "token_address":blind_addr, "blind":False}])
process_raw_issuance(self.nodes[0], [{"asset_amount": 7, "asset_address": blind_addr, "token_amount":2, "token_address":nonblind_addr, "blind":False}])
process_raw_issuance(self.nodes[0], [{"asset_amount": 7, "asset_address": blind_addr, "token_amount":2, "token_address":blind_addr, "blind":False}])
self.raw_issuance(self.nodes[0], [{"asset_amount": 2, "asset_address": nonblind_addr, "blind": False}])
self.raw_issuance(self.nodes[0], [{"asset_amount": 2, "asset_address": nonblind_addr, "blind": True}])
self.raw_issuance(self.nodes[0], [{"token_amount": 5, "token_address": nonblind_addr, "blind": False}])
self.raw_issuance(self.nodes[0], [{"asset_amount": 7, "asset_address": nonblind_addr, "token_amount":2, "token_address":nonblind_addr, "blind":False}])
self.raw_issuance(self.nodes[0], [{"asset_amount": 7, "asset_address": nonblind_addr, "token_amount":2, "token_address":blind_addr, "blind":False}])
self.raw_issuance(self.nodes[0], [{"asset_amount": 7, "asset_address": blind_addr, "token_amount":2, "token_address":nonblind_addr, "blind":False}])
self.raw_issuance(self.nodes[0], [{"asset_amount": 7, "asset_address": blind_addr, "token_amount":2, "token_address":blind_addr, "blind":False}])
# Now do multiple with some issuance outputs blind, some unblinded
process_raw_issuance(self.nodes[0], [{"asset_amount": 7, "asset_address": nonblind_addr, "token_amount":2, "token_address":nonblind_addr, "blind":False}, {"asset_amount":2, "asset_address":nonblind_addr, "blind":False}])
process_raw_issuance(self.nodes[0], [{"asset_amount": 7, "asset_address": blind_addr, "token_amount":2, "token_address":nonblind_addr, "blind":False}, {"asset_amount":2, "asset_address":nonblind_addr, "blind":False}])
self.raw_issuance(self.nodes[0], [{"asset_amount": 7, "asset_address": nonblind_addr, "token_amount":2, "token_address":nonblind_addr, "blind":False}, {"asset_amount":2, "asset_address":nonblind_addr, "blind":False}])
self.raw_issuance(self.nodes[0], [{"asset_amount": 7, "asset_address": blind_addr, "token_amount":2, "token_address":nonblind_addr, "blind":False}, {"asset_amount":2, "asset_address":nonblind_addr, "blind":False}])
# Up to 5 issuances since we're making 5 outputs each time
process_raw_issuance(self.nodes[0], [{"asset_amount": 7, "asset_address": nonblind_addr, "token_amount":2, "token_address":blind_addr, "blind":False}, {"asset_amount":2, "asset_address":nonblind_addr, "blind":False}])
process_raw_issuance(self.nodes[0], [{"asset_amount": 1, "asset_address": nonblind_addr, "token_amount":2, "token_address":blind_addr, "blind":False}, {"asset_amount":3, "asset_address":nonblind_addr, "blind":False}, {"asset_amount":4, "asset_address":nonblind_addr, "token_amount":5, "token_address":blind_addr, "blind":False}, {"asset_amount":6, "asset_address":nonblind_addr, "token_amount":7, "token_address":blind_addr, "blind":False}, {"asset_amount":8, "asset_address":nonblind_addr, "token_amount":9, "token_address":blind_addr, "blind":False}])
self.raw_issuance(self.nodes[0], [{"asset_amount": 7, "asset_address": nonblind_addr, "token_amount":2, "token_address":blind_addr, "blind":False}, {"asset_amount":2, "asset_address":nonblind_addr, "blind":False}])
self.raw_issuance(self.nodes[0], [{"asset_amount": 1, "asset_address": nonblind_addr, "token_amount":2, "token_address":blind_addr, "blind":False}, {"asset_amount":3, "asset_address":nonblind_addr, "blind":False}, {"asset_amount":4, "asset_address":nonblind_addr, "token_amount":5, "token_address":blind_addr, "blind":False}, {"asset_amount":6, "asset_address":nonblind_addr, "token_amount":7, "token_address":blind_addr, "blind":False}, {"asset_amount":8, "asset_address":nonblind_addr, "token_amount":9, "token_address":blind_addr, "blind":False}])
# Default "blind" value is true, omitting explicit argument for last
process_raw_issuance(self.nodes[0], [{"asset_amount": 1, "asset_address": nonblind_addr, "token_amount":2, "token_address":blind_addr, "blind":True}, {"asset_amount":3, "asset_address":nonblind_addr, "blind":True}, {"asset_amount":4, "asset_address":nonblind_addr, "token_amount":5, "token_address":blind_addr, "blind":True}, {"asset_amount":6, "asset_address":nonblind_addr, "token_amount":7, "token_address":blind_addr, "blind":True}, {"asset_amount":8, "asset_address":nonblind_addr, "token_amount":9, "token_address":blind_addr}])
self.raw_issuance(self.nodes[0], [{"asset_amount": 1, "asset_address": nonblind_addr, "token_amount":2, "token_address":blind_addr, "blind":True}, {"asset_amount":3, "asset_address":nonblind_addr, "blind":True}, {"asset_amount":4, "asset_address":nonblind_addr, "token_amount":5, "token_address":blind_addr, "blind":True}, {"asset_amount":6, "asset_address":nonblind_addr, "token_amount":7, "token_address":blind_addr, "blind":True}, {"asset_amount":8, "asset_address":nonblind_addr, "token_amount":9, "token_address":blind_addr}])
# Make sure that fee is checked
@ -372,7 +375,7 @@ class IssuanceTest(BitcoinTestFramework):
print("Raw reissuance tests")
issued_asset = self.nodes[0].issueasset(0, 1)
self.nodes[0].generate(1)
self.generate(self.nodes[0], 1)
utxo_info = None
# Find info about the token output using wallet
for utxo in self.nodes[0].listunspent():
@ -396,7 +399,7 @@ class IssuanceTest(BitcoinTestFramework):
blind_tx = self.nodes[0].blindrawtransaction(reissued_tx["hex"])
signed_tx = self.nodes[0].signrawtransactionwithwallet(blind_tx)
tx_id = self.nodes[0].sendrawtransaction(signed_tx["hex"])
self.nodes[0].generate(1)
self.generate(self.nodes[0], 1)
assert_equal(self.nodes[0].gettransaction(tx_id)["confirmations"], 1)
# Now send reissuance token to blinded multisig, then reissue
@ -414,7 +417,7 @@ class IssuanceTest(BitcoinTestFramework):
self.nodes[0].importblindingkey(blinded_multisig, blinding_privkey)
# Sending to this address must achieve blinding to reissue from this address
self.nodes[0].sendtoaddress(blinded_multisig, self.nodes[0].getbalance()[issued_asset["token"]], "", "", False, False, 1, "UNSET", False, issued_asset["token"], False)
self.nodes[0].generate(1)
self.generate(self.nodes[0], 1)
# Get that multisig output
utxo_info = None
@ -442,7 +445,7 @@ class IssuanceTest(BitcoinTestFramework):
blind_tx = self.nodes[0].blindrawtransaction(reissued_tx["hex"])
signed_tx = self.nodes[0].signrawtransactionwithwallet(blind_tx)
tx_id = self.nodes[0].sendrawtransaction(signed_tx["hex"])
self.nodes[0].generate(1)
self.generate(self.nodes[0], 1)
assert_equal(self.nodes[0].gettransaction(tx_id)["confirmations"], 1)
# Now make transaction spending a token that had non-null contract_hash
@ -453,7 +456,7 @@ class IssuanceTest(BitcoinTestFramework):
blinded_tx = self.nodes[0].blindrawtransaction(issued_tx["hex"])
signed_tx = self.nodes[0].signrawtransactionwithwallet(blinded_tx)
tx_id = self.nodes[0].sendrawtransaction(signed_tx["hex"])
self.nodes[0].generate(1)
self.generate(self.nodes[0], 1)
assert_equal(self.nodes[0].gettransaction(tx_id)["confirmations"], 1)
utxo_info = None
@ -479,7 +482,7 @@ class IssuanceTest(BitcoinTestFramework):
blind_tx = self.nodes[0].blindrawtransaction(reissued_tx["hex"], False)
signed_tx = self.nodes[0].signrawtransactionwithwallet(blind_tx)
tx_id = self.nodes[0].sendrawtransaction(signed_tx["hex"])
self.nodes[0].generate(1)
self.generate(self.nodes[0], 1)
assert_equal(self.nodes[0].gettransaction(tx_id)["confirmations"], 1)
# Regression for one form of https://github.com/bitcoin/bitcoin/issues/20347
@ -489,7 +492,7 @@ class IssuanceTest(BitcoinTestFramework):
nonblind_addr = self.nodes[1].validateaddress(blind_addr)['unconfidential']
self.nodes[0].sendtoaddress(nonblind_addr, 0.0005)
self.sync_all()
self.nodes[0].generate(2)
self.generate(self.nodes[0], 2)
self.sync_all()
# 2. Try to do an unblinded issuance with only tokens -- the result will

4
test/functional/feature_mandatory_coinbase.py
View file

@ -44,10 +44,10 @@ class MandatoryCoinbaseTest(BitcoinTestFramework):
self.log.info("generatetoaddress: Making blocks of various kinds, checking for rejection")
# Create valid blocks to get out of IBD and get some funds (subsidy goes to permitted addr)
node0.generatetoaddress(101, mandatory_address)
self.generatetoaddress(node0, 101, mandatory_address)
# Generating for another address will not work
assert_raises_rpc_error(-1, "CreateNewBlock: TestBlockValidity failed: bad-coinbase-txos", node0.generatetoaddress, 1, node0.getnewaddress())
assert_raises_rpc_error(-1, "CreateNewBlock: TestBlockValidity failed: bad-coinbase-txos", self.generatetoaddress, node0, 1, node0.getnewaddress())
# Have non-mandatory node make a template
self.sync_all()

10
test/functional/feature_pak.py
View file

@ -111,7 +111,7 @@ class PAKTest (BitcoinTestFramework):
print(pegout_info)
raw_node1_pegout = self.nodes[1].gettransaction(pegout_info["txid"])["hex"]
self.sync_all() # mempool sync
self.nodes[1].generatetoaddress(1, self.nodes[0].getnewaddress())
self.generatetoaddress(self.nodes[1], 1, self.nodes[0].getnewaddress())
self.sync_all() # block sync
assert_greater_than(self.nodes[1].gettransaction(pegout_info["txid"])["confirmations"], 0)
@ -184,7 +184,7 @@ class PAKTest (BitcoinTestFramework):
self.sync_blocks()
# Get some block subsidy and send off
self.nodes[1].generatetoaddress(101, self.nodes[1].getnewaddress())
self.generatetoaddress(self.nodes[1], 101, self.nodes[1].getnewaddress())
wpkh_stmc = self.nodes[1].sendtomainchain("", 1)
wpkh_txid = wpkh_stmc['txid']
@ -215,7 +215,7 @@ class PAKTest (BitcoinTestFramework):
self.nodes[1].submitblock(block)
self.sync_blocks()
self.nodes[1].generatetoaddress(1, self.nodes[1].getnewaddress())
self.generatetoaddress(self.nodes[1], 1, self.nodes[1].getnewaddress())
sh_wpkh_txid = self.nodes[1].sendtomainchain("", 1)['txid']
# Make sure peg-outs look correct
@ -244,7 +244,7 @@ class PAKTest (BitcoinTestFramework):
assert peg_out_found
# Make sure they all confirm
self.nodes[1].generatetoaddress(1, self.nodes[0].getnewaddress())
self.generatetoaddress(self.nodes[1], 1, self.nodes[0].getnewaddress())
for tx_id in [wpkh_txid, sh_wpkh_txid]:
assert_greater_than(self.nodes[1].gettransaction(tx_id)["confirmations"], 0)
@ -270,7 +270,7 @@ class PAKTest (BitcoinTestFramework):
assert_raises_rpc_error(-25, "bad-pak-tx", self.nodes[2].testproposedblock, bad_prop, True)
# Test that subtracting fee from output works
self.nodes[1].generatetoaddress(101, self.nodes[1].getnewaddress())
self.generatetoaddress(self.nodes[1], 101, self.nodes[1].getnewaddress())
self.nodes[1].sendtomainchain("", self.nodes[1].getbalance()["bitcoin"], True)
assert_equal(self.nodes[1].getbalance()["bitcoin"], 0)

2
test/functional/feature_progress.py
View file

@ -42,7 +42,7 @@ class ProgressTest(BitcoinTestFramework):
blocks = []
for i in range(10):
self.setmocktime(i)
blocks.extend(node1.generate(1))
blocks.extend(self.generate(node1, 1))
self.setmocktime(19)
assert_close(0.5, node1.getblockchaininfo()["verificationprogress"])

10
test/functional/feature_sighash_rangeproof.py
View file

@ -72,7 +72,7 @@ class SighashRangeproofTest(BitcoinTestFramework):
addr = self.nodes[1].getnewaddress("", address_type)
assert len(self.nodes[1].getaddressinfo(addr)["confidential_key"]) > 0
self.nodes[0].sendtoaddress(addr, 1.0)
self.nodes[0].generate(1)
self.generate(self.nodes[0], 1)
self.sync_all()
utxo = self.nodes[1].listunspent(1, 1, [addr])[0]
utxo_tx = tx_from_hex(self.nodes[1].getrawtransaction(utxo["txid"]))
@ -225,7 +225,7 @@ class SighashRangeproofTest(BitcoinTestFramework):
# - after activation, using the flag is standard (and thus also legal)
# Mine come coins for node 0.
self.nodes[0].generate(200)
self.generate(self.nodes[0], 200)
self.sync_all()
# Ensure that if we use the SIGHASH_RANGEPROOF flag before it's activated,
@ -244,9 +244,9 @@ class SighashRangeproofTest(BitcoinTestFramework):
# Activate dynafed (nb of blocks taken from dynafed activation test)
# Generate acress several calls to `generatetoaddress` to ensure no individual call times out
self.nodes[0].generate(503)
self.nodes[0].generate(503)
self.nodes[0].generate(1 + 144 + 144)
self.generate(self.nodes[0], 503)
self.generate(self.nodes[0], 503)
self.generate(self.nodes[0], 1 + 144 + 144)
assert_equal(self.nodes[0].getblockchaininfo()["softforks"]["dynafed"]["bip9"]["status"], "active")
self.sync_all()

10
test/functional/feature_txwitness.py
View file

@ -91,10 +91,10 @@ class TxWitnessTest(BitcoinTestFramework):
self.unknown_addr = self.nodes[1].getnewaddress()
# directly seed types of utxos required
self.nodes[0].generatetoaddress(1, legacy_addr)
self.nodes[0].generatetoaddress(1, p2sh_addr)
self.nodes[0].generatetoaddress(1, bech32_addr)
self.nodes[0].generatetoaddress(101, self.unknown_addr)
self.generatetoaddress(self.nodes[0], 1, legacy_addr)
self.generatetoaddress(self.nodes[0], 1, p2sh_addr)
self.generatetoaddress(self.nodes[0], 1, bech32_addr)
self.generatetoaddress(self.nodes[0], 101, self.unknown_addr)
# grab utxos filtering by age
legacy_utxo = self.nodes[0].listunspent(104, 104)[0]
@ -109,7 +109,7 @@ class TxWitnessTest(BitcoinTestFramework):
self.log.info("Testing bech32 UTXO")
submitted_txids.append(self.assert_tx_format_also_signed(bech32_utxo, segwit=True))
blockhash = self.nodes[0].generate(1)[0]
blockhash = self.generate(self.nodes[0], 1)[0]
hexblock = self.nodes[0].getblock(blockhash, 0)
block_details = self.nodes[0].getblock(blockhash, 2)
block = CBlock()

2
test/functional/mempool_package_limits.py
View file

@ -251,7 +251,7 @@ class MempoolPackageLimitsTest(BitcoinTestFramework):
assert_equal(txres["package-error"], "package-mempool-limits")
# Clear mempool and check that the package passes now
node.generate(1)
self.generate(node, 1)
assert all([res["allowed"] for res in node.testmempoolaccept(rawtxs=package_hex)])
def test_anc_count_limits(self):

4
test/functional/rpc_fundrawtransaction.py
View file

@ -1007,7 +1007,7 @@ class RawTransactionsTest(BitcoinTestFramework):
txid = self.nodes[2].sendtoaddress(addr_info['unconfidential'], 10)
self.sync_all()
vout = find_vout_for_address(self.nodes[0], txid, n0_blind_addr)
self.nodes[0].generate(1)
self.generate(self.nodes[0], 1)
self.sync_all()
# An external input without solving data should result in an error
@ -1224,7 +1224,7 @@ class RawTransactionsTest(BitcoinTestFramework):
for i in range(0, 50):
outputs[recipient.getnewaddress()] = 0.1
wallet.sendmany("", outputs)
self.nodes[0].generate(10)
self.generate(self.nodes[0], 10)
# ...and try to send them all in one transaction
# This should fail but we should not see an assertion failure.

4
test/functional/rpc_psbt.py
View file

@ -635,7 +635,7 @@ class PSBTTest(BitcoinTestFramework):
# Extractor test
for extractor in extractors:
extracted = self.nodes[2].finalizepsbt(extractor['extract'], True)['hex']
extracted = self.n des[2].finalizepsbt(extractor['extract'], True)['hex']
assert_equal(extracted, extractor['result'])
# Unload extra wallets
@ -950,7 +950,7 @@ class PSBTTest(BitcoinTestFramework):
assert_raises_rpc_error(-8, "PSBTs not compatible (different transactions)", self.nodes[0].combinepsbt, [BLINDED, bad_pset])
def run_test(self):
self.nodes[0].generate(200)
self.generate(self.nodes[0], 200)
self.sync_all()
# Run all the pre-Elements, tests first with non-confidential addresses, then again with confidential addresses

4
test/functional/rpc_signrawtransaction.py
View file

@ -365,7 +365,7 @@ class SignRawTransactionsTest(BitcoinTestFramework):
utxo_script_pk = utxo_address_info['scriptPubKey']
utxo_amount = 0.1
utxo_txid = self.nodes[2].sendtoaddress(utxo_address, utxo_amount)
self.nodes[2].generate(1)
self.generate(self.nodes[2], 1)
tx = self.nodes[2].getrawtransaction(utxo_txid, True)
vout = [v['n'] for v in tx['vout'] if 'scriptPubKey' in v and uc_addr == v['scriptPubKey'].get('address',[])]
@ -408,7 +408,7 @@ class SignRawTransactionsTest(BitcoinTestFramework):
# 5) The signed transaction can broadcast.
txid = self.nodes[2].sendrawtransaction(signed_tx['hex'])
self.nodes[2].generate(1)
self.generate(self.nodes[2], 1)
tx = self.nodes[2].getrawtransaction(txid, True)
vout = [v['n'] for v in tx['vout'] if 'scriptPubKey' in v and uc_addr == v['scriptPubKey'].get('address',[])]

2
test/functional/rpc_tweakfedpeg.py
View file

@ -86,7 +86,7 @@ class TweakFedpegTest(BitcoinTestFramework):
# Advance to dynamic federations activation, which has pubkeys
# after OP_ELSE get tweaked except the exact liquidv1 template to
# maintain compatibility
self.nodes[2].generate(433)
self.generate(self.nodes[2], 433)
assert_equal(self.nodes[2].getblockchaininfo()['softforks']['dynafed']['bip9']['status'], 'active')
assert_equal(self.nodes[2].tweakfedpegscript(claim_script)["script"], liquid_tweaked)

8
test/functional/test_framework/test_framework.py
View file

@ -632,19 +632,19 @@ class BitcoinTestFramework(metaclass=BitcoinTestMetaClass):
self.sync_all()
def generate(self, generator, *args, **kwargs):
blocks = generator.generate(*args, **kwargs)
blocks = generator.generate(*args, invalid_call=False, **kwargs)
return blocks
def generateblock(self, generator, *args, **kwargs):
blocks = generator.generateblock(*args, **kwargs)
blocks = generator.generateblock(*args, invalid_call=False, **kwargs)
return blocks
def generatetoaddress(self, generator, *args, **kwargs):
blocks = generator.generatetoaddress(*args, **kwargs)
blocks = generator.generatetoaddress(*args, invalid_call=False, **kwargs)
return blocks
def generatetodescriptor(self, generator, *args, **kwargs):
blocks = generator.generatetodescriptor(*args, **kwargs)
blocks = generator.generatetodescriptor(*args, invalid_call=False, **kwargs)
return blocks
def sync_blocks(self, nodes=None, wait=1, timeout=60, expect_disconnected=False):

16
test/functional/test_framework/test_node.py
View file

@ -311,9 +311,21 @@ class TestNode():
time.sleep(1.0 / poll_per_s)
self._raise_assertion_error("Unable to retrieve cookie credentials after {}s".format(self.rpc_timeout))
def generate(self, nblocks, maxtries=1000000):
def generate(self, nblocks, maxtries=1000000, **kwargs):
self.log.debug("TestNode.generate() dispatches `generate` call to `generatetoaddress`")
return self.generatetoaddress(nblocks=nblocks, address=self.get_deterministic_priv_key().address, maxtries=maxtries)
return self.generatetoaddress(nblocks=nblocks, address=self.get_deterministic_priv_key().address, maxtries=maxtries, **kwargs)
def generateblock(self, *args, invalid_call, **kwargs):
assert not invalid_call
return self.__getattr__('generateblock')(*args, **kwargs)
def generatetoaddress(self, *args, invalid_call, **kwargs):
assert not invalid_call
return self.__getattr__('generatetoaddress')(*args, **kwargs)
def generatetodescriptor(self, *args, invalid_call, **kwargs):
assert not invalid_call
return self.__getattr__('generatetodescriptor')(*args, **kwargs)
def get_wallet_rpc(self, wallet_name):
if self.use_cli:

4
test/functional/test_framework/wallet.py
View file

@ -111,9 +111,9 @@ class MiniWallet:
break
tx.vin[0].scriptSig = CScript([der_sig + bytes(bytearray([SIGHASH_ALL]))])
def generate(self, num_blocks):
def generate(self, num_blocks, **kwargs):
"""Generate blocks with coinbase outputs to the internal address, and append the outputs to the internal list"""
blocks = self._test_node.generatetodescriptor(num_blocks, self.get_descriptor())
blocks = self._test_node.generatetodescriptor(num_blocks, self.get_descriptor(), **kwargs)
for b in blocks:
cb_tx = self._test_node.getblock(blockhash=b, verbosity=2)['tx'][0]
self._utxos.append({'txid': cb_tx['txid'], 'vout': 0, 'value': cb_tx['vout'][0]['value']})

4
test/functional/wallet_balance.py
View file

@ -297,7 +297,7 @@ class WalletTest(BitcoinTestFramework):
assert_equal(walletinfo["unconfirmed_balance"].get(asset, 0), Decimal('0'))
# Balances with confirmed issuance.
self.nodes[0].generatetoaddress(1, ADDRESS_WATCHONLY)
self.generatetoaddress(self.nodes[0], 1, ADDRESS_WATCHONLY)
walletinfo = self.nodes[0].getwalletinfo()
assert_equal(walletinfo["balance"].get(asset, 0), Decimal('100'))
assert_equal(walletinfo["unconfirmed_balance"].get(asset, 0), Decimal('0'))
@ -312,7 +312,7 @@ class WalletTest(BitcoinTestFramework):
assert_equal(walletinfo["unconfirmed_balance"].get(asset, 0), Decimal('50'))
# Balances with confirmed receive
self.nodes[1].generatetoaddress(1, ADDRESS_WATCHONLY)
self.generatetoaddress(self.nodes[1], 1, ADDRESS_WATCHONLY)
walletinfo = self.nodes[1].getwalletinfo()
assert_equal(walletinfo["balance"].get(asset, 0), Decimal('50'))
assert_equal(walletinfo["unconfirmed_balance"].get(asset, 0), Decimal('0'))

2
test/functional/wallet_descriptor.py
View file

@ -84,7 +84,7 @@ class WalletDescriptorTest(BitcoinTestFramework):
send_wrpc = self.nodes[0].get_wallet_rpc("desc1")
# Generate some coins
self.generatetoaddress(send_wrpc, COINBASE_MATURITY + 1, send_wrpc.getnewaddress())
self.generatetoaddress(self.nodes[0], COINBASE_MATURITY + 1, send_wrpc.getnewaddress())
# Make transactions
self.log.info("Test sending and receiving")

2
test/functional/wallet_disable.py
View file

@ -29,7 +29,7 @@ class DisableWalletTest (BitcoinTestFramework):
# Checking mining to an address without a wallet. Generating to a valid address should succeed
# but generating to an invalid address will fail.
self.generatetoaddress(self.nodes[0], 1, 'CTEsjYXANAynYYMzu5BUyvfNAVToxGh3s17kjZvELXuBG37qsfzz65vfhxEocbo55AnrvGbWBuMbJMCz')
assert_raises_rpc_error(-5, "Invalid address", self.nodes[0].generatetoaddress, 1, '3J98t1WpEZ73CNmQviecrnyiWrnqRhWNLy')
assert_raises_rpc_error(-5, "Invalid address", self.generatetoaddress, self.nodes[0], 1, '3J98t1WpEZ73CNmQviecrnyiWrnqRhWNLy')
if __name__ == '__main__':
DisableWalletTest ().main ()

10
test/functional/wallet_elements_regression_1172.py
View file

@ -47,7 +47,7 @@ class WalletCtTest(BitcoinTestFramework):
address = self.nodes[to_idx].getaddressinfo(address)['unconfidential']
txid = self.nodes[from_idx].sendtoaddress(address, amt)
self.log.info(f"Sent {amt} LBTC to node {to_idx} in {txid}")
self.nodes[from_idx].generate(2)
self.generate(self.nodes[from_idx], 2)
self.sync_all()
for i in range(self.num_nodes):
@ -57,7 +57,7 @@ class WalletCtTest(BitcoinTestFramework):
def run_test(self):
# Mine 101 blocks to get the initial coins out of IBD
self.nodes[0].generate(COINBASE_MATURITY + 1)
self.generate(self.nodes[0], COINBASE_MATURITY + 1)
self.nodes[0].syncwithvalidationinterfacequeue()
self.sync_all()
@ -67,7 +67,7 @@ class WalletCtTest(BitcoinTestFramework):
# Send 1 coin to a new wallet
txid = self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 1)
self.log.info(f"Sent one coin to node 1 in {txid}")
self.nodes[0].generate(2)
self.generate(self.nodes[0], 2)
self.sync_all()
# Try to send those coins to yet another wallet, sending a large enough amount
@ -95,7 +95,7 @@ class WalletCtTest(BitcoinTestFramework):
+ [ self.nodes[2].getnewaddress() for i in range(15) ]
txid = self.nodes[2].sendmany(amounts={address: satoshi_round(Decimal(0.00025)) for address in addresses})
self.log.info(f"Sent many small UTXOs to nodes 1 and 2 in {txid}")
self.nodes[2].generate(2)
self.generate(self.nodes[2], 2)
self.sync_all()
self.log.info(f"Issuing some assets from node 1")
@ -111,7 +111,7 @@ class WalletCtTest(BitcoinTestFramework):
output_assets={addresses[i]: assets[i] for i in range(len(assets))},
)
self.log.info(f"Sent them to node 2 in {txid}")
self.nodes[1].generate(2)
self.generate(self.nodes[1], 2)
self.sync_all()
# Send them back
addresses = [ self.nodes[1].getnewaddress() for i in range(len(assets)) ]

2
test/functional/wallet_fallbackfee.py
View file

@ -46,7 +46,7 @@ class WalletRBFTest(BitcoinTestFramework):
addrs = self.nodes[1].getpeginaddress()
txid = self.nodes[0].sendtoaddress(addrs["mainchain_address"], 5)
raw = self.nodes[0].getrawtransaction(txid)
self.nodes[0].generate(12)
self.generate(self.nodes[0], 12)
proof = self.nodes[0].gettxoutproof([txid])
assert_raises_rpc_error(-6, "Fee estimation failed", lambda: self.nodes[1].claimpegin(raw, proof))

4
test/functional/wallet_importdescriptors.py
View file

@ -74,7 +74,7 @@ class ImportDescriptorsTest(BitcoinTestFramework):
assert_equal(wpriv.getwalletinfo()['keypoolsize'], 0)
self.log.info('Mining coins')
self.generatetoaddress(w0, COINBASE_MATURITY + 1, w0.getnewaddress())
self.generatetoaddress(self.nodes[0], COINBASE_MATURITY + 1, w0.getnewaddress())
# RPC importdescriptors -----------------------------------------------
@ -405,7 +405,7 @@ class ImportDescriptorsTest(BitcoinTestFramework):
solvable=True,
ismine=True)
txid = w0.sendtoaddress(address, 49.99965520)
self.generatetoaddress(w0, 6, w0.getnewaddress())
self.generatetoaddress(self.nodes[0], 6, w0.getnewaddress())
self.sync_blocks()
tx = wpriv.createrawtransaction([{"txid": txid, "vout": 0}], [{w0.getnewaddress(): 49.999}, {"fee": 0.00065520}])
signed_tx = wpriv.signrawtransactionwithwallet(tx)

8
test/functional/wallet_transactiontime_rescan.py
View file

@ -63,7 +63,7 @@ class TransactionTimeRescanTest(BitcoinTestFramework):
# generate some btc to create transactions and check blockcount
initial_mine = COINBASE_MATURITY + 1
minernode.generatetoaddress(initial_mine, m1)
self.generatetoaddress(minernode, initial_mine, m1)
assert_equal(minernode.getblockcount(), initial_mine + 200)
# synchronize nodes and time
@ -76,7 +76,7 @@ class TransactionTimeRescanTest(BitcoinTestFramework):
miner_wallet.sendtoaddress(wo1, 10)
# generate blocks and check blockcount
minernode.generatetoaddress(COINBASE_MATURITY, m1)
self.generatetoaddress(minernode, COINBASE_MATURITY, m1)
assert_equal(minernode.getblockcount(), initial_mine + 300)
# synchronize nodes and time
@ -89,7 +89,7 @@ class TransactionTimeRescanTest(BitcoinTestFramework):
miner_wallet.sendtoaddress(wo2, 5)
# generate blocks and check blockcount
minernode.generatetoaddress(COINBASE_MATURITY, m1)
self.generatetoaddress(minernode, COINBASE_MATURITY, m1)
assert_equal(minernode.getblockcount(), initial_mine + 400)
# synchronize nodes and time
@ -102,7 +102,7 @@ class TransactionTimeRescanTest(BitcoinTestFramework):
miner_wallet.sendtoaddress(wo3, 1)
# generate more blocks and check blockcount
minernode.generatetoaddress(COINBASE_MATURITY, m1)
self.generatetoaddress(minernode, COINBASE_MATURITY, m1)
assert_equal(minernode.getblockcount(), initial_mine + 500)
self.log.info('Check user\'s final balance and transaction count')