async def test_signage_points(self, two_nodes, empty_blockchain):
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
peer = await connect_and_get_peer(server_1, server_2)
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)
# Only provide one
res = await client.get_recent_signage_point_or_eos(None, None)
assert res is None
res = await client.get_recent_signage_point_or_eos(
std_hash(b"0"), std_hash(b"1"))
assert res is None
# Not found
res = await client.get_recent_signage_point_or_eos(
std_hash(b"0"), None)
assert res is None
res = await client.get_recent_signage_point_or_eos(
None, std_hash(b"0"))
assert res is None
blocks = bt.get_consecutive_blocks(5)
for block in blocks:
await full_node_api_1.full_node.respond_block(
full_node_protocol.RespondBlock(block))
blocks = bt.get_consecutive_blocks(1,
block_list_input=blocks,
skip_slots=1,
force_overflow=True)
blockchain = full_node_api_1.full_node.blockchain
second_blockchain = empty_blockchain
for block in blocks:
await second_blockchain.receive_block(block)
# Creates a signage point based on the last block
peak_2 = second_blockchain.get_peak()
sp: SignagePoint = get_signage_point(
test_constants,
blockchain,
peak_2,
peak_2.ip_sub_slot_total_iters(test_constants),
uint8(4),
[],
peak_2.sub_slot_iters,
)
# Don't have SP yet
res = await client.get_recent_signage_point_or_eos(
sp.cc_vdf.output.get_hash(), None)
assert res is None
# Add the last block
await full_node_api_1.full_node.respond_block(
full_node_protocol.RespondBlock(blocks[-1]))
await full_node_api_1.respond_signage_point(
full_node_protocol.RespondSignagePoint(uint8(4), sp.cc_vdf,
sp.cc_proof, sp.rc_vdf,
sp.rc_proof), peer)
assert full_node_api_1.full_node.full_node_store.get_signage_point(
sp.cc_vdf.output.get_hash()) is not None
# Properly fetch a signage point
res = await client.get_recent_signage_point_or_eos(
sp.cc_vdf.output.get_hash(), None)
assert res is not None
assert "eos" not in res
assert res["signage_point"] == sp
assert not res["reverted"]
blocks = bt.get_consecutive_blocks(1,
block_list_input=blocks,
skip_slots=1)
selected_eos = blocks[-1].finished_sub_slots[0]
# Don't have EOS yet
res = await client.get_recent_signage_point_or_eos(
None, selected_eos.challenge_chain.get_hash())
assert res is None
# Properly fetch an EOS
for eos in blocks[-1].finished_sub_slots:
await full_node_api_1.full_node.respond_end_of_sub_slot(
full_node_protocol.RespondEndOfSubSlot(eos), peer)
res = await client.get_recent_signage_point_or_eos(
None, selected_eos.challenge_chain.get_hash())
assert res is not None
assert "signage_point" not in res
assert res["eos"] == selected_eos
assert not res["reverted"]
# Do another one but without sending the slot
await full_node_api_1.full_node.respond_block(
full_node_protocol.RespondBlock(blocks[-1]))
blocks = bt.get_consecutive_blocks(1,
block_list_input=blocks,
skip_slots=1)
selected_eos = blocks[-1].finished_sub_slots[-1]
await full_node_api_1.full_node.respond_block(
full_node_protocol.RespondBlock(blocks[-1]))
res = await client.get_recent_signage_point_or_eos(
None, selected_eos.challenge_chain.get_hash())
assert res is not None
assert "signage_point" not in res
assert res["eos"] == selected_eos
assert not res["reverted"]
# Perform a reorg
blocks = bt.get_consecutive_blocks(12, seed=b"1234")
for block in blocks:
await full_node_api_1.full_node.respond_block(
full_node_protocol.RespondBlock(block))
# Signage point is no longer in the blockchain
res = await client.get_recent_signage_point_or_eos(
sp.cc_vdf.output.get_hash(), None)
assert res["reverted"]
assert res["signage_point"] == sp
assert "eos" not in res
# EOS is no longer in the blockchain
res = await client.get_recent_signage_point_or_eos(
None, selected_eos.challenge_chain.get_hash())
assert res is not None
assert "signage_point" not in res
assert res["eos"] == selected_eos
assert res["reverted"]
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 = 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(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)
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_wallet_make_transaction(self, two_wallet_nodes):
test_rpc_port = uint16(21529)
test_rpc_port_node = uint16(21530)
num_blocks = 5
full_nodes, wallets = two_wallet_nodes
full_node_api = full_nodes[0]
full_node_server = full_node_api.full_node.server
wallet_node, server_2 = wallets[0]
wallet_node_2, server_3 = wallets[1]
wallet = wallet_node.wallet_state_manager.main_wallet
wallet_2 = wallet_node_2.wallet_state_manager.main_wallet
ph = await wallet.get_new_puzzlehash()
ph_2 = await wallet_2.get_new_puzzlehash()
await server_2.start_client(
PeerInfo("localhost", uint16(full_node_server._port)), None)
for i in range(0, num_blocks):
await full_node_api.farm_new_transaction_block(
FarmNewBlockProtocol(ph))
initial_funds = sum([
calculate_pool_reward(uint32(i)) +
calculate_base_farmer_reward(uint32(i))
for i in range(1, num_blocks)
])
initial_funds_eventually = sum([
calculate_pool_reward(uint32(i)) +
calculate_base_farmer_reward(uint32(i))
for i in range(1, num_blocks + 1)
])
wallet_rpc_api = WalletRpcApi(wallet_node)
config = bt.config
hostname = config["self_hostname"]
daemon_port = config["daemon_port"]
def stop_node_cb():
pass
full_node_rpc_api = FullNodeRpcApi(full_node_api.full_node)
rpc_cleanup_node = await start_rpc_server(
full_node_rpc_api,
hostname,
daemon_port,
test_rpc_port_node,
stop_node_cb,
bt.root_path,
config,
connect_to_daemon=False,
)
rpc_cleanup = await start_rpc_server(
wallet_rpc_api,
hostname,
daemon_port,
test_rpc_port,
stop_node_cb,
bt.root_path,
config,
connect_to_daemon=False,
)
await time_out_assert(5, wallet.get_confirmed_balance, initial_funds)
await time_out_assert(5, wallet.get_unconfirmed_balance, initial_funds)
client = await WalletRpcClient.create(self_hostname, test_rpc_port,
bt.root_path, config)
client_node = await FullNodeRpcClient.create(self_hostname,
test_rpc_port_node,
bt.root_path, config)
try:
addr = encode_puzzle_hash(
await wallet_node_2.wallet_state_manager.main_wallet.
get_new_puzzlehash(), "xch")
tx_amount = 15600000
try:
await client.send_transaction("1", 100000000000000001, addr)
raise Exception("Should not create high value tx")
except ValueError:
pass
# Tests sending a basic transaction
tx = await client.send_transaction("1", tx_amount, addr)
transaction_id = tx.name
async def tx_in_mempool():
tx = await client.get_transaction("1", transaction_id)
return tx.is_in_mempool()
await time_out_assert(5, tx_in_mempool, True)
await time_out_assert(5, wallet.get_unconfirmed_balance,
initial_funds - tx_amount)
assert (
await client.get_wallet_balance("1")
)["unconfirmed_wallet_balance"] == initial_funds - tx_amount
assert (await client.get_wallet_balance("1")
)["confirmed_wallet_balance"] == initial_funds
for i in range(0, 5):
await client.farm_block(encode_puzzle_hash(ph_2, "xch"))
await asyncio.sleep(0.5)
async def eventual_balance():
return (
await
client.get_wallet_balance("1"))["confirmed_wallet_balance"]
await time_out_assert(5, eventual_balance,
initial_funds_eventually - tx_amount)
# Tests offline signing
ph_3 = await wallet_node_2.wallet_state_manager.main_wallet.get_new_puzzlehash(
)
ph_4 = await wallet_node_2.wallet_state_manager.main_wallet.get_new_puzzlehash(
)
ph_5 = await wallet_node_2.wallet_state_manager.main_wallet.get_new_puzzlehash(
)
# Test basic transaction to one output
signed_tx_amount = 888000
tx_res = await client.create_signed_transaction([{
"amount":
signed_tx_amount,
"puzzle_hash":
ph_3
}])
assert tx_res["success"]
assert tx_res["signed_tx"]["fee_amount"] == 0
assert tx_res["signed_tx"]["amount"] == signed_tx_amount
assert len(tx_res["signed_tx"]
["additions"]) == 2 # The output and the change
assert any([
addition["amount"] == signed_tx_amount
for addition in tx_res["signed_tx"]["additions"]
])
push_res = await client_node.push_tx(
SpendBundle.from_json_dict(tx_res["signed_tx"]["spend_bundle"])
)
assert push_res["success"]
assert (
await client.get_wallet_balance("1")
)["confirmed_wallet_balance"] == initial_funds_eventually - tx_amount
for i in range(0, 5):
await client.farm_block(encode_puzzle_hash(ph_2, "xch"))
await asyncio.sleep(0.5)
await time_out_assert(
5, eventual_balance,
initial_funds_eventually - tx_amount - signed_tx_amount)
# Test transaction to two outputs, from a specified coin, with a fee
coin_to_spend = None
for addition in tx_res["signed_tx"]["additions"]:
if addition["amount"] != signed_tx_amount:
coin_to_spend = Coin.from_json_dict(addition)
assert coin_to_spend is not None
tx_res = await client.create_signed_transaction(
[{
"amount": 444,
"puzzle_hash": ph_4
}, {
"amount": 999,
"puzzle_hash": ph_5
}],
coins=[coin_to_spend],
fee=100,
)
assert tx_res["success"]
assert tx_res["signed_tx"]["fee_amount"] == 100
assert tx_res["signed_tx"]["amount"] == 444 + 999
assert len(tx_res["signed_tx"]
["additions"]) == 3 # The outputs and the change
assert any([
addition["amount"] == 444
for addition in tx_res["signed_tx"]["additions"]
])
assert any([
addition["amount"] == 999
for addition in tx_res["signed_tx"]["additions"]
])
assert (
sum([rem["amount"]
for rem in tx_res["signed_tx"]["removals"]]) -
sum([ad["amount"]
for ad in tx_res["signed_tx"]["additions"]]) == 100)
push_res = await client_node.push_tx(
SpendBundle.from_json_dict(tx_res["signed_tx"]["spend_bundle"])
)
assert push_res["success"]
for i in range(0, 5):
await client.farm_block(encode_puzzle_hash(ph_2, "xch"))
await asyncio.sleep(0.5)
await time_out_assert(
5, eventual_balance, initial_funds_eventually - tx_amount -
signed_tx_amount - 444 - 999 - 100)
address = await client.get_next_address("1", True)
assert len(address) > 10
transactions = await client.get_transactions("1")
assert len(transactions) > 1
pks = await client.get_public_keys()
assert len(pks) == 1
assert (await client.get_height_info()) > 0
sk_dict = await client.get_private_key(pks[0])
assert sk_dict["fingerprint"] == pks[0]
assert sk_dict["sk"] is not None
assert sk_dict["pk"] is not None
assert sk_dict["seed"] is not None
mnemonic = await client.generate_mnemonic()
assert len(mnemonic) == 24
await client.add_key(mnemonic)
pks = await client.get_public_keys()
assert len(pks) == 2
await client.log_in_and_skip(pks[1])
sk_dict = await client.get_private_key(pks[1])
assert sk_dict["fingerprint"] == pks[1]
await client.delete_key(pks[0])
await client.log_in_and_skip(pks[1])
assert len(await client.get_public_keys()) == 1
assert not (await client.get_sync_status())
wallets = await client.get_wallets()
assert len(wallets) == 1
balance = await client.get_wallet_balance(wallets[0]["id"])
assert balance["unconfirmed_wallet_balance"] == 0
test_wallet_backup_path = Path("test_wallet_backup_file")
await client.create_backup(test_wallet_backup_path)
assert test_wallet_backup_path.exists()
test_wallet_backup_path.unlink()
try:
await client.send_transaction(wallets[0]["id"], 100, addr)
raise Exception("Should not create tx if no balance")
except ValueError:
pass
await client.delete_all_keys()
assert len(await client.get_public_keys()) == 0
finally:
# Checks that the RPC manages to stop the node
client.close()
client_node.close()
await client.await_closed()
await client_node.await_closed()
await rpc_cleanup()
await rpc_cleanup_node()