mirror of
https://github.com/dashpay/dash.git
synced 2024-12-25 12:02:48 +01:00
57b6fe7327
bdb8b9a347e68f80a2e8d44ce5590a2e8214b6bb test: doc: improve doc for `from_hex` helper (mention `to_hex` alternative) (Sebastian Falbesoner) 191405420815d49ab50184513717a303fc2744d6 scripted-diff: test: rename `FromHex` to `from_hex` (Sebastian Falbesoner) a79396fe5f8f81c78cf84117a87074c6ff6c9d95 test: remove `ToHex` helper, use .serialize().hex() instead (Sebastian Falbesoner) 2ce7b47958c4a10ba20dc86c011d71cda4b070a5 test: introduce `tx_from_hex` helper for tx deserialization (Sebastian Falbesoner) Pull request description: There are still many functional tests that perform conversions from a hex-string to a message object (deserialization) manually. This PR identifies all those instances and replaces them with a newly introduced helper `tx_from_hex`. Instances were found via * `git grep "deserialize.*BytesIO"` and some of them manually, when it were not one-liners. Further, the helper `ToHex` was removed and simply replaced by `.serialize().hex()`, since now both variants are in use (sometimes even within the same test) and using the helper doesn't really have an advantage in readability. (see discussion https://github.com/bitcoin/bitcoin/pull/22257#discussion_r652404782) ACKs for top commit: MarcoFalke: review re-ACK bdb8b9a347e68f80a2e8d44ce5590a2e8214b6bb 😁 Tree-SHA512: e25d7dc85918de1d6755a5cea65471b07a743204c20ad1c2f71ff07ef48cc1b9ad3fe5f515c1efaba2b2e3d89384e7980380c5d81895f9826e2046808cd3266e
616 lines
27 KiB
Python
Executable File
616 lines
27 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
|
|
# Copyright (c) 2022-2024 The Dash Core developers
|
|
# Distributed under the MIT software license, see the accompanying
|
|
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|
|
|
import copy
|
|
import struct
|
|
from decimal import Decimal
|
|
from io import BytesIO
|
|
|
|
from test_framework.blocktools import (
|
|
create_block,
|
|
create_coinbase,
|
|
)
|
|
from test_framework.authproxy import JSONRPCException
|
|
from test_framework.key import ECKey
|
|
from test_framework.messages import (
|
|
CAssetLockTx,
|
|
CAssetUnlockTx,
|
|
COIN,
|
|
COutPoint,
|
|
CTransaction,
|
|
CTxIn,
|
|
CTxOut,
|
|
tx_from_hex,
|
|
hash256,
|
|
ser_string,
|
|
)
|
|
from test_framework.script import (
|
|
CScript,
|
|
OP_CHECKSIG,
|
|
OP_DUP,
|
|
OP_EQUALVERIFY,
|
|
OP_HASH160,
|
|
OP_RETURN,
|
|
hash160,
|
|
)
|
|
from test_framework.test_framework import DashTestFramework
|
|
from test_framework.util import (
|
|
assert_equal,
|
|
assert_greater_than,
|
|
assert_greater_than_or_equal,
|
|
get_bip9_details,
|
|
hex_str_to_bytes,
|
|
)
|
|
|
|
llmq_type_test = 106 # LLMQType::LLMQ_TEST_PLATFORM
|
|
tiny_amount = int(Decimal("0.0007") * COIN)
|
|
blocks_in_one_day = 576
|
|
|
|
class AssetLocksTest(DashTestFramework):
|
|
def set_test_params(self):
|
|
self.set_dash_test_params(5, 3, [["-whitelist=127.0.0.1", "-llmqtestinstantsenddip0024=llmq_test_instantsend"]] * 5, evo_count=3)
|
|
|
|
def skip_test_if_missing_module(self):
|
|
self.skip_if_no_wallet()
|
|
|
|
def create_assetlock(self, coin, amount, pubkey):
|
|
node_wallet = self.nodes[0]
|
|
|
|
|
|
inputs = [CTxIn(COutPoint(int(coin["txid"], 16), coin["vout"]))]
|
|
|
|
credit_outputs = []
|
|
tmp_amount = amount
|
|
if tmp_amount > COIN:
|
|
tmp_amount -= COIN
|
|
credit_outputs.append(CTxOut(COIN, CScript([OP_DUP, OP_HASH160, hash160(pubkey), OP_EQUALVERIFY, OP_CHECKSIG])))
|
|
credit_outputs.append(CTxOut(tmp_amount, CScript([OP_DUP, OP_HASH160, hash160(pubkey), OP_EQUALVERIFY, OP_CHECKSIG])))
|
|
|
|
lockTx_payload = CAssetLockTx(1, credit_outputs)
|
|
|
|
remaining = int(COIN * coin['amount']) - tiny_amount - amount
|
|
|
|
tx_output_ret = CTxOut(amount, CScript([OP_RETURN, b""]))
|
|
tx_output = CTxOut(remaining, CScript([pubkey, OP_CHECKSIG]))
|
|
|
|
lock_tx = CTransaction()
|
|
lock_tx.vin = inputs
|
|
lock_tx.vout = [tx_output, tx_output_ret] if remaining > 0 else [tx_output_ret]
|
|
lock_tx.nVersion = 3
|
|
lock_tx.nType = 8 # asset lock type
|
|
lock_tx.vExtraPayload = lockTx_payload.serialize()
|
|
|
|
lock_tx = node_wallet.signrawtransactionwithwallet(lock_tx.serialize().hex())
|
|
return tx_from_hex(lock_tx["hex"])
|
|
|
|
|
|
def create_assetunlock(self, index, withdrawal, pubkey=None, fee=tiny_amount):
|
|
node_wallet = self.nodes[0]
|
|
mninfo = self.mninfo
|
|
assert_greater_than(int(withdrawal), fee)
|
|
tx_output = CTxOut(int(withdrawal) - fee, CScript([pubkey, OP_CHECKSIG]))
|
|
|
|
# request ID = sha256("plwdtx", index)
|
|
request_id_buf = ser_string(b"plwdtx") + struct.pack("<Q", index)
|
|
request_id = hash256(request_id_buf)[::-1].hex()
|
|
|
|
height = node_wallet.getblockcount()
|
|
self.log.info(f"Creating asset unlock: {llmq_type_test} {request_id}")
|
|
quorumHash = mninfo[0].node.quorum("selectquorum", llmq_type_test, request_id)["quorumHash"]
|
|
self.log.info(f"Used quorum hash: {quorumHash}")
|
|
unlockTx_payload = CAssetUnlockTx(
|
|
version = 1,
|
|
index = index,
|
|
fee = fee,
|
|
requestedHeight = height,
|
|
quorumHash = int(quorumHash, 16),
|
|
quorumSig = b'\00' * 96)
|
|
|
|
unlock_tx = CTransaction()
|
|
unlock_tx.vin = []
|
|
unlock_tx.vout = [tx_output]
|
|
unlock_tx.nVersion = 3
|
|
unlock_tx.nType = 9 # asset unlock type
|
|
unlock_tx.vExtraPayload = unlockTx_payload.serialize()
|
|
|
|
unlock_tx.calc_sha256()
|
|
msgHash = format(unlock_tx.sha256, '064x')
|
|
|
|
recsig = self.get_recovered_sig(request_id, msgHash, llmq_type=llmq_type_test)
|
|
|
|
unlockTx_payload.quorumSig = bytearray.fromhex(recsig["sig"])
|
|
unlock_tx.vExtraPayload = unlockTx_payload.serialize()
|
|
return unlock_tx
|
|
|
|
def get_credit_pool_balance(self, node = None, block_hash = None):
|
|
if node is None:
|
|
node = self.nodes[0]
|
|
|
|
if block_hash is None:
|
|
block_hash = node.getbestblockhash()
|
|
block = node.getblock(block_hash)
|
|
return int(COIN * block['cbTx']['creditPoolBalance'])
|
|
|
|
def validate_credit_pool_balance(self, expected = None, block_hash = None):
|
|
for node in self.nodes:
|
|
locked = self.get_credit_pool_balance(node=node, block_hash=block_hash)
|
|
if expected is None:
|
|
expected = locked
|
|
else:
|
|
assert_equal(expected, locked)
|
|
self.log.info(f"Credit pool amount matched with '{expected}'")
|
|
return expected
|
|
|
|
def check_mempool_size(self):
|
|
self.sync_mempools()
|
|
for node in self.nodes:
|
|
assert_equal(node.getmempoolinfo()['size'], self.mempool_size)
|
|
|
|
def check_mempool_result(self, result_expected, tx):
|
|
"""Wrapper to check result of testmempoolaccept on node_0's mempool"""
|
|
result_expected['txid'] = tx.rehash()
|
|
if result_expected['allowed']:
|
|
result_expected['vsize'] = tx.get_vsize()
|
|
|
|
result_test = self.nodes[0].testmempoolaccept([tx.serialize().hex()])
|
|
|
|
assert_equal([result_expected], result_test)
|
|
self.check_mempool_size()
|
|
|
|
def create_and_check_block(self, txes, expected_error = None):
|
|
node_wallet = self.nodes[0]
|
|
best_block_hash = node_wallet.getbestblockhash()
|
|
best_block = node_wallet.getblock(best_block_hash)
|
|
tip = int(best_block_hash, 16)
|
|
height = best_block["height"] + 1
|
|
block_time = best_block["time"] + 1
|
|
|
|
cbb = create_coinbase(height, dip4_activated=True, v20_activated=True)
|
|
gbt = node_wallet.getblocktemplate()
|
|
cbb.vExtraPayload = hex_str_to_bytes(gbt["coinbase_payload"])
|
|
cbb.rehash()
|
|
block = create_block(tip, cbb, block_time, version=4)
|
|
# Add quorum commitments from block template
|
|
for tx_obj in gbt["transactions"]:
|
|
tx = tx_from_hex(tx_obj["data"])
|
|
if tx.nType == 6:
|
|
block.vtx.append(tx)
|
|
for tx in txes:
|
|
block.vtx.append(tx)
|
|
block.hashMerkleRoot = block.calc_merkle_root()
|
|
block.solve()
|
|
result = node_wallet.submitblock(block.serialize().hex())
|
|
if result != expected_error:
|
|
raise AssertionError('mining the block should have failed with error %s, but submitblock returned %s' % (expected_error, result))
|
|
|
|
def set_sporks(self):
|
|
spork_enabled = 0
|
|
spork_disabled = 4070908800
|
|
|
|
self.nodes[0].sporkupdate("SPORK_17_QUORUM_DKG_ENABLED", spork_enabled)
|
|
self.nodes[0].sporkupdate("SPORK_19_CHAINLOCKS_ENABLED", spork_disabled)
|
|
self.nodes[0].sporkupdate("SPORK_2_INSTANTSEND_ENABLED", spork_disabled)
|
|
self.wait_for_sporks_same()
|
|
|
|
def ensure_tx_is_not_mined(self, tx_id):
|
|
try:
|
|
for node in self.nodes:
|
|
node.gettransaction(tx_id)
|
|
raise AssertionError("Transaction should not be mined")
|
|
except JSONRPCException as e:
|
|
assert "Invalid or non-wallet transaction id" in e.error['message']
|
|
|
|
def send_tx_simple(self, tx):
|
|
return self.nodes[0].sendrawtransaction(hexstring=tx.serialize().hex(), maxfeerate=0)
|
|
|
|
def send_tx(self, tx, expected_error = None, reason = None):
|
|
try:
|
|
self.log.info(f"Send tx with expected_error:'{expected_error}'...")
|
|
tx_res = self.send_tx_simple(tx)
|
|
if expected_error is None:
|
|
self.sync_mempools()
|
|
return tx_res
|
|
|
|
# failure didn't happen, but expected:
|
|
message = "Transaction should not be accepted"
|
|
if reason is not None:
|
|
message += ": " + reason
|
|
|
|
raise AssertionError(message)
|
|
except JSONRPCException as e:
|
|
assert expected_error in e.error['message']
|
|
|
|
def slowly_generate_batch(self, amount):
|
|
self.log.info(f"Slowly generate {amount} blocks")
|
|
while amount > 0:
|
|
self.log.info(f"Generating batch of blocks {amount} left")
|
|
next = min(10, amount)
|
|
amount -= next
|
|
self.bump_mocktime(next)
|
|
self.nodes[1].generate(next)
|
|
self.sync_all()
|
|
|
|
def run_test(self):
|
|
node_wallet = self.nodes[0]
|
|
node = self.nodes[1]
|
|
|
|
self.set_sporks()
|
|
|
|
self.activate_v19(expected_activation_height=900)
|
|
self.log.info("Activated v19 at height:" + str(node.getblockcount()))
|
|
|
|
self.nodes[0].sporkupdate("SPORK_2_INSTANTSEND_ENABLED", 0)
|
|
self.wait_for_sporks_same()
|
|
|
|
self.mine_quorum(llmq_type_name='llmq_test_instantsend', llmq_type=104)
|
|
|
|
for _ in range(3):
|
|
self.dynamically_add_masternode(evo=True)
|
|
node.generate(8)
|
|
self.sync_blocks()
|
|
|
|
self.set_sporks()
|
|
self.activate_v20()
|
|
node.generate(1)
|
|
self.sync_all()
|
|
self.mempool_size = 0
|
|
|
|
key = ECKey()
|
|
key.generate()
|
|
pubkey = key.get_pubkey().get_bytes()
|
|
|
|
self.test_asset_locks(node_wallet, node, pubkey)
|
|
self.test_asset_unlocks(node_wallet, node, pubkey)
|
|
self.test_withdrawal_limits(node_wallet, node, pubkey)
|
|
self.test_mn_rr(node_wallet, node, pubkey)
|
|
|
|
|
|
def test_asset_locks(self, node_wallet, node, pubkey):
|
|
self.log.info("Testing asset lock...")
|
|
locked_1 = 10 * COIN + 141421
|
|
locked_2 = 10 * COIN + 314159
|
|
|
|
coins = node_wallet.listunspent(query_options={'minimumAmount': Decimal(str(locked_2 / COIN))})
|
|
coin = coins.pop()
|
|
asset_lock_tx = self.create_assetlock(coin, locked_1, pubkey)
|
|
|
|
|
|
self.check_mempool_result(tx=asset_lock_tx, result_expected={'allowed': True, 'fees': {'base': Decimal(str(tiny_amount / COIN))}})
|
|
self.validate_credit_pool_balance(0)
|
|
txid_in_block = self.send_tx(asset_lock_tx)
|
|
assert "assetLockTx" in node.getrawtransaction(txid_in_block, 1)
|
|
self.validate_credit_pool_balance(0)
|
|
node.generate(1)
|
|
assert_equal(self.get_credit_pool_balance(node=node), locked_1)
|
|
self.log.info("Generate a number of blocks to ensure this is the longest chain for later in the test when we reconsiderblock")
|
|
node.generate(12)
|
|
self.sync_all()
|
|
|
|
self.validate_credit_pool_balance(locked_1)
|
|
|
|
# tx is mined, let's get blockhash
|
|
self.log.info("Invalidate block with asset lock tx...")
|
|
self.block_hash_1 = node_wallet.gettransaction(txid_in_block)['blockhash']
|
|
for inode in self.nodes:
|
|
inode.invalidateblock(self.block_hash_1)
|
|
assert_equal(self.get_credit_pool_balance(node=inode), 0)
|
|
node.generate(3)
|
|
self.sync_all()
|
|
self.validate_credit_pool_balance(0)
|
|
self.log.info("Resubmit asset lock tx to new chain...")
|
|
# NEW tx appears
|
|
asset_lock_tx_2 = self.create_assetlock(coin, locked_2, pubkey)
|
|
txid_in_block = self.send_tx(asset_lock_tx_2)
|
|
node.generate(1)
|
|
self.sync_all()
|
|
self.validate_credit_pool_balance(locked_2)
|
|
self.log.info("Reconsider old blocks...")
|
|
for inode in self.nodes:
|
|
inode.reconsiderblock(self.block_hash_1)
|
|
self.validate_credit_pool_balance(locked_1)
|
|
self.sync_all()
|
|
|
|
self.log.info('Mine block with incorrect credit-pool value...')
|
|
coin = coins.pop()
|
|
extra_lock_tx = self.create_assetlock(coin, COIN, pubkey)
|
|
self.create_and_check_block([extra_lock_tx], expected_error = 'bad-cbtx-assetlocked-amount')
|
|
|
|
self.log.info("Mine a quorum...")
|
|
self.mine_quorum(llmq_type_name='llmq_test_platform', llmq_type=106, expected_connections=2, expected_members=3, expected_contributions=3, expected_complaints=0, expected_justifications=0, expected_commitments=3 )
|
|
|
|
self.validate_credit_pool_balance(locked_1)
|
|
|
|
|
|
def test_asset_unlocks(self, node_wallet, node, pubkey):
|
|
self.log.info("Testing asset unlock...")
|
|
|
|
self.log.info("Generating several txes by same quorum....")
|
|
locked = self.get_credit_pool_balance()
|
|
|
|
self.validate_credit_pool_balance(locked)
|
|
asset_unlock_tx = self.create_assetunlock(101, COIN, pubkey)
|
|
asset_unlock_tx_late = self.create_assetunlock(102, COIN, pubkey)
|
|
asset_unlock_tx_too_late = self.create_assetunlock(103, COIN, pubkey)
|
|
asset_unlock_tx_too_big_fee = self.create_assetunlock(104, COIN, pubkey, fee=int(Decimal("0.1") * COIN))
|
|
asset_unlock_tx_zero_fee = self.create_assetunlock(105, COIN, pubkey, fee=0)
|
|
asset_unlock_tx_duplicate_index = copy.deepcopy(asset_unlock_tx)
|
|
# modify this tx with duplicated index to make a hash of tx different, otherwise tx would be refused too early
|
|
asset_unlock_tx_duplicate_index.vout[0].nValue += COIN
|
|
too_late_height = node.getblockcount() + 48
|
|
|
|
self.check_mempool_result(tx=asset_unlock_tx, result_expected={'allowed': True, 'fees': {'base': Decimal(str(tiny_amount / COIN))}})
|
|
self.check_mempool_result(tx=asset_unlock_tx_too_big_fee,
|
|
result_expected={'allowed': False, 'reject-reason' : 'max-fee-exceeded'})
|
|
self.check_mempool_result(tx=asset_unlock_tx_zero_fee,
|
|
result_expected={'allowed': False, 'reject-reason' : 'bad-txns-assetunlock-fee-outofrange'})
|
|
# not-verified is a correct faiure from mempool. Mempool knows nothing about CreditPool indexes and he just report that signature is not validated
|
|
self.check_mempool_result(tx=asset_unlock_tx_duplicate_index,
|
|
result_expected={'allowed': False, 'reject-reason' : 'bad-assetunlock-not-verified'})
|
|
|
|
self.log.info("Validating that we calculate payload hash correctly: ask quorum forcely by message hash...")
|
|
asset_unlock_tx_payload = CAssetUnlockTx()
|
|
asset_unlock_tx_payload.deserialize(BytesIO(asset_unlock_tx.vExtraPayload))
|
|
|
|
assert_equal(asset_unlock_tx_payload.quorumHash, int(self.mninfo[0].node.quorum("selectquorum", llmq_type_test, 'e6c7a809d79f78ea85b72d5df7e9bd592aecf151e679d6e976b74f053a7f9056')["quorumHash"], 16))
|
|
|
|
self.log.info("Test no IS for asset unlock...")
|
|
self.nodes[0].sporkupdate("SPORK_2_INSTANTSEND_ENABLED", 0)
|
|
self.wait_for_sporks_same()
|
|
|
|
txid = self.send_tx(asset_unlock_tx)
|
|
is_id = node_wallet.sendtoaddress(node_wallet.getnewaddress(), 1)
|
|
for node in self.nodes:
|
|
self.wait_for_instantlock(is_id, node)
|
|
|
|
|
|
tip = self.nodes[0].getblockcount()
|
|
indexes_statuses_no_height = self.nodes[0].getassetunlockstatuses(["101", "102", "300"])
|
|
assert_equal([{'index': 101, 'status': 'mempooled'}, {'index': 102, 'status': 'unknown'}, {'index': 300, 'status': 'unknown'}], indexes_statuses_no_height)
|
|
indexes_statuses_height = self.nodes[0].getassetunlockstatuses(["101", "102", "300"], tip)
|
|
assert_equal([{'index': 101, 'status': 'unknown'}, {'index': 102, 'status': 'unknown'}, {'index': 300, 'status': 'unknown'}], indexes_statuses_height)
|
|
|
|
|
|
rawtx = node.getrawtransaction(txid, 1)
|
|
rawtx_is = node.getrawtransaction(is_id, 1)
|
|
assert_equal(rawtx["instantlock"], False)
|
|
assert_equal(rawtx_is["instantlock"], True)
|
|
assert_equal(rawtx["chainlock"], False)
|
|
assert_equal(rawtx_is["chainlock"], False)
|
|
assert not "confirmations" in rawtx
|
|
assert not "confirmations" in rawtx_is
|
|
# disable back IS
|
|
self.set_sporks()
|
|
|
|
assert "assetUnlockTx" in node.getrawtransaction(txid, 1)
|
|
|
|
self.mempool_size += 2
|
|
self.check_mempool_size()
|
|
self.validate_credit_pool_balance(locked)
|
|
node.generate(1)
|
|
self.sync_all()
|
|
assert_equal(rawtx["instantlock"], False)
|
|
assert_equal(rawtx["chainlock"], False)
|
|
rawtx = node.getrawtransaction(txid, 1)
|
|
assert_equal(rawtx["confirmations"], 1)
|
|
self.validate_credit_pool_balance(locked - COIN)
|
|
self.mempool_size -= 2
|
|
self.check_mempool_size()
|
|
block_asset_unlock = node.getrawtransaction(asset_unlock_tx.rehash(), 1)['blockhash']
|
|
|
|
self.send_tx(asset_unlock_tx,
|
|
expected_error = "Transaction already in block chain",
|
|
reason = "double copy")
|
|
|
|
self.log.info("Mining next quorum to check tx 'asset_unlock_tx_late' is still valid...")
|
|
self.mine_quorum(llmq_type_name="llmq_test_platform", llmq_type=106)
|
|
self.log.info("Checking credit pool amount is same...")
|
|
self.validate_credit_pool_balance(locked - 1 * COIN)
|
|
self.check_mempool_result(tx=asset_unlock_tx_late, result_expected={'allowed': True, 'fees': {'base': Decimal(str(tiny_amount / COIN))}})
|
|
self.log.info("Checking credit pool amount still is same...")
|
|
self.validate_credit_pool_balance(locked - 1 * COIN)
|
|
self.send_tx(asset_unlock_tx_late)
|
|
node.generate(1)
|
|
self.sync_all()
|
|
self.validate_credit_pool_balance(locked - 2 * COIN)
|
|
|
|
self.log.info("Generating many blocks to make quorum far behind (even still active)...")
|
|
self.slowly_generate_batch(too_late_height - node.getblockcount() - 1)
|
|
self.check_mempool_result(tx=asset_unlock_tx_too_late, result_expected={'allowed': True, 'fees': {'base': Decimal(str(tiny_amount / COIN))}})
|
|
node.generate(1)
|
|
self.sync_all()
|
|
self.check_mempool_result(tx=asset_unlock_tx_too_late,
|
|
result_expected={'allowed': False, 'reject-reason' : 'bad-assetunlock-too-late'})
|
|
|
|
self.log.info("Checking that two quorums later it is too late because quorum is not active...")
|
|
self.mine_quorum(llmq_type_name="llmq_test_platform", llmq_type=106)
|
|
self.log.info("Expecting new reject-reason...")
|
|
self.check_mempool_result(tx=asset_unlock_tx_too_late,
|
|
result_expected={'allowed': False, 'reject-reason' : 'bad-assetunlock-not-active-quorum'})
|
|
|
|
block_to_reconsider = node.getbestblockhash()
|
|
self.log.info("Test block invalidation with asset unlock tx...")
|
|
for inode in self.nodes:
|
|
inode.invalidateblock(block_asset_unlock)
|
|
self.validate_credit_pool_balance(locked)
|
|
self.slowly_generate_batch(50)
|
|
self.validate_credit_pool_balance(locked)
|
|
for inode in self.nodes:
|
|
inode.reconsiderblock(block_to_reconsider)
|
|
self.validate_credit_pool_balance(locked - 2 * COIN)
|
|
|
|
self.log.info("Forcibly mining asset_unlock_tx_too_late and ensure block is invalid...")
|
|
self.create_and_check_block([asset_unlock_tx_too_late], expected_error = "bad-assetunlock-not-active-quorum")
|
|
|
|
node.generate(1)
|
|
self.sync_all()
|
|
|
|
self.validate_credit_pool_balance(locked - 2 * COIN)
|
|
self.validate_credit_pool_balance(block_hash=self.block_hash_1, expected=locked)
|
|
|
|
self.log.info("Forcibly mine asset_unlock_tx_full and ensure block is invalid...")
|
|
self.create_and_check_block([asset_unlock_tx_duplicate_index], expected_error = "bad-assetunlock-duplicated-index")
|
|
|
|
|
|
def test_withdrawal_limits(self, node_wallet, node, pubkey):
|
|
self.log.info("Testing withdrawal limits...")
|
|
self.log.info("Too big withdrawal is expected to not be mined")
|
|
asset_unlock_tx_full = self.create_assetunlock(201, 1 + self.get_credit_pool_balance(), pubkey)
|
|
|
|
self.log.info("Checking that transaction with exceeding amount accepted by mempool...")
|
|
# Mempool doesn't know about the size of the credit pool
|
|
self.check_mempool_result(tx=asset_unlock_tx_full, result_expected={'allowed': True, 'fees': {'base': Decimal(str(tiny_amount / COIN))}})
|
|
|
|
txid_in_block = self.send_tx(asset_unlock_tx_full)
|
|
node.generate(1)
|
|
self.sync_all()
|
|
|
|
self.ensure_tx_is_not_mined(txid_in_block)
|
|
|
|
self.log.info("Forcibly mine asset_unlock_tx_full and ensure block is invalid...")
|
|
self.create_and_check_block([asset_unlock_tx_full], expected_error = "failed-creditpool-unlock-too-much")
|
|
|
|
self.mempool_size += 1
|
|
asset_unlock_tx_full = self.create_assetunlock(301, self.get_credit_pool_balance(), pubkey)
|
|
self.check_mempool_result(tx=asset_unlock_tx_full, result_expected={'allowed': True, 'fees': {'base': Decimal(str(tiny_amount / COIN))}})
|
|
|
|
txid_in_block = self.send_tx(asset_unlock_tx_full)
|
|
node.generate(1)
|
|
self.sync_all()
|
|
self.log.info("Check txid_in_block was mined...")
|
|
block = node.getblock(node.getbestblockhash())
|
|
assert txid_in_block in block['tx']
|
|
self.validate_credit_pool_balance(0)
|
|
|
|
self.log.info("Fast forward to the next day to reset all current unlock limits...")
|
|
self.slowly_generate_batch(blocks_in_one_day + 1)
|
|
self.mine_quorum(llmq_type_name="llmq_test_platform", llmq_type=106)
|
|
|
|
total = self.get_credit_pool_balance()
|
|
coins = node_wallet.listunspent()
|
|
while total <= 10_900 * COIN:
|
|
self.log.info(f"Collecting coins in pool... Collected {total}/{10_900 * COIN}")
|
|
coin = coins.pop()
|
|
to_lock = int(coin['amount'] * COIN) - tiny_amount
|
|
if to_lock > 99 * COIN:
|
|
to_lock = 99 * COIN
|
|
total += to_lock
|
|
tx = self.create_assetlock(coin, to_lock, pubkey)
|
|
self.send_tx_simple(tx)
|
|
self.sync_mempools()
|
|
node.generate(1)
|
|
self.sync_all()
|
|
credit_pool_balance_1 = self.get_credit_pool_balance()
|
|
assert_greater_than(credit_pool_balance_1, 10_900 * COIN)
|
|
limit_amount_1 = 1000 * COIN
|
|
# take most of limit by one big tx for faster testing and
|
|
# create several tiny withdrawal with exactly 1 *invalid* / causes spend above limit tx
|
|
withdrawals = [600 * COIN, 131 * COIN, 131 * COIN, 131 * COIN, 131 * COIN]
|
|
amount_to_withdraw_1 = sum(withdrawals)
|
|
index = 400
|
|
for next_amount in withdrawals:
|
|
index += 1
|
|
asset_unlock_tx = self.create_assetunlock(index, next_amount, pubkey)
|
|
self.send_tx_simple(asset_unlock_tx)
|
|
if index == 401:
|
|
self.sync_mempools()
|
|
node.generate(1)
|
|
|
|
self.sync_mempools()
|
|
node.generate(1)
|
|
self.sync_all()
|
|
self.log.info(f"MN_RR status: {get_bip9_details(node, 'mn_rr')}")
|
|
|
|
new_total = self.get_credit_pool_balance()
|
|
amount_actually_withdrawn = total - new_total
|
|
block = node.getblock(node.getbestblockhash())
|
|
self.log.info("Testing that we tried to withdraw more than we could...")
|
|
assert_greater_than(amount_to_withdraw_1, amount_actually_withdrawn)
|
|
self.log.info("Checking that we tried to withdraw more than the limit...")
|
|
assert_greater_than(amount_to_withdraw_1, limit_amount_1)
|
|
self.log.info("Checking we didn't actually withdraw more than allowed by the limit...")
|
|
assert_greater_than_or_equal(limit_amount_1, amount_actually_withdrawn)
|
|
assert_equal(amount_actually_withdrawn, 993 * COIN)
|
|
node.generate(1)
|
|
self.sync_all()
|
|
self.log.info("Checking that exactly 1 tx stayed in mempool...")
|
|
self.mempool_size = 1
|
|
self.check_mempool_size()
|
|
|
|
assert_equal(new_total, self.get_credit_pool_balance())
|
|
self.log.info("Fast forward to next day again...")
|
|
self.slowly_generate_batch(blocks_in_one_day - 2)
|
|
self.log.info("Checking mempool is empty now...")
|
|
self.mempool_size = 0
|
|
self.check_mempool_size()
|
|
|
|
self.log.info("Creating new asset-unlock tx. It should be mined exactly 1 block after")
|
|
credit_pool_balance_2 = self.get_credit_pool_balance()
|
|
limit_amount_2 = credit_pool_balance_2 // 10
|
|
index += 1
|
|
asset_unlock_tx = self.create_assetunlock(index, limit_amount_2, pubkey)
|
|
self.send_tx(asset_unlock_tx)
|
|
node.generate(1)
|
|
self.sync_all()
|
|
assert_equal(new_total, self.get_credit_pool_balance())
|
|
node.generate(1)
|
|
self.sync_all()
|
|
new_total -= limit_amount_2
|
|
assert_equal(new_total, self.get_credit_pool_balance())
|
|
self.log.info("Trying to withdraw more... expecting to fail")
|
|
index += 1
|
|
asset_unlock_tx = self.create_assetunlock(index, COIN * 100, pubkey)
|
|
self.send_tx(asset_unlock_tx)
|
|
node.generate(1)
|
|
self.sync_all()
|
|
|
|
tip = self.nodes[0].getblockcount()
|
|
indexes_statuses_no_height = self.nodes[0].getassetunlockstatuses(["101", "102", "103"])
|
|
assert_equal([{'index': 101, 'status': 'mined'}, {'index': 102, 'status': 'mined'}, {'index': 103, 'status': 'unknown'}], indexes_statuses_no_height)
|
|
indexes_statuses_height = self.nodes[0].getassetunlockstatuses(["101", "102", "103"], tip)
|
|
assert_equal([{'index': 101, 'status': 'chainlocked'}, {'index': 102, 'status': 'chainlocked'}, {'index': 103, 'status': 'unknown'}], indexes_statuses_height)
|
|
|
|
|
|
self.log.info("generate many blocks to be sure that mempool is empty after expiring txes...")
|
|
self.slowly_generate_batch(60)
|
|
self.log.info("Checking that credit pool is not changed...")
|
|
assert_equal(new_total, self.get_credit_pool_balance())
|
|
self.check_mempool_size()
|
|
|
|
|
|
def test_mn_rr(self, node_wallet, node, pubkey):
|
|
self.log.info("Activate mn_rr...")
|
|
locked = self.get_credit_pool_balance()
|
|
self.activate_mn_rr(expected_activation_height=node.getblockcount() + 12 * 3)
|
|
self.log.info(f'height: {node.getblockcount()} credit: {self.get_credit_pool_balance()}')
|
|
assert_equal(locked, self.get_credit_pool_balance())
|
|
|
|
bt = node.getblocktemplate()
|
|
platform_reward = bt['masternode'][0]['amount']
|
|
assert_equal(bt['masternode'][0]['script'], '6a') # empty OP_RETURN
|
|
owner_reward = bt['masternode'][1]['amount']
|
|
operator_reward = bt['masternode'][2]['amount'] if len(bt['masternode']) == 3 else 0
|
|
all_mn_rewards = platform_reward + owner_reward + operator_reward
|
|
assert_equal(all_mn_rewards, bt['coinbasevalue'] * 3 // 4) # 75/25 mn/miner reward split
|
|
assert_equal(platform_reward, all_mn_rewards * 375 // 1000) # 0.375 platform share
|
|
assert_equal(platform_reward, 31916328)
|
|
assert_equal(locked, self.get_credit_pool_balance())
|
|
node.generate(1)
|
|
self.sync_all()
|
|
locked += platform_reward
|
|
assert_equal(locked, self.get_credit_pool_balance())
|
|
|
|
coins = node_wallet.listunspent(query_options={'minimumAmount': 1})
|
|
coin = coins.pop()
|
|
self.send_tx(self.create_assetlock(coin, COIN, pubkey))
|
|
locked += platform_reward + COIN
|
|
node.generate(1)
|
|
self.sync_all()
|
|
assert_equal(locked, self.get_credit_pool_balance())
|
|
|
|
|
|
if __name__ == '__main__':
|
|
AssetLocksTest().main()
|