def get_cand(index: int):
unf_block = FullBlock(
candidates[index].proof_of_space,
None,
candidates[index].header,
candidates[index].transactions_generator,
candidates[index].transactions_filter,
)
return fnp.RespondUnfinishedBlock(unf_block)
async def test_request_unfinished(self, two_nodes, wallet_blocks):
full_node_1, full_node_2, server_1, server_2 = two_nodes
wallet_a, wallet_receiver, blocks = wallet_blocks
blocks_list = await get_block_path(full_node_1)
blocks_new = bt.get_consecutive_blocks(
test_constants, 2, blocks_list, 10, seed=b"another seed 3",
)
# Add one block
[_ async for _ in full_node_1.respond_block(fnp.RespondBlock(blocks_new[-2]))]
unf_block = FullBlock(
blocks_new[-1].proof_of_space,
None,
blocks_new[-1].header,
blocks_new[-1].transactions_generator,
blocks_new[-1].transactions_filter,
)
unf_block_req = fnp.RespondUnfinishedBlock(unf_block)
# Don't have
req = fnp.RequestUnfinishedBlock(unf_block.header_hash)
res = [x async for x in full_node_1.request_unfinished_block(req)]
assert len(res) == 1
assert res[0].message.data == fnp.RejectUnfinishedBlockRequest(
unf_block.header_hash
)
# Have unfinished block
[x async for x in full_node_1.respond_unfinished_block(unf_block_req)]
res = [x async for x in full_node_1.request_unfinished_block(req)]
assert len(res) == 1
assert res[0].message.data == fnp.RespondUnfinishedBlock(unf_block)
# Have full block (genesis in this case)
req = fnp.RequestUnfinishedBlock(blocks_new[0].header_hash)
res = [x async for x in full_node_1.request_unfinished_block(req)]
assert len(res) == 1
assert res[0].message.data.block.header_hash == blocks_new[0].header_hash
async def test_new_unfinished(self, two_nodes, wallet_blocks):
full_node_1, full_node_2, server_1, server_2 = two_nodes
wallet_a, wallet_receiver, blocks = wallet_blocks
blocks_list = await get_block_path(full_node_1)
blocks_new = bt.get_consecutive_blocks(
test_constants, 1, blocks_list, 10, seed=b"another seed 2",
)
assert blocks_new[-1].proof_of_time is not None
assert blocks_new[-2].proof_of_time is not None
already_have = fnp.NewUnfinishedBlock(
blocks_new[-2].prev_header_hash,
blocks_new[-2].proof_of_time.number_of_iterations,
blocks_new[-2].header_hash,
)
assert (
len([x async for x in full_node_1.new_unfinished_block(already_have)]) == 0
)
bad_prev = fnp.NewUnfinishedBlock(
blocks_new[-1].header_hash,
blocks_new[-1].proof_of_time.number_of_iterations,
blocks_new[-1].header_hash,
)
assert len([x async for x in full_node_1.new_unfinished_block(bad_prev)]) == 0
good = fnp.NewUnfinishedBlock(
blocks_new[-1].prev_header_hash,
blocks_new[-1].proof_of_time.number_of_iterations,
blocks_new[-1].header_hash,
)
assert len([x async for x in full_node_1.new_unfinished_block(good)]) == 1
unf_block = FullBlock(
blocks_new[-1].proof_of_space,
None,
blocks_new[-1].header,
blocks_new[-1].transactions_generator,
blocks_new[-1].transactions_filter,
)
unf_block_req = fnp.RespondUnfinishedBlock(unf_block)
[x async for x in full_node_1.respond_unfinished_block(unf_block_req)]
assert len([x async for x in full_node_1.new_unfinished_block(good)]) == 0
async def test_unfinished_blocks_load(self, two_nodes):
num_blocks = 10
full_node_1, full_node_2, server_1, server_2 = two_nodes
blocks = bt.get_consecutive_blocks(test_constants, num_blocks, [], 10)
for i in range(1, num_blocks - 1):
async for _ in full_node_1.respond_block(
full_node_protocol.RespondBlock(blocks[i])):
pass
await server_2.start_client(
PeerInfo("localhost", uint16(server_1._port)), None)
await asyncio.sleep(2) # Allow connections to get made
num_unfinished_blocks = 1000
start_unf = time.time()
for i in range(num_unfinished_blocks):
msg = Message(
"respond_unfinished_block",
full_node_protocol.RespondUnfinishedBlock(blocks[9]),
)
server_1.push_message(
OutboundMessage(NodeType.FULL_NODE, msg, Delivery.BROADCAST))
# Send the whole block ast the end so we can detect when the node is done
block_msg = Message("respond_block",
full_node_protocol.RespondBlock(blocks[9]))
server_1.push_message(
OutboundMessage(NodeType.FULL_NODE, block_msg, Delivery.BROADCAST))
while time.time() - start_unf < 100:
if (max(
[h.height for h in full_node_2.blockchain.get_current_tips()
]) == num_blocks - 1):
print(
f"Time taken to process {num_unfinished_blocks} is {time.time() - start_unf}"
)
return
await asyncio.sleep(0.1)
raise Exception("Took too long to process blocks")
async def test_new_pot(self, two_nodes, wallet_blocks):
full_node_1, full_node_2, server_1, server_2 = two_nodes
wallet_a, wallet_receiver, _ = wallet_blocks
no_unf_block = fnp.NewProofOfTime(
uint32(5), bytes(32 * [1]), uint64(124512), uint8(2)
)
assert len([x async for x in full_node_1.new_proof_of_time(no_unf_block)]) == 0
blocks = await get_block_path(full_node_1)
blocks_new = bt.get_consecutive_blocks(
test_constants, 1, blocks[:-1], 10, seed=b"1212412",
)
unf_block = FullBlock(
blocks_new[-1].proof_of_space,
None,
blocks_new[-1].header,
blocks_new[-1].transactions_generator,
blocks_new[-1].transactions_filter,
)
unf_block_req = fnp.RespondUnfinishedBlock(unf_block)
res = [x async for x in full_node_1.respond_unfinished_block(unf_block_req)]
dont_have = fnp.NewProofOfTime(
unf_block.height,
unf_block.proof_of_space.challenge_hash,
res[0].message.data.iterations_needed,
uint8(2),
)
assert len([x async for x in full_node_1.new_proof_of_time(dont_have)]) == 1
[x async for x in full_node_1.respond_block(fnp.RespondBlock(blocks_new[-1]))]
assert blocks_new[-1].proof_of_time is not None
already_have = fnp.NewProofOfTime(
unf_block.height,
unf_block.proof_of_space.challenge_hash,
res[0].message.data.iterations_needed,
blocks_new[-1].proof_of_time.witness_type,
)
assert len([x async for x in full_node_1.new_proof_of_time(already_have)]) == 0
async def test_unfinished_blocks_load(self, two_nodes):
num_blocks = 2
full_node_1, full_node_2, server_1, server_2 = two_nodes
blocks = bt.get_consecutive_blocks(test_constants, num_blocks, [], 10)
for i in range(1, num_blocks - 1):
async for _ in full_node_1.respond_block(
full_node_protocol.RespondBlock(blocks[i])
):
pass
await server_2.start_client(PeerInfo("localhost", uint16(server_1._port)), None)
async def num_connections():
return len(server_2.global_connections.get_connections())
await time_out_assert(10, num_connections, 1)
num_unfinished_blocks = 250
for i in range(num_unfinished_blocks):
msg = Message(
"respond_unfinished_block",
full_node_protocol.RespondUnfinishedBlock(blocks[num_blocks - 1]),
)
server_1.push_message(
OutboundMessage(NodeType.FULL_NODE, msg, Delivery.BROADCAST)
)
# Send the whole block ast the end so we can detect when the node is done
block_msg = Message(
"respond_block", full_node_protocol.RespondBlock(blocks[num_blocks - 1])
)
server_1.push_message(
OutboundMessage(NodeType.FULL_NODE, block_msg, Delivery.BROADCAST)
)
await time_out_assert(
60, node_height_at_least, True, full_node_2, num_blocks - 1
)
async def test_respond_pot(self, two_nodes, wallet_blocks):
full_node_1, full_node_2, server_1, server_2 = two_nodes
wallet_a, wallet_receiver, blocks = wallet_blocks
blocks_list = await get_block_path(full_node_1)
blocks_new = bt.get_consecutive_blocks(
test_constants, 1, blocks_list, 10, seed=b"another seed",
)
assert blocks_new[-1].proof_of_time is not None
new_pot = fnp.NewProofOfTime(
blocks_new[-1].height,
blocks_new[-1].proof_of_space.challenge_hash,
blocks_new[-1].proof_of_time.number_of_iterations,
blocks_new[-1].proof_of_time.witness_type,
)
[x async for x in full_node_1.new_proof_of_time(new_pot)]
# Don't have unfinished block
respond_pot = fnp.RespondProofOfTime(blocks_new[-1].proof_of_time)
res = [x async for x in full_node_1.respond_proof_of_time(respond_pot)]
assert len(res) == 0
unf_block = FullBlock(
blocks_new[-1].proof_of_space,
None,
blocks_new[-1].header,
blocks_new[-1].transactions_generator,
blocks_new[-1].transactions_filter,
)
unf_block_req = fnp.RespondUnfinishedBlock(unf_block)
[x async for x in full_node_1.respond_unfinished_block(unf_block_req)]
# Have unfinished block, finish
assert blocks_new[-1].proof_of_time is not None
respond_pot = fnp.RespondProofOfTime(blocks_new[-1].proof_of_time)
res = [x async for x in full_node_1.respond_proof_of_time(respond_pot)]
assert len(res) == 4
async def test1(self, two_nodes):
num_blocks = 5
test_rpc_port = uint16(21522)
full_node_1, full_node_2, server_1, server_2 = two_nodes
blocks = bt.get_consecutive_blocks(test_constants, num_blocks, [], 10)
for i in range(1, num_blocks):
async for _ in full_node_1.respond_unfinished_block(
full_node_protocol.RespondUnfinishedBlock(blocks[i])):
pass
async for _ in full_node_1.respond_block(
full_node_protocol.RespondBlock(blocks[i])):
pass
def stop_node_cb():
full_node_1._close()
server_1.close_all()
full_node_rpc_api = FullNodeRpcApi(full_node_1)
config = bt.config
hostname = config["self_hostname"]
daemon_port = config["daemon_port"]
rpc_cleanup = await start_rpc_server(
full_node_rpc_api,
hostname,
daemon_port,
test_rpc_port,
stop_node_cb,
connect_to_daemon=False,
)
try:
client = await FullNodeRpcClient.create("localhost", test_rpc_port)
state = await client.get_blockchain_state()
assert state["lca"].header_hash is not None
assert not state["sync"]["sync_mode"]
assert len(state["tips"]) > 0
assert state["difficulty"] > 0
assert state["ips"] > 0
assert state["min_iters"] > 0
block = await client.get_block(state["lca"].header_hash)
assert block == blocks[2]
assert (await client.get_block(bytes([1] * 32))) is None
unf_block_headers = await client.get_unfinished_block_headers(4)
assert len(unf_block_headers) == 1
assert unf_block_headers[0] == blocks[4].header
header = await client.get_header(state["lca"].header_hash)
assert header == blocks[2].header
assert (await client.get_header_by_height(2)) == blocks[2].header
assert (await client.get_header_by_height(100)) is None
coins = await client.get_unspent_coins(
blocks[-1].get_coinbase().puzzle_hash, blocks[-1].header_hash)
assert len(coins) == 3
coins_lca = await client.get_unspent_coins(
blocks[-1].get_coinbase().puzzle_hash)
assert len(coins_lca) == 3
assert len(await client.get_connections()) == 0
await client.open_connection("localhost", server_2._port)
async def num_connections():
return len(await client.get_connections())
await time_out_assert(10, num_connections, 1)
connections = await client.get_connections()
await client.close_connection(connections[0]["node_id"])
await time_out_assert(10, num_connections, 0)
finally:
# Checks that the RPC manages to stop the node
client.close()
await client.await_closed()
await rpc_cleanup()
async def test1(self, two_nodes):
num_blocks = 10
test_rpc_port = uint16(21522)
full_node_1, full_node_2, server_1, server_2 = two_nodes
blocks = bt.get_consecutive_blocks(test_constants, num_blocks, [], 10)
for i in range(1, num_blocks):
async for _ in full_node_1.respond_unfinished_block(
full_node_protocol.RespondUnfinishedBlock(blocks[i])):
pass
async for _ in full_node_1.respond_block(
full_node_protocol.RespondBlock(blocks[i])):
pass
def stop_node_cb():
full_node_1._shutdown()
server_1.close_all()
rpc_cleanup = await start_rpc_server(full_node_1, stop_node_cb,
test_rpc_port)
try:
client = await RpcClient.create(test_rpc_port)
state = await client.get_blockchain_state()
assert state["lca"].header_hash is not None
assert not state["sync_mode"]
assert len(state["tips"]) > 0
assert state["difficulty"] > 0
assert state["ips"] > 0
assert state["min_iters"] > 0
block = await client.get_block(state["lca"].header_hash)
assert block == blocks[7]
assert (await client.get_block(bytes([1] * 32))) is None
unf_block_headers = await client.get_unfinished_block_headers(5)
assert len(unf_block_headers) == 1
assert unf_block_headers[0] == blocks[5].header
header = await client.get_header(state["lca"].header_hash)
assert header == blocks[7].header
assert (await client.get_header_by_height(7)) == blocks[7].header
assert (await client.get_header_by_height(100)) is None
coins = await client.get_unspent_coins(
blocks[-1].header.data.coinbase.puzzle_hash,
blocks[-1].header_hash)
assert len(coins) == 16
coins_lca = await client.get_unspent_coins(
blocks[-1].header.data.coinbase.puzzle_hash)
assert len(coins_lca) == 16
assert len(await client.get_connections()) == 0
await client.open_connection("localhost", server_2._port)
await asyncio.sleep(2)
connections = await client.get_connections()
assert len(connections) == 1
await client.close_connection(connections[0]["node_id"])
assert len(await client.get_connections()) == 0
await asyncio.sleep(2) # Allow server to start
except AssertionError:
# Checks that the RPC manages to stop the node
client.close()
await client.await_closed()
await rpc_cleanup()
raise
client.close()
await client.await_closed()
await rpc_cleanup()
async def test1(self, two_nodes):
num_blocks = 5
test_rpc_port = uint16(21522)
nodes, _ = two_nodes
full_node_api_1, full_node_api_2 = nodes
server_1 = full_node_api_1.full_node.server
server_2 = full_node_api_2.full_node.server
def stop_node_cb():
full_node_api_1._close()
server_1.close_all()
full_node_rpc_api = FullNodeRpcApi(full_node_api_1.full_node)
config = bt.config
hostname = config["self_hostname"]
daemon_port = config["daemon_port"]
rpc_cleanup = await start_rpc_server(
full_node_rpc_api,
hostname,
daemon_port,
test_rpc_port,
stop_node_cb,
bt.root_path,
config,
connect_to_daemon=False,
)
try:
client = await FullNodeRpcClient.create(self_hostname,
test_rpc_port,
bt.root_path, config)
state = await client.get_blockchain_state()
assert state["peak"] is None
assert not state["sync"]["sync_mode"]
assert state["difficulty"] > 0
assert state["sub_slot_iters"] > 0
blocks = bt.get_consecutive_blocks(num_blocks)
blocks = bt.get_consecutive_blocks(
num_blocks,
block_list_input=blocks,
guarantee_transaction_block=True)
assert len(await client.get_unfinished_block_headers()) == 0
assert len((await client.get_block_records(0, 100))) == 0
for block in blocks:
if is_overflow_block(
test_constants,
block.reward_chain_block.signage_point_index):
finished_ss = block.finished_sub_slots[:-1]
else:
finished_ss = block.finished_sub_slots
unf = UnfinishedBlock(
finished_ss,
block.reward_chain_block.get_unfinished(),
block.challenge_chain_sp_proof,
block.reward_chain_sp_proof,
block.foliage,
block.foliage_transaction_block,
block.transactions_info,
block.transactions_generator,
[],
)
await full_node_api_1.full_node.respond_unfinished_block(
full_node_protocol.RespondUnfinishedBlock(unf), None)
await full_node_api_1.full_node.respond_block(
full_node_protocol.RespondBlock(block), None)
assert len(await client.get_unfinished_block_headers()) > 0
assert len(await client.get_all_block(0, 2)) == 2
state = await client.get_blockchain_state()
block = await client.get_block(state["peak"].header_hash)
assert block == blocks[-1]
assert (await client.get_block(bytes([1] * 32))) is None
assert (await client.get_block_record_by_height(2)
).header_hash == blocks[2].header_hash
assert len((await client.get_block_records(0,
100))) == num_blocks * 2
assert (await client.get_block_record_by_height(100)) is None
ph = list(blocks[-1].get_included_reward_coins())[0].puzzle_hash
coins = await client.get_coin_records_by_puzzle_hash(ph)
print(coins)
assert len(coins) >= 1
additions, removals = await client.get_additions_and_removals(
blocks[-1].header_hash)
assert len(additions) >= 2 and len(removals) == 0
wallet = WalletTool()
wallet_receiver = WalletTool(
AugSchemeMPL.key_gen(std_hash(b"123123")))
ph = wallet.get_new_puzzlehash()
ph_2 = wallet.get_new_puzzlehash()
ph_receiver = wallet_receiver.get_new_puzzlehash()
assert len(await client.get_coin_records_by_puzzle_hash(ph)) == 0
assert len(
await client.get_coin_records_by_puzzle_hash(ph_receiver)) == 0
blocks = bt.get_consecutive_blocks(
2,
block_list_input=blocks,
guarantee_transaction_block=True,
farmer_reward_puzzle_hash=ph,
pool_reward_puzzle_hash=ph,
)
for block in blocks[-2:]:
await full_node_api_1.full_node.respond_block(
full_node_protocol.RespondBlock(block))
assert len(await client.get_coin_records_by_puzzle_hash(ph)) == 2
assert len(
await client.get_coin_records_by_puzzle_hash(ph_receiver)) == 0
coin_to_spend = list(blocks[-1].get_included_reward_coins())[0]
spend_bundle = wallet.generate_signed_transaction(
coin_to_spend.amount, ph_receiver, coin_to_spend)
assert len(await client.get_all_mempool_items()) == 0
assert len(await client.get_all_mempool_tx_ids()) == 0
assert (await client.get_mempool_item_by_tx_id(spend_bundle.name()
)) is None
await client.push_tx(spend_bundle)
assert len(await client.get_all_mempool_items()) == 1
assert len(await client.get_all_mempool_tx_ids()) == 1
assert (SpendBundle.from_json_dict(
list((await client.get_all_mempool_items()
).values())[0]["spend_bundle"]) == spend_bundle)
assert (await
client.get_all_mempool_tx_ids())[0] == spend_bundle.name()
assert (SpendBundle.from_json_dict(
(await client.get_mempool_item_by_tx_id(
spend_bundle.name()))["spend_bundle"]) == spend_bundle)
await full_node_api_1.farm_new_transaction_block(
FarmNewBlockProtocol(ph_2))
assert len(
await client.get_coin_records_by_puzzle_hash(ph_receiver)) == 1
assert len(
list(
filter(lambda cr: not cr.spent,
(await
client.get_coin_records_by_puzzle_hash(ph))))) == 3
assert len(await
client.get_coin_records_by_puzzle_hash(ph, False)) == 3
assert len(await client.get_coin_records_by_puzzle_hash(ph,
True)) == 4
assert len(await client.get_coin_records_by_puzzle_hash(
ph, True, 0, 100)) == 4
assert len(await client.get_coin_records_by_puzzle_hash(
ph, True, 50, 100)) == 0
assert len(await client.get_coin_records_by_puzzle_hash(
ph, True, 0, blocks[-1].height + 1)) == 2
assert len(await
client.get_coin_records_by_puzzle_hash(ph, True, 0,
1)) == 0
assert len(await client.get_connections()) == 0
await client.open_connection(self_hostname, server_2._port)
async def num_connections():
return len(await client.get_connections())
await time_out_assert(10, num_connections, 1)
connections = await client.get_connections()
await client.close_connection(connections[0]["node_id"])
await time_out_assert(10, num_connections, 0)
finally:
# Checks that the RPC manages to stop the node
client.close()
await client.await_closed()
await rpc_cleanup()
async def test_respond_unfinished(self, two_nodes, wallet_blocks):
full_node_1, full_node_2, server_1, server_2 = two_nodes
wallet_a, wallet_receiver, blocks = wallet_blocks
blocks_list = await get_block_path(full_node_1)
blocks_new = bt.get_consecutive_blocks(
test_constants, 1, blocks_list[:], 4, seed=b"Another seed 4",
)
for block in blocks_new:
[_ async for _ in full_node_1.respond_block(fnp.RespondBlock(block))]
candidates = []
for i in range(50):
blocks_new_2 = bt.get_consecutive_blocks(
test_constants,
1,
blocks_new[:],
4,
seed=i.to_bytes(4, "big") + b"Another seed",
)
candidates.append(blocks_new_2[-1])
unf_block_not_child = FullBlock(
blocks_new[-7].proof_of_space,
None,
blocks_new[-7].header,
blocks_new[-7].transactions_generator,
blocks_new[-7].transactions_filter,
)
unf_block_req_bad = fnp.RespondUnfinishedBlock(unf_block_not_child)
assert (
len(
[
x
async for x in full_node_1.respond_unfinished_block(
unf_block_req_bad
)
]
)
== 0
)
candidates = sorted(candidates, key=lambda c: c.proof_of_time.number_of_iterations) # type: ignore
def get_cand(index: int):
unf_block = FullBlock(
candidates[index].proof_of_space,
None,
candidates[index].header,
candidates[index].transactions_generator,
candidates[index].transactions_filter,
)
return fnp.RespondUnfinishedBlock(unf_block)
# Highest height should propagate
# Slow block should delay prop
start = time.time()
propagation_messages = [
x async for x in full_node_1.respond_unfinished_block(get_cand(20))
]
assert len(propagation_messages) == 2
assert isinstance(
propagation_messages[0].message.data, timelord_protocol.ProofOfSpaceInfo
)
assert isinstance(propagation_messages[1].message.data, fnp.NewUnfinishedBlock)
# TODO: fix
# assert time.time() - start > 3
# Already seen
assert (
len([x async for x in full_node_1.respond_unfinished_block(get_cand(20))])
== 0
)
# Slow equal height should not propagate
assert (
len([x async for x in full_node_1.respond_unfinished_block(get_cand(49))])
== 0
)
# Fastest equal height should propagate
start = time.time()
assert (
len([x async for x in full_node_1.respond_unfinished_block(get_cand(0))])
== 2
)
assert time.time() - start < 3
# Equal height (fast) should propagate
for i in range(1, 5):
# Checks a few blocks in case they have the same PoS
if (
candidates[i].proof_of_space.get_hash()
!= candidates[0].proof_of_space.get_hash()
):
start = time.time()
assert (
len(
[
x
async for x in full_node_1.respond_unfinished_block(
get_cand(i)
)
]
)
== 2
)
assert time.time() - start < 3
break
# Equal height (slow) should not propagate
assert (
len([x async for x in full_node_1.respond_unfinished_block(get_cand(40))])
== 0
)
# Don't propagate at old height
[_ async for _ in full_node_1.respond_block(fnp.RespondBlock(candidates[0]))]
blocks_new_3 = bt.get_consecutive_blocks(
test_constants, 1, blocks_new[:] + [candidates[0]], 10,
)
unf_block_new = FullBlock(
blocks_new_3[-1].proof_of_space,
None,
blocks_new_3[-1].header,
blocks_new_3[-1].transactions_generator,
blocks_new_3[-1].transactions_filter,
)
unf_block_new_req = fnp.RespondUnfinishedBlock(unf_block_new)
[x async for x in full_node_1.respond_unfinished_block(unf_block_new_req)]
assert (
len([x async for x in full_node_1.respond_unfinished_block(get_cand(10))])
== 0
)
async def test1(self, two_nodes):
num_blocks = 5
test_rpc_port = uint16(21522)
full_node_api_1, full_node_api_2, server_1, server_2 = two_nodes
def stop_node_cb():
full_node_api_1._close()
server_1.close_all()
full_node_rpc_api = FullNodeRpcApi(full_node_api_1.full_node)
config = bt.config
hostname = config["self_hostname"]
daemon_port = config["daemon_port"]
rpc_cleanup = await start_rpc_server(
full_node_rpc_api,
hostname,
daemon_port,
test_rpc_port,
stop_node_cb,
bt.root_path,
config,
connect_to_daemon=False,
)
try:
client = await FullNodeRpcClient.create(self_hostname,
test_rpc_port,
bt.root_path, config)
state = await client.get_blockchain_state()
assert state["peak"] is None
assert not state["sync"]["sync_mode"]
assert state["difficulty"] > 0
assert state["sub_slot_iters"] > 0
blocks = bt.get_consecutive_blocks(num_blocks)
blocks = bt.get_consecutive_blocks(
1, block_list_input=blocks, guarantee_transaction_block=True)
assert len(await client.get_unfinished_block_headers()) == 0
assert len((await client.get_block_records(0, 100))) == 0
for block in blocks:
if is_overflow_block(
test_constants,
block.reward_chain_block.signage_point_index):
finished_ss = block.finished_sub_slots[:-1]
else:
finished_ss = block.finished_sub_slots
unf = UnfinishedBlock(
finished_ss,
block.reward_chain_block.get_unfinished(),
block.challenge_chain_sp_proof,
block.reward_chain_sp_proof,
block.foliage,
block.foliage_transaction_block,
block.transactions_info,
block.transactions_generator,
)
await full_node_api_1.full_node.respond_unfinished_block(
full_node_protocol.RespondUnfinishedBlock(unf), None)
await full_node_api_1.full_node.respond_block(
full_node_protocol.RespondBlock(block), None)
assert len(await client.get_unfinished_block_headers()) > 0
assert len(await client.get_all_block(0, 2)) == 2
state = await client.get_blockchain_state()
block = await client.get_block(state["peak"].header_hash)
assert block == blocks[-1]
assert (await client.get_block(bytes([1] * 32))) is None
assert (await client.get_block_record_by_height(2)
).header_hash == blocks[2].header_hash
assert len((await client.get_block_records(0,
100))) == num_blocks + 1
assert (await client.get_block_record_by_height(100)) is None
ph = list(blocks[-1].get_included_reward_coins())[0].puzzle_hash
coins = await client.get_unspent_coins(ph)
assert len(coins) >= 1
additions, removals = await client.get_additions_and_removals(
blocks[-1].header_hash)
assert len(additions) >= 2 and len(removals) == 0
assert len(await client.get_connections()) == 0
await client.open_connection(self_hostname, server_2._port)
async def num_connections():
return len(await client.get_connections())
await time_out_assert(10, num_connections, 1)
connections = await client.get_connections()
await client.close_connection(connections[0]["node_id"])
await time_out_assert(10, num_connections, 0)
finally:
# Checks that the RPC manages to stop the node
client.close()
await client.await_closed()
await rpc_cleanup()
