def mine(self, via_daemon):
print("Test mining via " + ("daemon" if via_daemon else "wallet"))
cores_init = multiprocessing.cpu_count() # RX init uses all cores
cores_mine = 1 # Mining uses a parametric number of cores
is_mining_measurent = 'MINING_NO_MEASUREMENT' not in os.environ
if is_mining_measurent: # A dynamic calculation of the CPU power requested
time_pi_single_cpu = self.measure_cpu_power_get_time(cores_mine)
time_pi_all_cores = self.measure_cpu_power_get_time(cores_init)
# This is the last measurement, since it takes very little time and can be placed timewise-closer to the mining itself.
available_ram = self.get_available_ram(
) # So far no ideas how to use this var, other than printing it
start = monotonic.monotonic()
daemon = Daemon()
wallet = Wallet()
# check info/height/balance before generating blocks
res_info = daemon.get_info()
initial_height = res_info.height
res_getbalance = wallet.get_balance()
prev_balance = res_getbalance.balance
res_status = daemon.mining_status()
if via_daemon:
res = daemon.start_mining(
'42ey1afDFnn4886T7196doS9GPMzexD9gXpsZJDwVjeRVdFCSoHnv7KPbBeGpzJBzHRCAs9UxqeoyFQMYbqSWYTfJJQAWDm',
threads_count=1)
else:
res = wallet.start_mining(threads_count=cores_mine)
res_status = daemon.mining_status()
assert res_status.active == True
assert res_status.threads_count == cores_mine
assert res_status.address == '42ey1afDFnn4886T7196doS9GPMzexD9gXpsZJDwVjeRVdFCSoHnv7KPbBeGpzJBzHRCAs9UxqeoyFQMYbqSWYTfJJQAWDm'
assert res_status.is_background_mining_enabled == False
assert res_status.block_reward >= 600000000000
# wait till we mined a few of them
target_height = initial_height + 5
height = initial_height
if not is_mining_measurent:
timeout_init = 600
timeout_mine = 300
else:
"""
Randomx init has high variance on CI machines due to noisy neighbors,
taking up resources in parallel (including by our own jobs).
Mining is organized in the following scheme:
1) first loop's pass: RandomX init and mining
2) every next pass: only mining
Pass 1) takes much more time than pass 2)
Pass 1) uses all cores, pass 2) just one (currently)
For the above reasons both passes need separate timeouts and adjustments.
After the first pass, the timeout is being reset to a lower value.
"""
def calc_timeout(seconds_constant, time_pi, cores):
"""
The time it took to calculate pi under certain conditions
is proportional to the time it will take to calculate the real job.
The number of cores used decreases the time almost linearly.
"""
timeout = float(seconds_constant) * time_pi / float(cores)
return timeout
timeout_base_init = 60 # RX init needs more time
timeout_base_mine = 20
timeout_init = calc_timeout(timeout_base_init, time_pi_all_cores,
cores_init)
timeout_mine = calc_timeout(timeout_base_mine, time_pi_single_cpu,
cores_mine)
msg_timeout_src = "adjusted for the currently available CPU power" if is_mining_measurent else "selected to have the default value"
msg = "Timeout for {} {}, is {:.1f} s"
self.print_mining_info(
msg.format("init, ", msg_timeout_src, timeout_init))
self.print_mining_info(
msg.format("mining,", msg_timeout_src, timeout_mine))
timeout = timeout_init
rx_inited = False # Gets initialized in the first pass of the below loop
while height < target_height:
seen_height = height
for _ in range(int(math.ceil(timeout))):
time.sleep(1)
seconds_passed = monotonic.monotonic() - start
height = daemon.get_info().height
if height > seen_height:
break
else:
assert False, 'Failed to mine successor to block %d (initial block = %d) after %d s. RX initialized = %r' % (
seen_height, initial_height, round(seconds_passed),
rx_inited)
if not rx_inited:
rx_inited = True
timeout = timeout_mine # Resetting the timeout after first mined block and RX init
self.print_time_taken(start, "RX init + mining 1st block")
else:
self.print_time_taken(start, "mining iteration")
self.print_time_taken(start, "mining total")
if via_daemon:
res = daemon.stop_mining()
else:
res = wallet.stop_mining()
res_status = daemon.mining_status()
assert res_status.active == False
res_info = daemon.get_info()
new_height = res_info.height
wallet.refresh()
res_getbalance = wallet.get_balance()
balance = res_getbalance.balance
assert balance >= prev_balance + (new_height -
initial_height) * 600000000000
if via_daemon:
res = daemon.start_mining(
'42ey1afDFnn4886T7196doS9GPMzexD9gXpsZJDwVjeRVdFCSoHnv7KPbBeGpzJBzHRCAs9UxqeoyFQMYbqSWYTfJJQAWDm',
threads_count=1,
do_background_mining=True)
else:
res = wallet.start_mining(threads_count=1,
do_background_mining=True)
res_status = daemon.mining_status()
assert res_status.active == True
assert res_status.threads_count == 1
assert res_status.address == '42ey1afDFnn4886T7196doS9GPMzexD9gXpsZJDwVjeRVdFCSoHnv7KPbBeGpzJBzHRCAs9UxqeoyFQMYbqSWYTfJJQAWDm'
assert res_status.is_background_mining_enabled == True
assert res_status.block_reward >= 600000000000
# don't wait, might be a while if the machine is busy, which it probably is
if via_daemon:
res = daemon.stop_mining()
else:
res = wallet.stop_mining()
res_status = daemon.mining_status()
assert res_status.active == False
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 mine(self):
print("Test mining")
daemon = Daemon()
wallet = Wallet()
# check info/height/balance before generating blocks
res_info = daemon.get_info()
prev_height = res_info.height
res_getbalance = wallet.get_balance()
prev_balance = res_getbalance.balance
res_status = daemon.mining_status()
res = daemon.start_mining(
'42ey1afDFnn4886T7196doS9GPMzexD9gXpsZJDwVjeRVdFCSoHnv7KPbBeGpzJBzHRCAs9UxqeoyFQMYbqSWYTfJJQAWDm',
threads_count=1)
res_status = daemon.mining_status()
assert res_status.active == True
assert res_status.threads_count == 1
assert res_status.address == '42ey1afDFnn4886T7196doS9GPMzexD9gXpsZJDwVjeRVdFCSoHnv7KPbBeGpzJBzHRCAs9UxqeoyFQMYbqSWYTfJJQAWDm'
assert res_status.is_background_mining_enabled == False
assert res_status.block_reward >= 600000000000
# wait till we mined a few of them
timeout = 5
timeout_height = prev_height
while True:
time.sleep(1)
res_info = daemon.get_info()
height = res_info.height
if height >= prev_height + 5:
break
if height > timeout_height:
timeout = 5
timeout_height = height
else:
timeout -= 1
assert timeout >= 0
res = daemon.stop_mining()
res_status = daemon.mining_status()
assert res_status.active == False
res_info = daemon.get_info()
new_height = res_info.height
wallet.refresh()
res_getbalance = wallet.get_balance()
balance = res_getbalance.balance
assert balance >= prev_balance + (new_height -
prev_height) * 600000000000
res = daemon.start_mining(
'42ey1afDFnn4886T7196doS9GPMzexD9gXpsZJDwVjeRVdFCSoHnv7KPbBeGpzJBzHRCAs9UxqeoyFQMYbqSWYTfJJQAWDm',
threads_count=1,
do_background_mining=True)
res_status = daemon.mining_status()
assert res_status.active == True
assert res_status.threads_count == 1
assert res_status.address == '42ey1afDFnn4886T7196doS9GPMzexD9gXpsZJDwVjeRVdFCSoHnv7KPbBeGpzJBzHRCAs9UxqeoyFQMYbqSWYTfJJQAWDm'
assert res_status.is_background_mining_enabled == True
assert res_status.block_reward >= 600000000000
# don't wait, might be a while if the machine is busy, which it probably is
res = daemon.stop_mining()
res_status = daemon.mining_status()
assert res_status.active == False
def mine(self, via_daemon):
print("Test mining via " + ("daemon" if via_daemon else "wallet"))
daemon = Daemon()
wallet = Wallet()
# check info/height/balance before generating blocks
res_info = daemon.get_info()
prev_height = res_info.height
res_getbalance = wallet.get_balance()
prev_balance = res_getbalance.balance
res_status = daemon.mining_status()
if via_daemon:
res = daemon.start_mining('42ey1afDFnn4886T7196doS9GPMzexD9gXpsZJDwVjeRVdFCSoHnv7KPbBeGpzJBzHRCAs9UxqeoyFQMYbqSWYTfJJQAWDm', threads_count = 1)
else:
res = wallet.start_mining(threads_count = 1)
res_status = daemon.mining_status()
assert res_status.active == True
assert res_status.threads_count == 1
assert res_status.address == '42ey1afDFnn4886T7196doS9GPMzexD9gXpsZJDwVjeRVdFCSoHnv7KPbBeGpzJBzHRCAs9UxqeoyFQMYbqSWYTfJJQAWDm'
assert res_status.is_background_mining_enabled == False
assert res_status.block_reward >= 600000000000
# wait till we mined a few of them
target_height = prev_height + 5
height = prev_height
timeout = 60 # randomx is slow to init
while height < target_height:
seen_height = height
for _ in range(timeout):
time.sleep(1)
height = daemon.get_info().height
if height > seen_height:
break
else:
assert False, 'Failed to mine successor to block %d (initial block = %d)' % (seen_height, prev_height)
timeout = 5
if via_daemon:
res = daemon.stop_mining()
else:
res = wallet.stop_mining()
res_status = daemon.mining_status()
assert res_status.active == False
res_info = daemon.get_info()
new_height = res_info.height
wallet.refresh()
res_getbalance = wallet.get_balance()
balance = res_getbalance.balance
assert balance >= prev_balance + (new_height - prev_height) * 600000000000
if via_daemon:
res = daemon.start_mining('42ey1afDFnn4886T7196doS9GPMzexD9gXpsZJDwVjeRVdFCSoHnv7KPbBeGpzJBzHRCAs9UxqeoyFQMYbqSWYTfJJQAWDm', threads_count = 1, do_background_mining = True)
else:
res = wallet.start_mining(threads_count = 1, do_background_mining = True)
res_status = daemon.mining_status()
assert res_status.active == True
assert res_status.threads_count == 1
assert res_status.address == '42ey1afDFnn4886T7196doS9GPMzexD9gXpsZJDwVjeRVdFCSoHnv7KPbBeGpzJBzHRCAs9UxqeoyFQMYbqSWYTfJJQAWDm'
assert res_status.is_background_mining_enabled == True
assert res_status.block_reward >= 600000000000
# don't wait, might be a while if the machine is busy, which it probably is
if via_daemon:
res = daemon.stop_mining()
else:
res = wallet.stop_mining()
res_status = daemon.mining_status()
assert res_status.active == False
def mine(self):
print("Test mining")
daemon = Daemon()
wallet = Wallet()
# check info/height/balance before generating blocks
res_info = daemon.get_info()
prev_height = res_info.height
res_getbalance = wallet.get_balance()
prev_balance = res_getbalance.balance
res_status = daemon.mining_status()
res = daemon.start_mining('42ey1afDFnn4886T7196doS9GPMzexD9gXpsZJDwVjeRVdFCSoHnv7KPbBeGpzJBzHRCAs9UxqeoyFQMYbqSWYTfJJQAWDm', threads_count = 1)
res_status = daemon.mining_status()
assert res_status.active == True
assert res_status.threads_count == 1
assert res_status.address == '42ey1afDFnn4886T7196doS9GPMzexD9gXpsZJDwVjeRVdFCSoHnv7KPbBeGpzJBzHRCAs9UxqeoyFQMYbqSWYTfJJQAWDm'
assert res_status.is_background_mining_enabled == False
assert res_status.block_reward >= 600000000000
# wait till we mined a few of them
timeout = 5
timeout_height = prev_height
while True:
time.sleep(1)
res_info = daemon.get_info()
height = res_info.height
if height >= prev_height + 5:
break
if height > timeout_height:
timeout = 5
timeout_height = height
else:
timeout -= 1
assert timeout >= 0
res = daemon.stop_mining()
res_status = daemon.mining_status()
assert res_status.active == False
res_info = daemon.get_info()
new_height = res_info.height
wallet.refresh()
res_getbalance = wallet.get_balance()
balance = res_getbalance.balance
assert balance >= prev_balance + (new_height - prev_height) * 600000000000
res = daemon.start_mining('42ey1afDFnn4886T7196doS9GPMzexD9gXpsZJDwVjeRVdFCSoHnv7KPbBeGpzJBzHRCAs9UxqeoyFQMYbqSWYTfJJQAWDm', threads_count = 1, do_background_mining = True)
res_status = daemon.mining_status()
assert res_status.active == True
assert res_status.threads_count == 1
assert res_status.address == '42ey1afDFnn4886T7196doS9GPMzexD9gXpsZJDwVjeRVdFCSoHnv7KPbBeGpzJBzHRCAs9UxqeoyFQMYbqSWYTfJJQAWDm'
assert res_status.is_background_mining_enabled == True
assert res_status.block_reward >= 600000000000
# don't wait, might be a while if the machine is busy, which it probably is
res = daemon.stop_mining()
res_status = daemon.mining_status()
assert res_status.active == False
