def submitblock(self):
print("Test submitblock")
daemon = Daemon()
res = daemon.get_height()
height = res.height
res = daemon.generateblocks(
'42ey1afDFnn4886T7196doS9GPMzexD9gXpsZJDwVjeRVdFCSoHnv7KPbBeGpzJBzHRCAs9UxqeoyFQMYbqSWYTfJJQAWDm',
5)
assert len(res.blocks) == 5
hashes = res.blocks
blocks = []
for block_hash in hashes:
res = daemon.getblock(hash=block_hash)
assert len(res.blob) > 0 and len(res.blob) % 2 == 0
blocks.append(res.blob)
res = daemon.get_height()
assert res.height == height + 5
res = daemon.pop_blocks(5)
res = daemon.get_height()
assert res.height == height
for i in range(len(hashes)):
block_hash = hashes[i]
assert len(block_hash) == 64
res = daemon.submitblock(blocks[i])
res = daemon.get_height()
assert res.height == height + i + 1
assert res.hash == block_hash
def reset(self):
print('Resetting blockchain')
daemon = Daemon()
daemon.pop_blocks(1000)
daemon.flush_txpool()
def reset(self):
print('Resetting blockchain')
daemon = Daemon()
res = daemon.get_height()
daemon.pop_blocks(res.height - 1)
daemon.flush_txpool()
def test_get_output_distribution(self):
print("Test get_output_distribution")
daemon = Daemon()
res = daemon.get_output_distribution([0], 0, 0)
assert len(res.distributions) == 1
d = res.distributions[0]
assert d.amount == 0
assert d.base == 0
assert d.binary == False
assert len(d.distribution) == 1
assert d.distribution[0] == 0
res = daemon.generateblocks(
'42ey1afDFnn4886T7196doS9GPMzexD9gXpsZJDwVjeRVdFCSoHnv7KPbBeGpzJBzHRCAs9UxqeoyFQMYbqSWYTfJJQAWDm',
1)
res = daemon.get_output_distribution([0], 0, 0)
assert len(res.distributions) == 1
d = res.distributions[0]
assert d.amount == 0
assert d.base == 0
assert d.binary == False
assert len(d.distribution) == 2
assert d.distribution[0] == 0
assert d.distribution[1] == 1
res = daemon.pop_blocks(1)
res = daemon.get_output_distribution([0], 0, 0)
assert len(res.distributions) == 1
d = res.distributions[0]
assert d.amount == 0
assert d.base == 0
assert d.binary == False
assert len(d.distribution) == 1
assert d.distribution[0] == 0
res = daemon.generateblocks(
'42ey1afDFnn4886T7196doS9GPMzexD9gXpsZJDwVjeRVdFCSoHnv7KPbBeGpzJBzHRCAs9UxqeoyFQMYbqSWYTfJJQAWDm',
3)
res = daemon.get_output_distribution([0], 0, 0, cumulative=True)
assert len(res.distributions) == 1
d = res.distributions[0]
assert d.amount == 0
assert d.base == 0
assert d.binary == False
assert len(d.distribution) == 4
assert d.distribution[0] == 0
assert d.distribution[1] == 1
assert d.distribution[2] == 2
assert d.distribution[3] == 3
# extend
res = daemon.generateblocks(
'42ey1afDFnn4886T7196doS9GPMzexD9gXpsZJDwVjeRVdFCSoHnv7KPbBeGpzJBzHRCAs9UxqeoyFQMYbqSWYTfJJQAWDm',
80)
res = daemon.get_output_distribution([0], 0, 0, cumulative=True)
assert len(res.distributions) == 1
d = res.distributions[0]
assert d.amount == 0
assert d.base == 0
assert d.binary == False
assert len(d.distribution) == 84
for h in range(len(d.distribution)):
assert d.distribution[h] == h
# pop and replace, this will do through the "trim and extend" path
res = daemon.pop_blocks(2)
self.wallet.refresh()
dst = {
'address':
'42ey1afDFnn4886T7196doS9GPMzexD9gXpsZJDwVjeRVdFCSoHnv7KPbBeGpzJBzHRCAs9UxqeoyFQMYbqSWYTfJJQAWDm',
'amount': 1000000000000
}
self.wallet.transfer([dst])
res = daemon.generateblocks(
'42ey1afDFnn4886T7196doS9GPMzexD9gXpsZJDwVjeRVdFCSoHnv7KPbBeGpzJBzHRCAs9UxqeoyFQMYbqSWYTfJJQAWDm',
1)
for step in range(
3
): # the second will be cached, the third will also be cached, but we get it in non-cumulative mode
res = daemon.get_output_distribution([0],
0,
0,
cumulative=step < 3)
assert len(res.distributions) == 1
d = res.distributions[0]
assert d.amount == 0
assert d.base == 0
assert d.binary == False
assert len(d.distribution) == 83
for h in range(len(d.distribution)):
assert d.distribution[h] == (h if step < 3 else 1) + (
2 if h == len(d.distribution) - 1 else 0)
# start at 0, end earlier
res = daemon.get_output_distribution([0], 0, 40, cumulative=True)
assert len(res.distributions) == 1
d = res.distributions[0]
assert d.amount == 0
assert d.base == 0
assert d.binary == False
assert len(d.distribution) == 41
for h in range(len(d.distribution)):
assert d.distribution[h] == h
# start after 0, end earlier
res = daemon.get_output_distribution([0], 10, 20, cumulative=True)
assert len(res.distributions) == 1
d = res.distributions[0]
assert d.amount == 0
assert d.base == 9
assert d.binary == False
assert len(d.distribution) == 11
for h in range(len(d.distribution)):
assert d.distribution[h] == 10 + h
# straddling up
res = daemon.get_output_distribution([0], 15, 25, cumulative=True)
assert len(res.distributions) == 1
d = res.distributions[0]
assert d.amount == 0
assert d.base == 14
assert d.binary == False
assert len(d.distribution) == 11
for h in range(len(d.distribution)):
assert d.distribution[h] == 15 + h
# straddling down
res = daemon.get_output_distribution([0], 8, 18, cumulative=True)
assert len(res.distributions) == 1
d = res.distributions[0]
assert d.amount == 0
assert d.base == 7
assert d.binary == False
assert len(d.distribution) == 11
for h in range(len(d.distribution)):
assert d.distribution[h] == 8 + h
# encompassing
res = daemon.get_output_distribution([0], 5, 20, cumulative=True)
assert len(res.distributions) == 1
d = res.distributions[0]
assert d.amount == 0
assert d.base == 4
assert d.binary == False
assert len(d.distribution) == 16
for h in range(len(d.distribution)):
assert d.distribution[h] == 5 + h
# single
res = daemon.get_output_distribution([0], 2, 2, cumulative=True)
assert len(res.distributions) == 1
d = res.distributions[0]
assert d.amount == 0
assert d.base == 1
assert d.binary == False
assert len(d.distribution) == 1
assert d.distribution[0] == 2
# a non existent amount
res = daemon.get_output_distribution([1], 0, 0)
assert len(res.distributions) == 1
d = res.distributions[0]
assert d.amount == 1
assert d.base == 0
assert d.binary == False
assert len(d.distribution) == 83
for h in range(len(d.distribution)):
assert d.distribution[h] == 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 reset(self):
print('Resetting blockchain')
daemon = Daemon()
daemon.pop_blocks(1000)
daemon.flush_txpool()
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 check_txpool(self):
daemon = Daemon()
wallet = Wallet()
res = daemon.get_info()
height = res.height
txpool_size = res.tx_pool_size
txes = self.create_txes(
'46r4nYSevkfBUMhuykdK3gQ98XDqDTYW1hNLaXNvjpsJaSbNtdXh1sKMsdVgqkaihChAzEy29zEDPMR3NHQvGoZCLGwTerK',
5)
res = daemon.get_info()
assert res.tx_pool_size == txpool_size + 5
txpool_size = res.tx_pool_size
res = daemon.get_transaction_pool()
assert len(res.transactions) == txpool_size
for txid in txes.keys():
x = [x for x in res.transactions if x.id_hash == txid]
assert len(x) == 1
x = x[0]
assert x.kept_by_block == False
assert x.last_failed_id_hash == '0' * 64
assert x.double_spend_seen == False
assert x.weight >= x.blob_size
assert x.blob_size * 2 == len(txes[txid].tx_blob)
assert x.fee == txes[txid].fee
assert x.tx_blob == txes[txid].tx_blob
res = daemon.get_transaction_pool_hashes()
assert sorted(res.tx_hashes) == sorted(txes.keys())
print('Flushing 2 transactions')
txes_keys = list(txes.keys())
daemon.flush_txpool([txes_keys[1], txes_keys[3]])
res = daemon.get_transaction_pool()
assert len(res.transactions) == txpool_size - 2
assert len([x for x in res.transactions
if x.id_hash == txes_keys[1]]) == 0
assert len([x for x in res.transactions
if x.id_hash == txes_keys[3]]) == 0
new_keys = list(txes.keys())
new_keys.remove(txes_keys[1])
new_keys.remove(txes_keys[3])
res = daemon.get_transaction_pool_hashes()
assert sorted(res.tx_hashes) == sorted(new_keys)
print('Flushing unknown transactions')
unknown_txids = ['1' * 64, '2' * 64, '3' * 64]
daemon.flush_txpool(unknown_txids)
res = daemon.get_transaction_pool()
assert len(res.transactions) == txpool_size - 2
print('Mining transactions')
daemon.generateblocks(
'42ey1afDFnn4886T7196doS9GPMzexD9gXpsZJDwVjeRVdFCSoHnv7KPbBeGpzJBzHRCAs9UxqeoyFQMYbqSWYTfJJQAWDm',
1)
res = daemon.get_transaction_pool()
assert not 'transactions' in res or len(
res.transactions) == txpool_size - 5
res = daemon.get_transaction_pool_hashes()
assert not 'tx_hashes' in res or len(res.tx_hashes) == 0
print('Popping block')
daemon.pop_blocks(1)
res = daemon.get_transaction_pool_hashes()
assert sorted(res.tx_hashes) == sorted(new_keys)
res = daemon.get_transaction_pool()
assert len(res.transactions) == txpool_size - 2
for txid in new_keys:
x = [x for x in res.transactions if x.id_hash == txid]
assert len(x) == 1
x = x[0]
assert x.kept_by_block == True
assert x.last_failed_id_hash == '0' * 64
assert x.double_spend_seen == False
assert x.weight >= x.blob_size
assert x.blob_size * 2 == len(txes[txid].tx_blob)
assert x.fee == txes[txid].fee
assert x.tx_blob == txes[txid].tx_blob
def check_txpool(self):
daemon = Daemon()
wallet = Wallet()
res = daemon.get_info()
height = res.height
txpool_size = res.tx_pool_size
self.check_empty_pool()
txes = self.create_txes('46r4nYSevkfBUMhuykdK3gQ98XDqDTYW1hNLaXNvjpsJaSbNtdXh1sKMsdVgqkaihChAzEy29zEDPMR3NHQvGoZCLGwTerK', 5)
res = daemon.get_info()
assert res.tx_pool_size == txpool_size + 5
txpool_size = res.tx_pool_size
res = daemon.get_transaction_pool()
assert len(res.transactions) == txpool_size
total_bytes = 0
total_fee = 0
min_bytes = 99999999999999
max_bytes = 0
for txid in txes.keys():
x = [x for x in res.transactions if x.id_hash == txid]
assert len(x) == 1
x = x[0]
assert x.kept_by_block == False
assert x.last_failed_id_hash == '0'*64
assert x.double_spend_seen == False
assert x.weight >= x.blob_size
assert x.blob_size * 2 == len(txes[txid].tx_blob)
assert x.fee == txes[txid].fee
assert x.tx_blob == txes[txid].tx_blob
total_bytes += x.blob_size
total_fee += x.fee
min_bytes = min(min_bytes, x.blob_size)
max_bytes = max(max_bytes, x.blob_size)
res = daemon.get_transaction_pool_hashes()
assert sorted(res.tx_hashes) == sorted(txes.keys())
res = daemon.get_transaction_pool_stats()
assert res.pool_stats.bytes_total == total_bytes
assert res.pool_stats.bytes_min == min_bytes
assert res.pool_stats.bytes_max == max_bytes
assert res.pool_stats.bytes_med >= min_bytes and res.pool_stats.bytes_med <= max_bytes
assert res.pool_stats.fee_total == total_fee
assert res.pool_stats.txs_total == len(txes)
assert res.pool_stats.num_failing == 0
assert res.pool_stats.num_10m == 0
assert res.pool_stats.num_not_relayed == 0
assert res.pool_stats.num_double_spends == 0
print('Flushing 2 transactions')
txes_keys = list(txes.keys())
daemon.flush_txpool([txes_keys[1], txes_keys[3]])
res = daemon.get_transaction_pool()
assert len(res.transactions) == txpool_size - 2
assert len([x for x in res.transactions if x.id_hash == txes_keys[1]]) == 0
assert len([x for x in res.transactions if x.id_hash == txes_keys[3]]) == 0
new_keys = list(txes.keys())
new_keys.remove(txes_keys[1])
new_keys.remove(txes_keys[3])
res = daemon.get_transaction_pool_hashes()
assert sorted(res.tx_hashes) == sorted(new_keys)
res = daemon.get_transaction_pool()
assert len(res.transactions) == len(new_keys)
total_bytes = 0
total_fee = 0
min_bytes = 99999999999999
max_bytes = 0
for txid in new_keys:
x = [x for x in res.transactions if x.id_hash == txid]
assert len(x) == 1
x = x[0]
assert x.kept_by_block == False
assert x.last_failed_id_hash == '0'*64
assert x.double_spend_seen == False
assert x.weight >= x.blob_size
assert x.blob_size * 2 == len(txes[txid].tx_blob)
assert x.fee == txes[txid].fee
assert x.tx_blob == txes[txid].tx_blob
total_bytes += x.blob_size
total_fee += x.fee
min_bytes = min(min_bytes, x.blob_size)
max_bytes = max(max_bytes, x.blob_size)
res = daemon.get_transaction_pool_stats()
assert res.pool_stats.bytes_total == total_bytes
assert res.pool_stats.bytes_min == min_bytes
assert res.pool_stats.bytes_max == max_bytes
assert res.pool_stats.bytes_med >= min_bytes and res.pool_stats.bytes_med <= max_bytes
assert res.pool_stats.fee_total == total_fee
assert res.pool_stats.txs_total == len(new_keys)
assert res.pool_stats.num_failing == 0
assert res.pool_stats.num_10m == 0
assert res.pool_stats.num_not_relayed == 0
assert res.pool_stats.num_double_spends == 0
print('Flushing unknown transactions')
unknown_txids = ['1'*64, '2'*64, '3'*64]
daemon.flush_txpool(unknown_txids)
res = daemon.get_transaction_pool()
assert len(res.transactions) == txpool_size - 2
print('Mining transactions')
daemon.generateblocks('42ey1afDFnn4886T7196doS9GPMzexD9gXpsZJDwVjeRVdFCSoHnv7KPbBeGpzJBzHRCAs9UxqeoyFQMYbqSWYTfJJQAWDm', 1)
res = daemon.get_transaction_pool()
assert not 'transactions' in res or len(res.transactions) == txpool_size - 5
res = daemon.get_transaction_pool_hashes()
assert not 'tx_hashes' in res or len(res.tx_hashes) == 0
self.check_empty_pool()
print('Popping block')
daemon.pop_blocks(1)
res = daemon.get_transaction_pool_hashes()
assert sorted(res.tx_hashes) == sorted(new_keys)
res = daemon.get_transaction_pool()
assert len(res.transactions) == txpool_size - 2
for txid in new_keys:
x = [x for x in res.transactions if x.id_hash == txid]
assert len(x) == 1
x = x[0]
assert x.kept_by_block == True
assert x.last_failed_id_hash == '0'*64
assert x.double_spend_seen == False
assert x.weight >= x.blob_size
assert x.blob_size * 2 == len(txes[txid].tx_blob)
assert x.fee == txes[txid].fee
assert x.tx_blob == txes[txid].tx_blob
print('Checking relaying txes')
res = daemon.get_transaction_pool_hashes()
assert len(res.tx_hashes) > 0
txid = res.tx_hashes[0]
daemon.relay_tx([txid])
res = daemon.get_transactions([txid])
assert len(res.txs) == 1
assert res.txs[0].tx_hash == txid
assert res.txs[0].in_pool
assert res.txs[0].relayed
daemon.flush_txpool()
self.check_empty_pool()
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
def check_txpool(self):
daemon = Daemon()
wallet = Wallet()
res = daemon.get_info()
height = res.height
txpool_size = res.tx_pool_size
txes = self.create_txes('46r4nYSevkfBUMhuykdK3gQ98XDqDTYW1hNLaXNvjpsJaSbNtdXh1sKMsdVgqkaihChAzEy29zEDPMR3NHQvGoZCLGwTerK', 5)
res = daemon.get_info()
assert res.tx_pool_size == txpool_size + 5
txpool_size = res.tx_pool_size
res = daemon.get_transaction_pool()
assert len(res.transactions) == txpool_size
for txid in txes.keys():
x = [x for x in res.transactions if x.id_hash == txid]
assert len(x) == 1
x = x[0]
assert x.kept_by_block == False
assert x.last_failed_id_hash == '0'*64
assert x.double_spend_seen == False
assert x.weight >= x.blob_size
assert x.blob_size * 2 == len(txes[txid].tx_blob)
assert x.fee == txes[txid].fee
assert x.tx_blob == txes[txid].tx_blob
res = daemon.get_transaction_pool_hashes()
assert sorted(res.tx_hashes) == sorted(txes.keys())
print('Flushing 2 transactions')
txes_keys = list(txes.keys())
daemon.flush_txpool([txes_keys[1], txes_keys[3]])
res = daemon.get_transaction_pool()
assert len(res.transactions) == txpool_size - 2
assert len([x for x in res.transactions if x.id_hash == txes_keys[1]]) == 0
assert len([x for x in res.transactions if x.id_hash == txes_keys[3]]) == 0
new_keys = list(txes.keys())
new_keys.remove(txes_keys[1])
new_keys.remove(txes_keys[3])
res = daemon.get_transaction_pool_hashes()
assert sorted(res.tx_hashes) == sorted(new_keys)
print('Flushing unknown transactions')
unknown_txids = ['1'*64, '2'*64, '3'*64]
daemon.flush_txpool(unknown_txids)
res = daemon.get_transaction_pool()
assert len(res.transactions) == txpool_size - 2
print('Mining transactions')
daemon.generateblocks('42ey1afDFnn4886T7196doS9GPMzexD9gXpsZJDwVjeRVdFCSoHnv7KPbBeGpzJBzHRCAs9UxqeoyFQMYbqSWYTfJJQAWDm', 1)
res = daemon.get_transaction_pool()
assert not 'transactions' in res or len(res.transactions) == txpool_size - 5
res = daemon.get_transaction_pool_hashes()
assert not 'tx_hashes' in res or len(res.tx_hashes) == 0
print('Popping block')
daemon.pop_blocks(1)
res = daemon.get_transaction_pool_hashes()
assert sorted(res.tx_hashes) == sorted(new_keys)
res = daemon.get_transaction_pool()
assert len(res.transactions) == txpool_size - 2
for txid in new_keys:
x = [x for x in res.transactions if x.id_hash == txid]
assert len(x) == 1
x = x[0]
assert x.kept_by_block == True
assert x.last_failed_id_hash == '0'*64
assert x.double_spend_seen == False
assert x.weight >= x.blob_size
assert x.blob_size * 2 == len(txes[txid].tx_blob)
assert x.fee == txes[txid].fee
assert x.tx_blob == txes[txid].tx_blob
def test_get_output_distribution(self):
print("Test get_output_distribution")
daemon = Daemon()
res = daemon.get_output_distribution([0], 0, 0)
assert len(res.distributions) == 1
d = res.distributions[0]
assert d.amount == 0
assert d.base == 0
assert d.binary == False
assert len(d.distribution) == 1
assert d.distribution[0] == 0
res = daemon.generateblocks('42ey1afDFnn4886T7196doS9GPMzexD9gXpsZJDwVjeRVdFCSoHnv7KPbBeGpzJBzHRCAs9UxqeoyFQMYbqSWYTfJJQAWDm', 1)
res = daemon.get_output_distribution([0], 0, 0)
assert len(res.distributions) == 1
d = res.distributions[0]
assert d.amount == 0
assert d.base == 0
assert d.binary == False
assert len(d.distribution) == 2
assert d.distribution[0] == 0
assert d.distribution[1] == 1
res = daemon.pop_blocks(1)
res = daemon.get_output_distribution([0], 0, 0)
assert len(res.distributions) == 1
d = res.distributions[0]
assert d.amount == 0
assert d.base == 0
assert d.binary == False
assert len(d.distribution) == 1
assert d.distribution[0] == 0
res = daemon.generateblocks('42ey1afDFnn4886T7196doS9GPMzexD9gXpsZJDwVjeRVdFCSoHnv7KPbBeGpzJBzHRCAs9UxqeoyFQMYbqSWYTfJJQAWDm', 3)
res = daemon.get_output_distribution([0], 0, 0, cumulative = True)
assert len(res.distributions) == 1
d = res.distributions[0]
assert d.amount == 0
assert d.base == 0
assert d.binary == False
assert len(d.distribution) == 4
assert d.distribution[0] == 0
assert d.distribution[1] == 1
assert d.distribution[2] == 2
assert d.distribution[3] == 3
# extend
res = daemon.generateblocks('42ey1afDFnn4886T7196doS9GPMzexD9gXpsZJDwVjeRVdFCSoHnv7KPbBeGpzJBzHRCAs9UxqeoyFQMYbqSWYTfJJQAWDm', 80)
res = daemon.get_output_distribution([0], 0, 0, cumulative = True)
assert len(res.distributions) == 1
d = res.distributions[0]
assert d.amount == 0
assert d.base == 0
assert d.binary == False
assert len(d.distribution) == 84
for h in range(len(d.distribution)):
assert d.distribution[h] == h
# pop and replace, this will do through the "trim and extend" path
res = daemon.pop_blocks(2)
self.wallet.refresh()
dst = {'address': '42ey1afDFnn4886T7196doS9GPMzexD9gXpsZJDwVjeRVdFCSoHnv7KPbBeGpzJBzHRCAs9UxqeoyFQMYbqSWYTfJJQAWDm', 'amount': 1000000000000}
self.wallet.transfer([dst])
res = daemon.generateblocks('42ey1afDFnn4886T7196doS9GPMzexD9gXpsZJDwVjeRVdFCSoHnv7KPbBeGpzJBzHRCAs9UxqeoyFQMYbqSWYTfJJQAWDm', 1)
for step in range(3): # the second will be cached, the third will also be cached, but we get it in non-cumulative mode
res = daemon.get_output_distribution([0], 0, 0, cumulative = step < 3)
assert len(res.distributions) == 1
d = res.distributions[0]
assert d.amount == 0
assert d.base == 0
assert d.binary == False
assert len(d.distribution) == 83
for h in range(len(d.distribution)):
assert d.distribution[h] == (h if step < 3 else 1) + (2 if h == len(d.distribution) - 1 else 0)
# start at 0, end earlier
res = daemon.get_output_distribution([0], 0, 40, cumulative = True)
assert len(res.distributions) == 1
d = res.distributions[0]
assert d.amount == 0
assert d.base == 0
assert d.binary == False
assert len(d.distribution) == 41
for h in range(len(d.distribution)):
assert d.distribution[h] == h
# start after 0, end earlier
res = daemon.get_output_distribution([0], 10, 20, cumulative = True)
assert len(res.distributions) == 1
d = res.distributions[0]
assert d.amount == 0
assert d.base == 9
assert d.binary == False
assert len(d.distribution) == 11
for h in range(len(d.distribution)):
assert d.distribution[h] == 10 + h
# straddling up
res = daemon.get_output_distribution([0], 15, 25, cumulative = True)
assert len(res.distributions) == 1
d = res.distributions[0]
assert d.amount == 0
assert d.base == 14
assert d.binary == False
assert len(d.distribution) == 11
for h in range(len(d.distribution)):
assert d.distribution[h] == 15 + h
# straddling down
res = daemon.get_output_distribution([0], 8, 18, cumulative = True)
assert len(res.distributions) == 1
d = res.distributions[0]
assert d.amount == 0
assert d.base == 7
assert d.binary == False
assert len(d.distribution) == 11
for h in range(len(d.distribution)):
assert d.distribution[h] == 8 + h
# encompassing
res = daemon.get_output_distribution([0], 5, 20, cumulative = True)
assert len(res.distributions) == 1
d = res.distributions[0]
assert d.amount == 0
assert d.base == 4
assert d.binary == False
assert len(d.distribution) == 16
for h in range(len(d.distribution)):
assert d.distribution[h] == 5 + h
# single
res = daemon.get_output_distribution([0], 2, 2, cumulative = True)
assert len(res.distributions) == 1
d = res.distributions[0]
assert d.amount == 0
assert d.base == 1
assert d.binary == False
assert len(d.distribution) == 1
assert d.distribution[0] == 2
# a non existent amount
res = daemon.get_output_distribution([1], 0, 0)
assert len(res.distributions) == 1
d = res.distributions[0]
assert d.amount == 1
assert d.base == 0
assert d.binary == False
assert len(d.distribution) == 83
for h in range(len(d.distribution)):
assert d.distribution[h] == 0