def test_headerdb_persist_header_returns_new_canonical_chain(
headerdb, genesis_header):
gen_result, _ = headerdb.persist_header(genesis_header)
assert gen_result == (genesis_header, )
chain_a = mk_header_chain(genesis_header, 3)
chain_b = mk_header_chain(genesis_header, 2)
chain_c = mk_header_chain(genesis_header, 5)
for header in chain_a:
res, _ = headerdb.persist_header(header)
assert res == (header, )
for header in chain_b:
res, _ = headerdb.persist_header(header)
assert res == tuple()
for idx, header in enumerate(chain_c, 1):
res, _ = headerdb.persist_header(header)
if idx <= 3:
# prior to passing up `chain_a` each import should not return new
# canonical headers.
assert res == tuple()
elif idx == 4:
# at the point where `chain_c` passes `chain_a` we should get the
# headers from `chain_c` up through current.
assert res == chain_c[:idx]
assert_headers_eq(res[-1], header)
else:
# after `chain_c` has become canonical we should just get each new
# header back.
assert res == (header, )
def test_headerdb_get_canonical_head_with_header_chain(headerdb,
genesis_header):
headerdb.persist_header(genesis_header)
headers = mk_header_chain(genesis_header, length=10)
headerdb.persist_header_chain(headers)
head = headerdb.get_canonical_head()
assert_headers_eq(head, headers[-1])
def test_header_chain_initialization_header_already_persisted(base_db, genesis_header):
headerdb = HeaderDB(base_db)
headerdb.persist_header(genesis_header)
# sanity check that the header is persisted
assert_headers_eq(headerdb.get_canonical_head(), genesis_header)
header_chain = HeaderChain.from_genesis_header(base_db, genesis_header)
head = header_chain.get_canonical_head()
assert_headers_eq(head, genesis_header)
def test_headerdb_header_retrieval_by_hash(headerdb, genesis_header):
headerdb.persist_header(genesis_header)
headers = mk_header_chain(genesis_header, length=10)
headerdb.persist_header_chain(headers)
# can we get the genesis header by hash
actual = headerdb.get_block_header_by_hash(genesis_header.hash)
assert_headers_eq(actual, genesis_header)
for header in headers:
actual = headerdb.get_block_header_by_hash(header.hash)
assert_headers_eq(actual, header)
def assert_is_canonical_chain(headerdb, headers):
if not headers:
return
# verify that the HEAD is correctly set.
head = headerdb.get_canonical_head()
assert_headers_eq(head, headers[-1])
# verify that each header is set as the canonical block.
for header in headers:
canonical_hash = headerdb.get_canonical_block_hash(header.block_number)
assert canonical_hash == header.hash
# verify difficulties are correctly set.
base_header = headerdb.get_block_header_by_hash(headers[0].parent_hash)
difficulties = tuple(h.difficulty for h in headers)
scores = tuple(
accumulate(operator.add, difficulties, base_header.difficulty))
for header, expected_score in zip(headers, scores[1:]):
actual_score = headerdb.get_score(header.hash)
assert actual_score == expected_score
def test_header_chain_initialization_from_genesis_header(base_db, genesis_header):
header_chain = HeaderChain.from_genesis_header(base_db, genesis_header)
head = header_chain.get_canonical_head()
assert_headers_eq(head, genesis_header)
def test_chaindb_get_block_header_by_hash(chaindb, block, header):
block = block.copy(header=set_empty_root(chaindb, block.header))
header = set_empty_root(chaindb, header)
chaindb.persist_block(block)
block_header = chaindb.get_block_header_by_hash(block.hash)
assert_headers_eq(block_header, header)