async def test_full_block_performance(self, wallet_nodes):
full_node_1, server_1, wallet_a, wallet_receiver = wallet_nodes
blocks = await full_node_1.get_all_full_blocks()
full_node_1.full_node.mempool_manager.limit_factor = 1
wallet_ph = wallet_a.get_new_puzzlehash()
blocks = bt.get_consecutive_blocks(
10,
block_list_input=blocks,
guarantee_transaction_block=True,
farmer_reward_puzzle_hash=wallet_ph,
pool_reward_puzzle_hash=wallet_ph,
)
for block in blocks:
await full_node_1.full_node.respond_block(fnp.RespondBlock(block))
start_height = (full_node_1.full_node.blockchain.get_peak().height
if full_node_1.full_node.blockchain.get_peak()
is not None else -1)
incoming_queue, node_id = await add_dummy_connection(server_1, 12312)
fake_peer = server_1.all_connections[node_id]
# Mempool has capacity of 100, make 110 unspents that we can use
puzzle_hashes = []
# Makes a bunch of coins
for i in range(20):
conditions_dict: Dict = {ConditionOpcode.CREATE_COIN: []}
# This should fit in one transaction
for _ in range(100):
receiver_puzzlehash = wallet_receiver.get_new_puzzlehash()
puzzle_hashes.append(receiver_puzzlehash)
output = ConditionWithArgs(
ConditionOpcode.CREATE_COIN,
[receiver_puzzlehash,
int_to_bytes(100000000)])
conditions_dict[ConditionOpcode.CREATE_COIN].append(output)
spend_bundle = wallet_a.generate_signed_transaction(
100,
puzzle_hashes[0],
get_future_reward_coins(blocks[1 + i])[0],
condition_dic=conditions_dict,
)
assert spend_bundle is not None
respond_transaction_2 = fnp.RespondTransaction(spend_bundle)
await full_node_1.respond_transaction(respond_transaction_2,
fake_peer)
blocks = bt.get_consecutive_blocks(
1,
block_list_input=blocks,
guarantee_transaction_block=True,
transaction_data=spend_bundle,
)
await full_node_1.full_node.respond_block(
fnp.RespondBlock(blocks[-1]), fake_peer)
await time_out_assert(10, node_height_at_least, True, full_node_1,
start_height + 20)
spend_bundles = []
spend_bundle_ids = []
# Fill mempool
for puzzle_hash in puzzle_hashes[1:]:
coin_record = (await full_node_1.full_node.coin_store.
get_coin_records_by_puzzle_hash(True,
puzzle_hash))[0]
receiver_puzzlehash = wallet_receiver.get_new_puzzlehash()
if puzzle_hash == puzzle_hashes[-1]:
fee = 100000000 # 100 million (20 fee per cost)
else:
fee = random.randint(1, 100000000)
spend_bundle = wallet_receiver.generate_signed_transaction(
uint64(500), receiver_puzzlehash, coin_record.coin, fee=fee)
spend_bundles.append(spend_bundle)
spend_bundle_ids.append(spend_bundle.get_hash())
pr = cProfile.Profile()
pr.enable()
start = time.time()
num_tx: int = 0
for spend_bundle, spend_bundle_id in zip(spend_bundles,
spend_bundle_ids):
num_tx += 1
respond_transaction = fnp.RespondTransaction(spend_bundle)
await full_node_1.respond_transaction(respond_transaction,
fake_peer)
request = fnp.RequestTransaction(spend_bundle_id)
req = await full_node_1.request_transaction(request)
if req is None:
break
log.warning(f"Num Tx: {num_tx}")
log.warning(f"Time for mempool: {time.time() - start}")
pr.create_stats()
pr.dump_stats("./mempool-benchmark.pstats")
# Create an unfinished block
peak = full_node_1.full_node.blockchain.get_peak()
assert peak is not None
curr: BlockRecord = peak
while not curr.is_transaction_block:
curr = full_node_1.full_node.blockchain.block_record(
curr.prev_hash)
mempool_bundle = await full_node_1.full_node.mempool_manager.create_bundle_from_mempool(
curr.header_hash)
if mempool_bundle is None:
spend_bundle = None
else:
spend_bundle = mempool_bundle[0]
current_blocks = await full_node_1.get_all_full_blocks()
blocks = bt.get_consecutive_blocks(
1,
transaction_data=spend_bundle,
block_list_input=current_blocks,
guarantee_transaction_block=True,
)
block = blocks[-1]
unfinished = UnfinishedBlock(
block.finished_sub_slots,
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,
[],
)
pr = cProfile.Profile()
pr.enable()
start = time.time()
res = await full_node_1.respond_unfinished_block(
fnp.RespondUnfinishedBlock(unfinished), fake_peer)
log.warning(f"Res: {res}")
log.warning(f"Time for unfinished: {time.time() - start}")
pr.create_stats()
pr.dump_stats("./unfinished-benchmark.pstats")
pr = cProfile.Profile()
pr.enable()
start = time.time()
# No transactions generator, the full node already cached it from the unfinished block
block_small = dataclasses.replace(block, transactions_generator=None)
res = await full_node_1.full_node.respond_block(
fnp.RespondBlock(block_small))
log.warning(f"Res: {res}")
log.warning(f"Time for full block: {time.time() - start}")
pr.create_stats()
pr.dump_stats("./full-block-benchmark.pstats")
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
pid = list(blocks[-1].get_included_reward_coins())[0].parent_coin_info
pid_2 = list(blocks[-1].get_included_reward_coins())[1].parent_coin_info
coins = await client.get_coin_records_by_parent_ids([pid, pid_2])
print(coins)
assert len(coins) == 2
additions, removals = await client.get_additions_and_removals(blocks[-1].header_hash)
assert len(additions) >= 2 and len(removals) == 0
wallet = WalletTool(full_node_api_1.full_node.constants)
wallet_receiver = WalletTool(full_node_api_1.full_node.constants, 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)
coin = spend_bundle.additions()[0]
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
)
assert (await client.get_coin_record_by_name(coin.name())) is None
await full_node_api_1.farm_new_transaction_block(FarmNewBlockProtocol(ph_2))
assert (await client.get_coin_record_by_name(coin.name())).coin == coin
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_hashes([ph_receiver, ph])) == 5
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()
assert NodeType(connections[0]["type"]) == NodeType.FULL_NODE.value
assert len(await client.get_connections(NodeType.FULL_NODE)) == 1
assert len(await client.get_connections(NodeType.FARMER)) == 0
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()
unfinished_block = UnfinishedBlock(
[end_of_subslot_bundle],
reward_chain_block.get_unfinished(),
vdf_proof,
vdf_proof,
foliage,
foliage_transaction_block,
transactions_info,
SerializedProgram.from_bytes(
bytes.fromhex(
"ff01ffff33ffa0f8912302fb33b8188046662785704afc3dd945074e4b45499a7173946e044695ff8203e880ffff33ffa03eaa52e850322dbc281c6b922e9d8819c7b4120ee054c4aa79db50be516a2bcaff8207d08080"
)),
[uint32(1862532955)],
)
respond_unfinished_block = full_node_protocol.RespondUnfinishedBlock(
unfinished_block)
new_signage_point_or_end_of_subslot = full_node_protocol.NewSignagePointOrEndOfSubSlot(
bytes32(
bytes.fromhex(
"f945510ccea927f832635e56bc20315c92943e108d2b458ac91a290a82e02997")
),
bytes32(
bytes.fromhex(
"27a16b348971e5dfb258e7a01f0b300acbecf8339476afd144e8520f1981833b")
),
uint8(102),
bytes32(
bytes.fromhex(
"a619471c0ba0b8b8b92b7b2cb1241c2fbb2324c4f1a20a01eb7dcc0027393a56")
),