def _test_generateblocks(self, blocks):
assert blocks >= 2
print("Test generating", blocks, 'blocks')
daemon = Daemon()
# check info/height before generating blocks
res_info = daemon.get_info()
height = res_info.height
prev_block = res_info.top_block_hash
res_height = daemon.get_height()
assert res_height.height == height
assert int(res_info.wide_cumulative_difficulty) == (
res_info.cumulative_difficulty_top64 <<
64) + res_info.cumulative_difficulty
cumulative_difficulty = int(res_info.wide_cumulative_difficulty)
# we should not see a block at height
ok = False
try:
daemon.getblock(height)
except:
ok = True
assert ok
# generate blocks
res_generateblocks = daemon.generateblocks(
'42ey1afDFnn4886T7196doS9GPMzexD9gXpsZJDwVjeRVdFCSoHnv7KPbBeGpzJBzHRCAs9UxqeoyFQMYbqSWYTfJJQAWDm',
blocks)
# check info/height after generateblocks blocks
assert res_generateblocks.height == height + blocks - 1
res_info = daemon.get_info()
assert res_info.height == height + blocks
assert res_info.top_block_hash != prev_block
res_height = daemon.get_height()
assert res_height.height == height + blocks
# get the blocks, check they have the right height
res_getblock = []
for n in range(blocks):
res_getblock.append(daemon.getblock(height + n))
block_header = res_getblock[n].block_header
assert abs(block_header.timestamp -
time.time()) < 10 # within 10 seconds
assert block_header.height == height + n
assert block_header.orphan_status == False
assert block_header.depth == blocks - n - 1
assert block_header.prev_hash == prev_block, prev_block
assert int(block_header.wide_difficulty) == (
block_header.difficulty_top64 << 64) + block_header.difficulty
assert int(block_header.wide_cumulative_difficulty) == (
block_header.cumulative_difficulty_top64 <<
64) + block_header.cumulative_difficulty
assert block_header.reward >= 600000000000 # tail emission
cumulative_difficulty += int(block_header.wide_difficulty)
assert cumulative_difficulty == int(
block_header.wide_cumulative_difficulty)
assert block_header.block_size > 0
assert block_header.block_weight >= block_header.block_size
assert block_header.long_term_weight > 0
prev_block = block_header.hash
# we should not see a block after that
ok = False
try:
daemon.getblock(height + blocks)
except:
ok = True
assert ok
# getlastblockheader and by height/hash should return the same block
res_getlastblockheader = daemon.getlastblockheader()
assert res_getlastblockheader.block_header == block_header
res_getblockheaderbyhash = daemon.getblockheaderbyhash(prev_block)
assert res_getblockheaderbyhash.block_header == block_header
res_getblockheaderbyheight = daemon.getblockheaderbyheight(height +
blocks - 1)
assert res_getblockheaderbyheight.block_header == block_header
# getting a block template after that should have the right height, etc
res_getblocktemplate = daemon.getblocktemplate(
'42ey1afDFnn4886T7196doS9GPMzexD9gXpsZJDwVjeRVdFCSoHnv7KPbBeGpzJBzHRCAs9UxqeoyFQMYbqSWYTfJJQAWDm'
)
assert res_getblocktemplate.height == height + blocks
assert res_getblocktemplate.reserved_offset > 0
assert res_getblocktemplate.prev_hash == res_info.top_block_hash
assert res_getblocktemplate.expected_reward >= 600000000000
assert len(res_getblocktemplate.blocktemplate_blob) > 0
assert len(res_getblocktemplate.blockhashing_blob) > 0
assert int(res_getblocktemplate.wide_difficulty) == (
res_getblocktemplate.difficulty_top64 <<
64) + res_getblocktemplate.difficulty
# diff etc should be the same
assert res_getblocktemplate.prev_hash == res_info.top_block_hash
res_getlastblockheader = daemon.getlastblockheader()
# pop a block
res_popblocks = daemon.pop_blocks(1)
assert res_popblocks.height == height + blocks - 1
res_info = daemon.get_info()
assert res_info.height == height + blocks - 1
# getlastblockheader and by height/hash should return the previous block
block_header = res_getblock[blocks - 2].block_header
block_header.depth = 0 # this will be different, ignore it
res_getlastblockheader = daemon.getlastblockheader()
assert res_getlastblockheader.block_header == block_header
res_getblockheaderbyhash = daemon.getblockheaderbyhash(
block_header.hash)
assert res_getblockheaderbyhash.block_header == block_header
res_getblockheaderbyheight = daemon.getblockheaderbyheight(height +
blocks - 2)
assert res_getblockheaderbyheight.block_header == block_header
# we should not see the popped block anymore
ok = False
try:
daemon.getblock(height + blocks - 1)
except:
ok = True
assert ok
# get transactions
res = daemon.get_info()
assert res.height == height + blocks - 1
nblocks = height + blocks - 1
res = daemon.getblockheadersrange(0, nblocks - 1)
assert len(res.headers) == nblocks
assert res.headers[-1] == block_header
txids = [x.miner_tx_hash for x in res.headers]
res = daemon.get_transactions(txs_hashes=txids)
assert len(res.txs) == nblocks
assert not 'missed_txs' in res or len(res.missed_txs) == 0
running_output_index = 0
for i in range(len(txids)):
tx = res.txs[i]
assert tx.tx_hash == txids[i]
assert not tx.double_spend_seen
assert not tx.in_pool
assert tx.block_height == i
if i > 0:
for idx in tx.output_indices:
assert idx == running_output_index
running_output_index += 1
res_out = daemon.get_outs([{
'amount': 0,
'index': idx
} for idx in tx.output_indices],
get_txid=True)
assert len(res_out.outs) == len(tx.output_indices)
for out in res_out.outs:
assert len(out.key) == 64
assert len(out.mask) == 64
assert not out.unlocked
assert out.height == i
assert out.txid == txids[i]
for i in range(height + nblocks - 1):
res_sum = daemon.get_coinbase_tx_sum(i, 1)
res_header = daemon.getblockheaderbyheight(i)
assert res_sum.emission_amount == res_header.block_header.reward
res = daemon.get_coinbase_tx_sum(0, 1)
assert res.emission_amount == 17592186044415
assert res.fee_amount == 0
sum_blocks = height + nblocks - 1
res = daemon.get_coinbase_tx_sum(0, sum_blocks)
extrapolated = 17592186044415 + 17592186044415 * 2 * (sum_blocks - 1)
assert res.emission_amount < extrapolated and res.emission_amount > extrapolated - 1e12
assert res.fee_amount == 0
sum_blocks_emission = res.emission_amount
res = daemon.get_coinbase_tx_sum(1, sum_blocks)
assert res.emission_amount == sum_blocks_emission - 17592186044415
assert res.fee_amount == 0
res = daemon.get_output_distribution([0, 1, 17592186044415], 0, 0)
assert len(res.distributions) == 3
for a in range(3):
assert res.distributions[a].amount == [0, 1, 17592186044415][a]
assert res.distributions[a].start_height == 0
assert res.distributions[a].base == 0
assert len(
res.distributions[a].distribution) == height + nblocks - 1
assert res.distributions[a].binary == False
for i in range(height + nblocks - 1):
assert res.distributions[a].distribution[i] == (
1 if i > 0 and a == 0 else 1 if a == 2 and i == 0 else 0)
res = daemon.get_output_histogram([], min_count=0, max_count=0)
assert len(res.histogram) == 2
for i in range(2):
assert res.histogram[i].amount in [0, 17592186044415]
assert res.histogram[i].total_instances in [
height + nblocks - 2, 1
]
assert res.histogram[i].unlocked_instances == 0
assert res.histogram[i].recent_instances == 0
def test_randomx(self):
print("Test RandomX")
daemon = Daemon()
wallet = Wallet()
res = daemon.get_height()
daemon.pop_blocks(res.height - 1)
daemon.flush_txpool()
epoch = int(os.environ['SEEDHASH_EPOCH_BLOCKS'])
lag = int(os.environ['SEEDHASH_EPOCH_LAG'])
address = '42ey1afDFnn4886T7196doS9GPMzexD9gXpsZJDwVjeRVdFCSoHnv7KPbBeGpzJBzHRCAs9UxqeoyFQMYbqSWYTfJJQAWDm'
# check we can generate blocks, and that the seed hash changes when expected
res = daemon.getblocktemplate(address)
first_seed_hash = res.seed_hash
daemon.generateblocks(address, 1 + lag)
res = daemon.mining_status()
assert res.active == False
assert res.pow_algorithm == 'RandomX'
res = daemon.getblocktemplate(address)
seed_hash = res.seed_hash
t0 = time.time()
daemon.generateblocks(address, epoch - 3)
t0 = time.time() - t0
res = daemon.get_info()
assert res.height == lag + epoch - 1
res = daemon.getblocktemplate(address)
assert seed_hash == res.seed_hash
t0 = time.time()
daemon.generateblocks(address, 1)
t0 = time.time() - t0
res = daemon.get_info()
assert res.height == lag + epoch
daemon.generateblocks(address, 1)
res = daemon.getblocktemplate(address)
assert seed_hash != res.seed_hash
new_seed_hash = res.seed_hash
t0 = time.time()
daemon.generateblocks(address, epoch - 1)
t0 = time.time() - t0
res = daemon.getblocktemplate(address)
assert new_seed_hash == res.seed_hash
daemon.generateblocks(address, 1)
res = daemon.getblocktemplate(address)
assert new_seed_hash != res.seed_hash
new_seed_hash = res.seed_hash
t0 = time.time()
daemon.generateblocks(address, epoch - 1)
t0 = time.time() - t0
res = daemon.getblocktemplate(address)
assert new_seed_hash == res.seed_hash
daemon.generateblocks(address, 1)
res = daemon.getblocktemplate(address)
assert new_seed_hash != res.seed_hash
#print('First mining: ' + str(t0))
# pop all these blocks, and feed them again to monerod
print('Recreating the chain')
res = daemon.get_info()
height = res.height
assert height == lag + epoch * 3 + 1
block_hashes = [
x.hash for x in daemon.getblockheadersrange(0, height - 1).headers
]
assert len(block_hashes) == height
blocks = []
for i in range(len(block_hashes)):
res = daemon.getblock(height=i)
assert res.block_header.hash == block_hashes[i]
blocks.append(res.blob)
daemon.pop_blocks(height)
res = daemon.get_info()
assert res.height == 1
res = daemon.getblocktemplate(address)
assert first_seed_hash == res.seed_hash
t0 = time.time()
for h in range(len(block_hashes)):
res = daemon.submitblock(blocks[h])
t0 = time.time() - t0
res = daemon.get_info()
assert height == res.height
res = daemon.getblocktemplate(address)
assert new_seed_hash != res.seed_hash
res = daemon.pop_blocks(1)
res = daemon.getblocktemplate(address)
assert new_seed_hash == res.seed_hash
#print('Submit: ' + str(t0))
# start mining from the genesis block again
print('Mining from genesis block again')
res = daemon.get_height()
top_hash = res.hash
res = daemon.getblockheaderbyheight(0)
genesis_block_hash = res.block_header.hash
t0 = time.time()
daemon.generateblocks(address,
height - 2,
prev_block=genesis_block_hash)
t0 = time.time() - t0
res = daemon.get_info()
assert res.height == height - 1
assert res.top_block_hash == top_hash
#print('Second mining: ' + str(t0))
# that one will cause a huge reorg
print('Adding one to reorg')
res = daemon.generateblocks(address, 1)
assert len(res.blocks) == 1
new_top_hash = res.blocks[0]
res = daemon.get_info()
assert res.height == height
assert res.top_block_hash == new_top_hash
def _test_generateblocks(self, blocks):
assert blocks >= 2
print "Test generating", blocks, 'blocks'
daemon = Daemon()
# check info/height before generating blocks
res_info = daemon.get_info()
height = res_info.height
prev_block = res_info.top_block_hash
res_height = daemon.get_height()
assert res_height.height == height
assert int(res_info.wide_cumulative_difficulty) == (res_info.cumulative_difficulty_top64 << 64) + res_info.cumulative_difficulty
cumulative_difficulty = int(res_info.wide_cumulative_difficulty)
# we should not see a block at height
ok = False
try: daemon.getblock(height)
except: ok = True
assert ok
# generate blocks
res_generateblocks = daemon.generateblocks('42ey1afDFnn4886T7196doS9GPMzexD9gXpsZJDwVjeRVdFCSoHnv7KPbBeGpzJBzHRCAs9UxqeoyFQMYbqSWYTfJJQAWDm', blocks)
# check info/height after generateblocks blocks
assert res_generateblocks.height == height + blocks - 1
res_info = daemon.get_info()
assert res_info.height == height + blocks
assert res_info.top_block_hash != prev_block
res_height = daemon.get_height()
assert res_height.height == height + blocks
# get the blocks, check they have the right height
res_getblock = []
for n in range(blocks):
res_getblock.append(daemon.getblock(height + n))
block_header = res_getblock[n].block_header
assert abs(block_header.timestamp - time.time()) < 10 # within 10 seconds
assert block_header.height == height + n
assert block_header.orphan_status == False
assert block_header.depth == blocks - n - 1
assert block_header.prev_hash == prev_block, prev_block
assert int(block_header.wide_difficulty) == (block_header.difficulty_top64 << 64) + block_header.difficulty
assert int(block_header.wide_cumulative_difficulty) == (block_header.cumulative_difficulty_top64 << 64) + block_header.cumulative_difficulty
assert block_header.reward >= 600000000000 # tail emission
cumulative_difficulty += int(block_header.wide_difficulty)
assert cumulative_difficulty == int(block_header.wide_cumulative_difficulty)
assert block_header.block_size > 0
assert block_header.block_weight >= block_header.block_size
assert block_header.long_term_weight > 0
prev_block = block_header.hash
# we should not see a block after that
ok = False
try: daemon.getblock(height + blocks)
except: ok = True
assert ok
# getlastblockheader and by height/hash should return the same block
res_getlastblockheader = daemon.getlastblockheader()
assert res_getlastblockheader.block_header == block_header
res_getblockheaderbyhash = daemon.getblockheaderbyhash(prev_block)
assert res_getblockheaderbyhash.block_header == block_header
res_getblockheaderbyheight = daemon.getblockheaderbyheight(height + blocks - 1)
assert res_getblockheaderbyheight.block_header == block_header
# getting a block template after that should have the right height, etc
res_getblocktemplate = daemon.getblocktemplate('42ey1afDFnn4886T7196doS9GPMzexD9gXpsZJDwVjeRVdFCSoHnv7KPbBeGpzJBzHRCAs9UxqeoyFQMYbqSWYTfJJQAWDm')
assert res_getblocktemplate.height == height + blocks
assert res_getblocktemplate.reserved_offset > 0
assert res_getblocktemplate.prev_hash == res_info.top_block_hash
assert res_getblocktemplate.expected_reward >= 600000000000
assert len(res_getblocktemplate.blocktemplate_blob) > 0
assert len(res_getblocktemplate.blockhashing_blob) > 0
assert int(res_getblocktemplate.wide_difficulty) == (res_getblocktemplate.difficulty_top64 << 64) + res_getblocktemplate.difficulty
# diff etc should be the same
assert res_getblocktemplate.prev_hash == res_info.top_block_hash
res_getlastblockheader = daemon.getlastblockheader()
# pop a block
res_popblocks = daemon.pop_blocks(1)
assert res_popblocks.height == height + blocks - 1
res_info = daemon.get_info()
assert res_info.height == height + blocks - 1
# getlastblockheader and by height/hash should return the previous block
block_header = res_getblock[blocks - 2].block_header
block_header.depth = 0 # this will be different, ignore it
res_getlastblockheader = daemon.getlastblockheader()
assert res_getlastblockheader.block_header == block_header
res_getblockheaderbyhash = daemon.getblockheaderbyhash(block_header.hash)
assert res_getblockheaderbyhash.block_header == block_header
res_getblockheaderbyheight = daemon.getblockheaderbyheight(height + blocks - 2)
assert res_getblockheaderbyheight.block_header == block_header
# we should not see the popped block anymore
ok = False
try: daemon.getblock(height + blocks - 1)
except: ok = True
assert ok
