def show_all_keys():
"""
Prints all keys and mnemonics (if available).
"""
root_path = DEFAULT_ROOT_PATH
config = load_config(root_path, "config.yaml")
private_keys = keychain.get_all_private_keys()
selected = config["selected_network"]
prefix = config["network_overrides"]["config"][selected]["address_prefix"]
if len(private_keys) == 0:
print("There are no saved private keys")
return
print("Showing all private keys:")
for sk, seed in private_keys:
print("")
print("Fingerprint:", sk.get_g1().get_fingerprint())
print("Master public key (m):", sk.get_g1())
print("Master private key (m):", bytes(sk).hex())
print(
"Farmer public key (m/12381/8444/0/0)::",
master_sk_to_farmer_sk(sk).get_g1(),
)
print("Pool public key (m/12381/8444/1/0):", master_sk_to_pool_sk(sk).get_g1())
print(
"First wallet key (m/12381/8444/2/0):",
master_sk_to_wallet_sk(sk, uint32(0)).get_g1(),
)
print(
"First wallet address:",
encode_puzzle_hash(create_puzzlehash_for_pk(master_sk_to_wallet_sk(sk, uint32(0)).get_g1()), prefix),
)
assert seed is not None
mnemonic = bytes_to_mnemonic(seed)
print(" Mnemonic seed (24 secret words):")
print(mnemonic)
def get_private_key_for_puzzle_hash(self, puzzle_hash: bytes32) -> PrivateKey:
if puzzle_hash in self.puzzle_pk_cache:
child = self.puzzle_pk_cache[puzzle_hash]
private = master_sk_to_wallet_sk(self.private_key, uint32(child))
# pubkey = private.get_g1()
return private
else:
for child in range(self.next_address):
pubkey = master_sk_to_wallet_sk(self.private_key, uint32(child)).get_g1()
if puzzle_hash == puzzle_for_pk(bytes(pubkey)).get_tree_hash():
return master_sk_to_wallet_sk(self.private_key, uint32(child))
raise ValueError(f"Do not have the keys for puzzle hash {puzzle_hash}")
async def test_farmer_reward_target_endpoints(environment):
(
farmer_service,
farmer_rpc_api,
farmer_rpc_client,
harvester_service,
harvester_rpc_api,
harvester_rpc_client,
) = environment
farmer_api = farmer_service._api
targets_1 = await farmer_rpc_client.get_reward_targets(False)
assert "have_pool_sk" not in targets_1
assert "have_farmer_sk" not in targets_1
targets_2 = await farmer_rpc_client.get_reward_targets(True)
assert targets_2["have_pool_sk"] and targets_2["have_farmer_sk"]
new_ph: bytes32 = create_puzzlehash_for_pk(
master_sk_to_wallet_sk(bt.farmer_master_sk, uint32(10)).get_g1())
new_ph_2: bytes32 = create_puzzlehash_for_pk(
master_sk_to_wallet_sk(bt.pool_master_sk, uint32(472)).get_g1())
await farmer_rpc_client.set_reward_targets(
encode_puzzle_hash(new_ph, "xch"), encode_puzzle_hash(new_ph_2, "xch"))
targets_3 = await farmer_rpc_client.get_reward_targets(True)
assert decode_puzzle_hash(targets_3["farmer_target"]) == new_ph
assert decode_puzzle_hash(targets_3["pool_target"]) == new_ph_2
assert targets_3["have_pool_sk"] and targets_3["have_farmer_sk"]
new_ph_3: bytes32 = create_puzzlehash_for_pk(
master_sk_to_wallet_sk(bt.pool_master_sk, uint32(1888)).get_g1())
await farmer_rpc_client.set_reward_targets(
None, encode_puzzle_hash(new_ph_3, "xch"))
targets_4 = await farmer_rpc_client.get_reward_targets(True)
assert decode_puzzle_hash(targets_4["farmer_target"]) == new_ph
assert decode_puzzle_hash(targets_4["pool_target"]) == new_ph_3
assert not targets_4["have_pool_sk"] and targets_3["have_farmer_sk"]
root_path = farmer_api.farmer._root_path
config = load_config(root_path, "config.yaml")
assert config["farmer"]["xch_target_address"] == encode_puzzle_hash(
new_ph, "xch")
assert config["pool"]["xch_target_address"] == encode_puzzle_hash(
new_ph_3, "xch")
new_ph_3_encoded = encode_puzzle_hash(new_ph_3, "xch")
added_char = new_ph_3_encoded + "a"
with pytest.raises(ValueError):
await farmer_rpc_client.set_reward_targets(None, added_char)
replaced_char = new_ph_3_encoded[0:-1] + "a"
with pytest.raises(ValueError):
await farmer_rpc_client.set_reward_targets(None, replaced_char)
def get_reward_targets(self, search_for_private_key: bool) -> Dict:
if search_for_private_key:
all_sks = self.keychain.get_all_private_keys()
stop_searching_for_farmer, stop_searching_for_pool = False, False
for i in range(500):
if stop_searching_for_farmer and stop_searching_for_pool and i > 0:
break
for sk, _ in all_sks:
ph = create_puzzlehash_for_pk(
master_sk_to_wallet_sk(sk, uint32(i)).get_g1())
if ph == self.farmer_target:
stop_searching_for_farmer = True
if ph == self.pool_target:
stop_searching_for_pool = True
return {
"farmer_target": self.farmer_target_encoded,
"pool_target": self.pool_target_encoded,
"have_farmer_sk": stop_searching_for_farmer,
"have_pool_sk": stop_searching_for_pool,
}
return {
"farmer_target": self.farmer_target_encoded,
"pool_target": self.pool_target_encoded,
}
async def get_keys(self, puzzle_hash: bytes32) -> Optional[Tuple[G1Element, PrivateKey]]:
index_for_puzzlehash = await self.puzzle_store.index_for_puzzle_hash(puzzle_hash)
if index_for_puzzlehash is None:
raise ValueError(f"No key for this puzzlehash {puzzle_hash})")
private = master_sk_to_wallet_sk(self.private_key, index_for_puzzlehash)
pubkey = private.get_g1()
return pubkey, private
async def generate_eve_spend(self, coin: Coin, full_puzzle: Program,
innerpuz: Program):
assert self.did_info.origin_coin is not None
# innerpuz solution is (mode amount message my_id my_puzhash parent_innerpuzhash_amounts_for_recovery_ids)
innersol = Program.to([
0, coin.amount, coin.puzzle_hash,
coin.name(), coin.puzzle_hash, []
])
# full solution is (parent_info my_amount innersolution)
fullsol = Program.to([
[
self.did_info.origin_coin.parent_coin_info,
self.did_info.origin_coin.amount
],
coin.parent_coin_info,
coin.amount,
innersol,
])
list_of_solutions = [CoinSolution(coin, full_puzzle, fullsol)]
# sign for AGG_SIG_ME
message = (
Program.to([coin.amount, coin.puzzle_hash]).get_tree_hash() +
coin.name() +
self.wallet_state_manager.constants.AGG_SIG_ME_ADDITIONAL_DATA)
pubkey = did_wallet_puzzles.get_pubkey_from_innerpuz(innerpuz)
index = await self.wallet_state_manager.puzzle_store.index_for_pubkey(
pubkey)
private = master_sk_to_wallet_sk(self.wallet_state_manager.private_key,
index)
signature = AugSchemeMPL.sign(private, message)
sigs = [signature]
aggsig = AugSchemeMPL.aggregate(sigs)
spend_bundle = SpendBundle(list_of_solutions, aggsig)
return spend_bundle
async def create_spend(self, puzhash: bytes32):
assert self.did_info.current_inner is not None
coins = await self.select_coins(1)
assert coins is not None
coin = coins.pop()
# innerpuz solution is (mode amount new_puz identity my_puz)
innersol: Program = Program.to([0, coin.amount, puzhash, coin.name(), coin.puzzle_hash])
# full solution is (corehash parent_info my_amount innerpuz_reveal solution)
innerpuz: Program = self.did_info.current_inner
full_puzzle: Program = did_wallet_puzzles.create_fullpuz(
innerpuz,
self.did_info.my_did,
)
parent_info = await self.get_parent_for_coin(coin)
assert parent_info is not None
fullsol = Program.to(
[
[
parent_info.parent_name,
parent_info.inner_puzzle_hash,
parent_info.amount,
],
coin.amount,
innersol,
]
)
list_of_solutions = [CoinSolution(coin, full_puzzle, fullsol)]
# sign for AGG_SIG_ME
message = bytes(puzhash) + bytes(coin.name())
pubkey = did_wallet_puzzles.get_pubkey_from_innerpuz(innerpuz)
index = await self.wallet_state_manager.puzzle_store.index_for_pubkey(pubkey)
private = master_sk_to_wallet_sk(self.wallet_state_manager.private_key, index)
signature = AugSchemeMPL.sign(private, message)
# assert signature.validate([signature.PkMessagePair(pubkey, message)])
sigs = [signature]
aggsig = AugSchemeMPL.aggregate(sigs)
spend_bundle = SpendBundle(list_of_solutions, aggsig)
did_record = TransactionRecord(
confirmed_at_height=uint32(0),
created_at_time=uint64(int(time.time())),
to_puzzle_hash=puzhash,
amount=uint64(coin.amount),
fee_amount=uint64(0),
confirmed=False,
sent=uint32(0),
spend_bundle=spend_bundle,
additions=spend_bundle.additions(),
removals=spend_bundle.removals(),
wallet_id=self.wallet_info.id,
sent_to=[],
trade_id=None,
type=uint32(TransactionType.OUTGOING_TX.value),
name=token_bytes(),
)
await self.standard_wallet.push_transaction(did_record)
return spend_bundle
def get_new_puzzle(self) -> bytes32:
next_address_index: uint32 = self.get_next_address_index()
pubkey = master_sk_to_wallet_sk(self.private_key, next_address_index).get_g1()
self.pubkey_num_lookup[bytes(pubkey)] = next_address_index
puzzle = puzzle_for_pk(bytes(pubkey))
self.puzzle_pk_cache[puzzle.get_tree_hash()] = next_address_index
return puzzle
def show_all_keys(show_mnemonic: bool):
"""
Prints all keys and mnemonics (if available).
"""
root_path = DEFAULT_ROOT_PATH
config = load_config(root_path, "config.yaml")
private_keys = keychain.get_all_private_keys()
selected = config["selected_network"]
prefix = config["network_overrides"]["config"][selected]["address_prefix"]
if len(private_keys) == 0:
print("There are no saved private keys")
return None
msg = "Showing all public keys derived from your private keys:"
if show_mnemonic:
msg = "Showing all public and private keys"
print(msg)
result_list = []
for sk, seed in private_keys:
# print("")
# print("Fingerprint:", sk.get_g1().get_fingerprint())
# print("Master public key (m):", sk.get_g1())
# print(
# "Farmer public key (m/12381/8444/0/0):",
# master_sk_to_farmer_sk(sk).get_g1(),
# )
# print("Pool public key (m/12381/8444/1/0):", master_sk_to_pool_sk(sk).get_g1())
# print(
# "First wallet address:",
# encode_puzzle_hash(create_puzzlehash_for_pk(master_sk_to_wallet_sk(sk, uint32(0)).get_g1()), prefix),
# )
# assert seed is not None
# print("Master private key (m):", bytes(sk).hex())
# print(
# "First wallet secret key (m/12381/8444/2/0):",
# master_sk_to_wallet_sk(sk, uint32(0)).get_g1(),
# )
mnemonic = bytes_to_mnemonic(seed)
# print(" Mnemonic seed (24 secret words):")
# print(mnemonic)
data = {
"fingerprint":
sk.get_g1().get_fingerprint(),
"mnemonic":
','.join(mnemonic.split()),
"address":
encode_puzzle_hash(
create_puzzlehash_for_pk(
master_sk_to_wallet_sk(sk, uint32(0)).get_g1()), prefix),
"master":
sk.get_g1(),
"farmer":
master_sk_to_farmer_sk(sk).get_g1(),
"pool":
master_sk_to_pool_sk(sk).get_g1(),
}
result_list.append(data)
return result_list
def mnemonic():
# mnemonic = "imitate obvious arch square fan bike thumb hedgehog crystal innocent shoe glare share father romance local size gloom hurt maid denial weapon wave bulb"
mnemonic = "turn acquire ring mind empower ahead section often habit sick sail mountain pen repair catch drum insect file dry trend venue junk novel laptop"
seed = mnemonic_to_seed(mnemonic, "")
master_private_key = AugSchemeMPL.key_gen(seed)
child_private_key = master_sk_to_wallet_sk(master_private_key, 0)
child_public_key = child_private_key.get_g1()
puzzle = puzzle_for_pk(child_public_key)
puzzle_hash = puzzle.get_tree_hash()
address = encode_puzzle_hash(puzzle_hash, "txch")
async def get_keys(self, puzzle_hash: bytes32) -> Tuple[G1Element, PrivateKey]:
"""
Returns keys for puzzle_hash.
"""
index_for_puzzlehash = await self.wallet_state_manager.puzzle_store.index_for_puzzle_hash_and_wallet(
puzzle_hash, self.id()
)
if index_for_puzzlehash is None:
raise ValueError(f"index_for_puzzlehash is None ph {puzzle_hash}")
private = master_sk_to_wallet_sk(self.private_key, index_for_puzzlehash)
pubkey = private.get_g1()
return pubkey, private
async def get_keys_pk(self, clawback_pubkey: bytes):
"""
Return keys for pubkey
"""
index_for_pubkey = await self.wallet_state_manager.puzzle_store.index_for_pubkey(
G1Element.from_bytes(clawback_pubkey))
if index_for_pubkey is None:
raise ValueError(
f"index_for_pubkey is None pk {clawback_pubkey.hex()}")
private = master_sk_to_wallet_sk(self.private_key, index_for_pubkey)
pubkey = private.get_g1()
return pubkey, private
async def test_address_sliding_window(self, wallet_node_100_pk, trusted):
full_nodes, wallets = wallet_node_100_pk
full_node_api = full_nodes[0]
server_1: ChiaServer = full_node_api.full_node.server
wallet_node, server_2 = wallets[0]
if trusted:
wallet_node.config["trusted_peers"] = {
server_1.node_id.hex(): server_1.node_id.hex()
}
else:
wallet_node.config["trusted_peers"] = {}
wallet = wallet_node.wallet_state_manager.main_wallet
await server_2.start_client(
PeerInfo(self_hostname, uint16(server_1._port)), None)
puzzle_hashes = []
for i in range(211):
pubkey = master_sk_to_wallet_sk(
wallet_node.wallet_state_manager.private_key, i).get_g1()
puzzle: Program = wallet.puzzle_for_pk(bytes(pubkey))
puzzle_hash: bytes32 = puzzle.get_tree_hash()
puzzle_hashes.append(puzzle_hash)
await full_node_api.farm_new_transaction_block(
FarmNewBlockProtocol(32 * b"0"))
await full_node_api.farm_new_transaction_block(
FarmNewBlockProtocol(puzzle_hashes[0]))
await full_node_api.farm_new_transaction_block(
FarmNewBlockProtocol(puzzle_hashes[210]))
await full_node_api.farm_new_transaction_block(
FarmNewBlockProtocol(puzzle_hashes[114]))
await full_node_api.farm_new_transaction_block(
FarmNewBlockProtocol(32 * b"0"))
await time_out_assert(15, wallet.get_confirmed_balance, 2 * 10**12)
await full_node_api.farm_new_transaction_block(
FarmNewBlockProtocol(puzzle_hashes[50]))
await full_node_api.farm_new_transaction_block(
FarmNewBlockProtocol(32 * b"0"))
await time_out_assert(15, wallet.get_confirmed_balance, 8 * 10**12)
await full_node_api.farm_new_transaction_block(
FarmNewBlockProtocol(puzzle_hashes[113]))
await full_node_api.farm_new_transaction_block(
FarmNewBlockProtocol(puzzle_hashes[209]))
await full_node_api.farm_new_transaction_block(
FarmNewBlockProtocol(32 * b"0"))
await time_out_assert(15, wallet.get_confirmed_balance, 12 * 10**12)
async def test_address_sliding_window(self, wallet_node_100_pk):
full_nodes, wallets = wallet_node_100_pk
full_node_api = full_nodes[0]
server_1: ChiaServer = full_node_api.full_node.server
wallet_node, server_2 = wallets[0]
wallet = wallet_node.wallet_state_manager.main_wallet
await server_2.start_client(
PeerInfo(self_hostname, uint16(server_1._port)), None)
puzzle_hashes = []
for i in range(211):
pubkey = master_sk_to_wallet_sk(
wallet_node.wallet_state_manager.private_key, i).get_g1()
puzzle: Program = wallet.puzzle_for_pk(bytes(pubkey))
puzzle_hash: bytes32 = puzzle.get_tree_hash()
puzzle_hashes.append(puzzle_hash)
# TODO: fix after merging new wallet. These 210 and 114 should be found
await full_node_api.farm_new_transaction_block(
FarmNewBlockProtocol(32 * b"0"))
await full_node_api.farm_new_transaction_block(
FarmNewBlockProtocol(puzzle_hashes[0]))
await full_node_api.farm_new_transaction_block(
FarmNewBlockProtocol(puzzle_hashes[210]))
await full_node_api.farm_new_transaction_block(
FarmNewBlockProtocol(puzzle_hashes[114]))
await full_node_api.farm_new_transaction_block(
FarmNewBlockProtocol(32 * b"0"))
await time_out_assert(5, wallet.get_confirmed_balance, 2 * 10**12)
await full_node_api.farm_new_transaction_block(
FarmNewBlockProtocol(puzzle_hashes[50]))
await full_node_api.farm_new_transaction_block(
FarmNewBlockProtocol(32 * b"0"))
await time_out_assert(5, wallet.get_confirmed_balance, 4 * 10**12)
await full_node_api.farm_new_transaction_block(
FarmNewBlockProtocol(puzzle_hashes[113]))
await full_node_api.farm_new_transaction_block(
FarmNewBlockProtocol(puzzle_hashes[209]))
await full_node_api.farm_new_transaction_block(
FarmNewBlockProtocol(32 * b"0"))
await time_out_assert(5, wallet.get_confirmed_balance, 8 * 10**12)
async def create_rl_user(wallet_state_manager: Any, ):
async with wallet_state_manager.puzzle_store.lock:
unused: Optional[
uint32] = await wallet_state_manager.puzzle_store.get_unused_derivation_path(
)
if unused is None:
await wallet_state_manager.create_more_puzzle_hashes()
unused = await wallet_state_manager.puzzle_store.get_unused_derivation_path(
)
assert unused is not None
private_key = wallet_state_manager.private_key
pubkey: G1Element = master_sk_to_wallet_sk(private_key,
unused).get_g1()
rl_info = RLInfo("user", None, bytes(pubkey), None, None, None,
None, None, False)
info_as_string = json.dumps(rl_info.to_json_dict())
await wallet_state_manager.user_store.create_wallet(
"RL User", WalletType.RATE_LIMITED, info_as_string)
wallet_info = await wallet_state_manager.user_store.get_last_wallet(
)
if wallet_info is None:
raise Exception("wallet_info is None")
self = await RLWallet.create(wallet_state_manager, wallet_info)
await wallet_state_manager.puzzle_store.add_derivation_paths([
DerivationRecord(
unused,
bytes32(token_bytes(32)),
pubkey,
WalletType.RATE_LIMITED,
wallet_info.id,
)
])
await wallet_state_manager.puzzle_store.set_used_up_to(unused)
await wallet_state_manager.add_new_wallet(self, self.id())
return self
async def create_rl_admin(wallet_state_manager: Any, ):
unused: Optional[
uint32] = await wallet_state_manager.puzzle_store.get_unused_derivation_path(
)
if unused is None:
await wallet_state_manager.create_more_puzzle_hashes()
unused = await wallet_state_manager.puzzle_store.get_unused_derivation_path(
)
assert unused is not None
private_key = master_sk_to_wallet_sk(wallet_state_manager.private_key,
unused)
pubkey_bytes: bytes = bytes(private_key.get_g1())
rl_info = RLInfo("admin", pubkey_bytes, None, None, None, None, None,
None, False)
info_as_string = json.dumps(rl_info.to_json_dict())
wallet_info: Optional[
WalletInfo] = await wallet_state_manager.user_store.create_wallet(
"RL Admin", WalletType.RATE_LIMITED, info_as_string)
if wallet_info is None:
raise Exception("wallet_info is None")
await wallet_state_manager.puzzle_store.add_derivation_paths([
DerivationRecord(
unused,
token_bytes(),
pubkey_bytes,
WalletType.RATE_LIMITED,
wallet_info.id,
)
])
await wallet_state_manager.puzzle_store.set_used_up_to(unused)
self = await RLWallet.create(wallet_state_manager, wallet_info)
await wallet_state_manager.add_new_wallet(self, self.id())
return self
def derive_wallet_address(
root_path: Path,
private_key: PrivateKey,
index: int,
count: int,
prefix: Optional[str],
non_observer_derivation: bool,
show_hd_path: bool,
):
"""
Generate wallet addresses using keys derived from the provided private key.
"""
if prefix is None:
config: Dict = load_config(root_path, "config.yaml")
selected: str = config["selected_network"]
prefix = config["network_overrides"]["config"][selected]["address_prefix"]
path_indices: List[int] = [12381, 8444, 2]
wallet_hd_path_root: str = "m/"
for i in path_indices:
wallet_hd_path_root += f"{i}{'n' if non_observer_derivation else ''}/"
for i in range(index, index + count):
if non_observer_derivation:
sk = master_sk_to_wallet_sk(private_key, uint32(i))
else:
sk = master_sk_to_wallet_sk_unhardened(private_key, uint32(i))
# Generate a wallet address using the standard p2_delegated_puzzle_or_hidden_puzzle puzzle
# TODO: consider generating addresses using other puzzles
address = encode_puzzle_hash(create_puzzlehash_for_pk(sk.get_g1()), prefix)
if show_hd_path:
print(
f"Wallet address {i} "
f"({wallet_hd_path_root + str(i) + ('n' if non_observer_derivation else '')}): {address}"
)
else:
print(f"Wallet address {i}: {address}")
async def create_attestment(self,
recovering_coin_name: bytes32,
newpuz: bytes32,
pubkey: G1Element,
filename=None) -> SpendBundle:
assert self.did_info.current_inner is not None
assert self.did_info.origin_coin is not None
coins = await self.select_coins(1)
assert coins is not None and coins != set()
coin = coins.pop()
message = did_wallet_puzzles.create_recovery_message_puzzle(
recovering_coin_name, newpuz, pubkey)
innermessage = message.get_tree_hash()
# innerpuz solution is (mode amount new_puz identity my_puz)
innersol = Program.to([
1, coin.amount, innermessage, recovering_coin_name,
coin.puzzle_hash
])
# full solution is (corehash parent_info my_amount innerpuz_reveal solution)
innerpuz: Program = self.did_info.current_inner
full_puzzle: Program = did_wallet_puzzles.create_fullpuz(
innerpuz,
self.did_info.origin_coin.puzzle_hash,
)
parent_info = await self.get_parent_for_coin(coin)
assert parent_info is not None
fullsol = Program.to([
[
self.did_info.origin_coin.parent_coin_info,
self.did_info.origin_coin.amount
],
[
parent_info.parent_name,
parent_info.inner_puzzle_hash,
parent_info.amount,
],
coin.amount,
innersol,
])
list_of_solutions = [CoinSolution(coin, full_puzzle, fullsol)]
message_spend = did_wallet_puzzles.create_spend_for_message(
coin.name(), recovering_coin_name, newpuz, pubkey)
message_spend_bundle = SpendBundle([message_spend],
AugSchemeMPL.aggregate([]))
# sign for AGG_SIG_ME
to_sign = Program.to([coin.puzzle_hash, coin.amount,
innermessage]).get_tree_hash()
message = to_sign + coin.name(
) + self.wallet_state_manager.constants.AGG_SIG_ME_ADDITIONAL_DATA
pubkey = did_wallet_puzzles.get_pubkey_from_innerpuz(innerpuz)
index = await self.wallet_state_manager.puzzle_store.index_for_pubkey(
pubkey)
private = master_sk_to_wallet_sk(self.wallet_state_manager.private_key,
index)
signature = AugSchemeMPL.sign(private, message)
# assert signature.validate([signature.PkMessagePair(pubkey, message)])
spend_bundle = SpendBundle(list_of_solutions, signature)
did_record = TransactionRecord(
confirmed_at_height=uint32(0),
created_at_time=uint64(int(time.time())),
to_puzzle_hash=coin.puzzle_hash,
amount=uint64(coin.amount),
fee_amount=uint64(0),
confirmed=False,
sent=uint32(0),
spend_bundle=spend_bundle,
additions=spend_bundle.additions(),
removals=spend_bundle.removals(),
wallet_id=self.wallet_info.id,
sent_to=[],
trade_id=None,
type=uint32(TransactionType.INCOMING_TX.value),
name=token_bytes(),
)
await self.standard_wallet.push_transaction(did_record)
if filename is not None:
f = open(filename, "w")
f.write(self.get_my_DID())
f.write(":")
f.write(bytes(message_spend_bundle).hex())
f.write(":")
parent = coin.parent_coin_info.hex()
innerpuzhash = self.did_info.current_inner.get_tree_hash().hex()
amount = coin.amount
f.write(parent)
f.write(":")
f.write(innerpuzhash)
f.write(":")
f.write(str(amount))
f.close()
return message_spend_bundle
async def test1(self, simulation):
test_rpc_port = uint16(21522)
test_rpc_port_2 = uint16(21523)
harvester, farmer_api = simulation
def stop_node_cb():
pass
def stop_node_cb_2():
pass
config = bt.config
hostname = config["self_hostname"]
daemon_port = config["daemon_port"]
farmer_rpc_api = FarmerRpcApi(farmer_api.farmer)
harvester_rpc_api = HarvesterRpcApi(harvester)
rpc_cleanup = await start_rpc_server(
farmer_rpc_api,
hostname,
daemon_port,
test_rpc_port,
stop_node_cb,
bt.root_path,
config,
connect_to_daemon=False,
)
rpc_cleanup_2 = await start_rpc_server(
harvester_rpc_api,
hostname,
daemon_port,
test_rpc_port_2,
stop_node_cb_2,
bt.root_path,
config,
connect_to_daemon=False,
)
try:
client = await FarmerRpcClient.create(self_hostname, test_rpc_port,
bt.root_path, config)
client_2 = await HarvesterRpcClient.create(self_hostname,
test_rpc_port_2,
bt.root_path, config)
async def have_connections():
return len(await client.get_connections()) > 0
await time_out_assert(15, have_connections, True)
assert (await client.get_signage_point(std_hash(b"2"))) is None
assert len(await client.get_signage_points()) == 0
async def have_signage_points():
return len(await client.get_signage_points()) > 0
sp = farmer_protocol.NewSignagePoint(std_hash(b"1"),
std_hash(b"2"),
std_hash(b"3"), uint64(1),
uint64(1000000), uint8(2))
await farmer_api.new_signage_point(sp)
await time_out_assert(5, have_signage_points, True)
assert (await client.get_signage_point(std_hash(b"2"))) is not None
async def have_plots():
return len((await client_2.get_plots())["plots"]) > 0
await time_out_assert(5, have_plots, True)
res = await client_2.get_plots()
num_plots = len(res["plots"])
assert num_plots > 0
plot_dir = get_plot_dir() / "subdir"
plot_dir.mkdir(parents=True, exist_ok=True)
plot_dir_sub = get_plot_dir() / "subdir" / "subsubdir"
plot_dir_sub.mkdir(parents=True, exist_ok=True)
plotter = DiskPlotter()
filename = "test_farmer_harvester_rpc_plot.plot"
filename_2 = "test_farmer_harvester_rpc_plot2.plot"
plotter.create_plot_disk(
str(plot_dir),
str(plot_dir),
str(plot_dir),
filename,
18,
stream_plot_info_pk(bt.pool_pk, bt.farmer_pk,
AugSchemeMPL.key_gen(bytes([4] * 32))),
token_bytes(32),
128,
0,
2000,
0,
False,
)
# Making a plot with a puzzle hash encoded into it instead of pk
plot_id_2 = token_bytes(32)
plotter.create_plot_disk(
str(plot_dir),
str(plot_dir),
str(plot_dir),
filename_2,
18,
stream_plot_info_ph(std_hash(b"random ph"), bt.farmer_pk,
AugSchemeMPL.key_gen(bytes([5] * 32))),
plot_id_2,
128,
0,
2000,
0,
False,
)
# Making the same plot, in a different dir. This should not be farmed
plotter.create_plot_disk(
str(plot_dir_sub),
str(plot_dir_sub),
str(plot_dir_sub),
filename_2,
18,
stream_plot_info_ph(std_hash(b"random ph"), bt.farmer_pk,
AugSchemeMPL.key_gen(bytes([5] * 32))),
plot_id_2,
128,
0,
2000,
0,
False,
)
res_2 = await client_2.get_plots()
assert len(res_2["plots"]) == num_plots
assert len(await client_2.get_plot_directories()) == 1
await client_2.add_plot_directory(str(plot_dir))
await client_2.add_plot_directory(str(plot_dir_sub))
assert len(await client_2.get_plot_directories()) == 3
res_2 = await client_2.get_plots()
assert len(res_2["plots"]) == num_plots + 2
await client_2.delete_plot(str(plot_dir / filename))
await client_2.delete_plot(str(plot_dir / filename_2))
await client_2.refresh_plots()
res_3 = await client_2.get_plots()
assert len(res_3["plots"]) == num_plots + 1
await client_2.remove_plot_directory(str(plot_dir))
assert len(await client_2.get_plot_directories()) == 2
targets_1 = await client.get_reward_targets(False)
assert "have_pool_sk" not in targets_1
assert "have_farmer_sk" not in targets_1
targets_2 = await client.get_reward_targets(True)
assert targets_2["have_pool_sk"] and targets_2["have_farmer_sk"]
new_ph: bytes32 = create_puzzlehash_for_pk(
master_sk_to_wallet_sk(bt.farmer_master_sk,
uint32(10)).get_g1())
new_ph_2: bytes32 = create_puzzlehash_for_pk(
master_sk_to_wallet_sk(bt.pool_master_sk,
uint32(472)).get_g1())
await client.set_reward_targets(
encode_puzzle_hash(new_ph, "xch"),
encode_puzzle_hash(new_ph_2, "xch"))
targets_3 = await client.get_reward_targets(True)
assert decode_puzzle_hash(targets_3["farmer_target"]) == new_ph
assert decode_puzzle_hash(targets_3["pool_target"]) == new_ph_2
assert targets_3["have_pool_sk"] and targets_3["have_farmer_sk"]
new_ph_3: bytes32 = create_puzzlehash_for_pk(
master_sk_to_wallet_sk(bt.pool_master_sk,
uint32(1888)).get_g1())
await client.set_reward_targets(
None, encode_puzzle_hash(new_ph_3, "xch"))
targets_4 = await client.get_reward_targets(True)
assert decode_puzzle_hash(targets_4["farmer_target"]) == new_ph
assert decode_puzzle_hash(targets_4["pool_target"]) == new_ph_3
assert not targets_4["have_pool_sk"] and targets_3["have_farmer_sk"]
root_path = farmer_api.farmer._root_path
config = load_config(root_path, "config.yaml")
assert config["farmer"][
"xch_target_address"] == encode_puzzle_hash(new_ph, "xch")
assert config["pool"]["xch_target_address"] == encode_puzzle_hash(
new_ph_3, "xch")
new_ph_3_encoded = encode_puzzle_hash(new_ph_3, "xch")
added_char = new_ph_3_encoded + "a"
with pytest.raises(ValueError):
await client.set_reward_targets(None, added_char)
replaced_char = new_ph_3_encoded[0:-1] + "a"
with pytest.raises(ValueError):
await client.set_reward_targets(None, replaced_char)
finally:
# Checks that the RPC manages to stop the node
client.close()
client_2.close()
await client.await_closed()
await client_2.await_closed()
await rpc_cleanup()
await rpc_cleanup_2()
def get_public_key(self, index: uint32) -> G1Element:
return master_sk_to_wallet_sk(self.private_key, index).get_g1()
def sign(self, value: bytes, pubkey: bytes) -> G2Element:
privatekey: PrivateKey = master_sk_to_wallet_sk(
self.private_key, self.pubkey_num_lookup[pubkey])
return AugSchemeMPL.sign(privatekey, value)
def check_keys(new_root: Path) -> None:
keychain: Keychain = Keychain()
all_sks = keychain.get_all_private_keys()
if len(all_sks) == 0:
print(
"No keys are present in the keychain. Generate them with 'chia keys generate'"
)
return
config: Dict = load_config(new_root, "config.yaml")
pool_child_pubkeys = [
master_sk_to_pool_sk(sk).get_g1() for sk, _ in all_sks
]
all_targets = []
stop_searching_for_farmer = "xch_target_address" not in config["farmer"]
stop_searching_for_pool = "xch_target_address" not in config["pool"]
number_of_ph_to_search = 500
selected = config["selected_network"]
prefix = config["network_overrides"]["config"][selected]["address_prefix"]
for i in range(number_of_ph_to_search):
if stop_searching_for_farmer and stop_searching_for_pool and i > 0:
break
for sk, _ in all_sks:
all_targets.append(
encode_puzzle_hash(
create_puzzlehash_for_pk(
master_sk_to_wallet_sk(sk, uint32(i)).get_g1()),
prefix))
if all_targets[-1] == config["farmer"].get("xch_target_address"):
stop_searching_for_farmer = True
if all_targets[-1] == config["pool"].get("xch_target_address"):
stop_searching_for_pool = True
# Set the destinations
if "xch_target_address" not in config["farmer"]:
print(
f"Setting the xch destination address for coinbase fees reward to {all_targets[0]}"
)
config["farmer"]["xch_target_address"] = all_targets[0]
elif config["farmer"]["xch_target_address"] not in all_targets:
print(
f"WARNING: using a farmer address which we don't have the private"
f" keys for. We searched the first {number_of_ph_to_search} addresses. Consider overriding "
f"{config['farmer']['xch_target_address']} with {all_targets[0]}")
if "pool" not in config:
config["pool"] = {}
if "xch_target_address" not in config["pool"]:
print(
f"Setting the xch destination address for coinbase reward to {all_targets[0]}"
)
config["pool"]["xch_target_address"] = all_targets[0]
elif config["pool"]["xch_target_address"] not in all_targets:
print(
f"WARNING: using a pool address which we don't have the private"
f" keys for. We searched the first {number_of_ph_to_search} addresses. Consider overriding "
f"{config['pool']['xch_target_address']} with {all_targets[0]}")
# Set the pool pks in the farmer
pool_pubkeys_hex = set(bytes(pk).hex() for pk in pool_child_pubkeys)
if "pool_public_keys" in config["farmer"]:
for pk_hex in config["farmer"]["pool_public_keys"]:
# Add original ones in config
pool_pubkeys_hex.add(pk_hex)
config["farmer"]["pool_public_keys"] = pool_pubkeys_hex
save_config(new_root, "config.yaml", config)
if __name__ == "__main__":
"""
Naive way to calculate cost ratio between vByte and CLVM cost unit.
AggSig has assigned cost of 20vBytes, simple CLVM program is benchmarked against it.
"""
wallet_tool = WalletTool()
benchmark_all_operators()
secret_key: PrivateKey = AugSchemeMPL.key_gen(bytes([2] * 32))
puzzles = []
solutions = []
private_keys = []
public_keys = []
for i in range(0, 1000):
private_key: PrivateKey = master_sk_to_wallet_sk(secret_key, uint32(i))
public_key = private_key.public_key()
solution = wallet_tool.make_solution(
{ConditionOpcode.ASSERT_MY_COIN_ID: [ConditionWithArgs(ConditionOpcode.ASSERT_MY_COIN_ID, [token_bytes()])]}
)
puzzle = puzzle_for_pk(bytes(public_key))
puzzles.append(puzzle)
solutions.append(solution)
private_keys.append(private_key)
public_keys.append(public_key)
# Run Puzzle 1000 times
puzzle_start = time.time()
clvm_cost = 0
for i in range(0, 1000):
cost_run, sexp = puzzles[i].run_with_cost(solutions[i])
async def test_make_fake_coin(self, two_wallet_nodes):
num_blocks = 5
full_nodes, wallets = two_wallet_nodes
full_node_1 = full_nodes[0]
server_1 = full_node_1.server
wallet_node, server_2 = wallets[0]
wallet_node_2, server_3 = wallets[1]
await server_2.start_client(
PeerInfo("localhost", uint16(server_1._port)), None)
wallet = wallet_node.wallet_state_manager.main_wallet
wallet2 = wallet_node_2.wallet_state_manager.main_wallet
ph = await wallet.get_new_puzzlehash()
await server_3.start_client(
PeerInfo("localhost", uint16(server_1._port)), None)
for i in range(1, num_blocks):
await full_node_1.farm_new_transaction_block(
FarmNewBlockProtocol(ph))
funds = sum([
calculate_pool_reward(uint32(i)) +
calculate_base_farmer_reward(uint32(i))
for i in range(1, num_blocks - 1)
])
await time_out_assert(15, wallet.get_confirmed_balance, funds)
did_wallet: DIDWallet = await DIDWallet.create_new_did_wallet(
wallet_node.wallet_state_manager, wallet, uint64(101))
ph2 = await wallet2.get_new_puzzlehash()
for i in range(1, num_blocks):
await full_node_1.farm_new_transaction_block(
FarmNewBlockProtocol(ph2))
await time_out_assert(15, did_wallet.get_confirmed_balance, 101)
await time_out_assert(15, did_wallet.get_unconfirmed_balance, 101)
await time_out_assert(15, did_wallet.get_spendable_balance, 101)
coins = await did_wallet.select_coins(1)
coin = coins.pop()
# copy info for later
parent_info = await did_wallet.get_parent_for_coin(coin)
id_puzhash = coin.puzzle_hash
await did_wallet.create_spend(ph)
for i in range(1, num_blocks):
await full_node_1.farm_new_transaction_block(
FarmNewBlockProtocol(ph))
await time_out_assert(15, did_wallet.get_confirmed_balance, 0)
await time_out_assert(15, did_wallet.get_unconfirmed_balance, 0)
tx_record = await wallet.generate_signed_transaction(101, id_puzhash)
await wallet.push_transaction(tx_record)
for i in range(1, num_blocks):
await full_node_1.farm_new_transaction_block(
FarmNewBlockProtocol(ph))
await time_out_assert(15, wallet.get_confirmed_balance, 21999999999899)
await time_out_assert(15, wallet.get_unconfirmed_balance,
21999999999899)
coins = await did_wallet.select_coins(1)
assert len(coins) >= 1
coin = coins.pop()
# Write spend by hand
# innerpuz solution is (mode amount new_puz identity my_puz)
innersol = Program.to(
[0, coin.amount, ph,
coin.name(), coin.puzzle_hash])
# full solution is (corehash parent_info my_amount innerpuz_reveal solution)
innerpuz = did_wallet.did_info.current_inner
full_puzzle: Program = did_wallet_puzzles.create_fullpuz(
innerpuz,
did_wallet.did_info.my_did,
)
fullsol = Program.to([
[
parent_info.parent_name,
parent_info.inner_puzzle_hash,
parent_info.amount,
],
coin.amount,
innersol,
])
list_of_solutions = [CoinSolution(coin, full_puzzle, fullsol)]
# sign for AGG_SIG_ME
message = coin.puzzle_hash + coin.name(
) + did_wallet.wallet_state_manager.constants.AGG_SIG_ME_ADDITIONAL_DATA
pubkey = did_wallet_puzzles.get_pubkey_from_innerpuz(innerpuz)
index = await did_wallet.wallet_state_manager.puzzle_store.index_for_pubkey(
pubkey)
private = master_sk_to_wallet_sk(
did_wallet.wallet_state_manager.private_key, index)
signature = AugSchemeMPL.sign(private, message)
sigs = [signature]
aggsig = AugSchemeMPL.aggregate(sigs)
spend_bundle = SpendBundle(list_of_solutions, aggsig)
did_record = TransactionRecord(
confirmed_at_height=uint32(0),
created_at_time=uint64(int(time.time())),
to_puzzle_hash=ph,
amount=uint64(coin.amount),
fee_amount=uint64(0),
confirmed=False,
sent=uint32(0),
spend_bundle=spend_bundle,
additions=spend_bundle.additions(),
removals=spend_bundle.removals(),
wallet_id=did_wallet.wallet_info.id,
sent_to=[],
trade_id=None,
type=uint32(TransactionType.OUTGOING_TX.value),
name=token_bytes(),
)
await did_wallet.standard_wallet.push_transaction(did_record)
await time_out_assert(15, wallet.get_confirmed_balance, 21999999999899)
await time_out_assert(15, wallet.get_unconfirmed_balance,
21999999999899)
ph2 = Program.to(binutils.assemble("()")).get_tree_hash()
for i in range(1, num_blocks + 3):
await full_node_1.farm_new_block(FarmNewBlockProtocol(ph2))
# It ends in 900 so it's not gone through
# Assert coin ID is failing
await time_out_assert(15, wallet.get_confirmed_balance, 23999999999899)
await time_out_assert(15, wallet.get_unconfirmed_balance,
23999999999899)
async def test1(self, simulation):
test_rpc_port = uint16(21522)
test_rpc_port_2 = uint16(21523)
harvester, farmer_api = simulation
def stop_node_cb():
pass
def stop_node_cb_2():
pass
config = bt.config
hostname = config["self_hostname"]
daemon_port = config["daemon_port"]
farmer_rpc_api = FarmerRpcApi(farmer_api.farmer)
harvester_rpc_api = HarvesterRpcApi(harvester)
rpc_cleanup = await start_rpc_server(
farmer_rpc_api,
hostname,
daemon_port,
test_rpc_port,
stop_node_cb,
bt.root_path,
config,
connect_to_daemon=False,
)
rpc_cleanup_2 = await start_rpc_server(
harvester_rpc_api,
hostname,
daemon_port,
test_rpc_port_2,
stop_node_cb_2,
bt.root_path,
config,
connect_to_daemon=False,
)
try:
client = await FarmerRpcClient.create(self_hostname, test_rpc_port, bt.root_path, config)
client_2 = await HarvesterRpcClient.create(self_hostname, test_rpc_port_2, bt.root_path, config)
async def have_connections():
return len(await client.get_connections()) > 0
await time_out_assert(15, have_connections, True)
assert (await client.get_signage_point(std_hash(b"2"))) is None
assert len(await client.get_signage_points()) == 0
async def have_signage_points():
return len(await client.get_signage_points()) > 0
sp = farmer_protocol.NewSignagePoint(
std_hash(b"1"), std_hash(b"2"), std_hash(b"3"), uint64(1), uint64(1000000), uint8(2)
)
await farmer_api.new_signage_point(sp)
await time_out_assert(5, have_signage_points, True)
assert (await client.get_signage_point(std_hash(b"2"))) is not None
async def have_plots():
return len((await client_2.get_plots())["plots"]) > 0
await time_out_assert(5, have_plots, True)
res = await client_2.get_plots()
num_plots = len(res["plots"])
assert num_plots > 0
plot_dir = get_plot_dir() / "subdir"
plot_dir.mkdir(parents=True, exist_ok=True)
plot_dir_sub = get_plot_dir() / "subdir" / "subsubdir"
plot_dir_sub.mkdir(parents=True, exist_ok=True)
plotter = DiskPlotter()
filename = "test_farmer_harvester_rpc_plot.plot"
filename_2 = "test_farmer_harvester_rpc_plot2.plot"
plotter.create_plot_disk(
str(plot_dir),
str(plot_dir),
str(plot_dir),
filename,
18,
stream_plot_info_pk(bt.pool_pk, bt.farmer_pk, AugSchemeMPL.key_gen(bytes([4] * 32))),
token_bytes(32),
128,
0,
2000,
0,
False,
)
# Making a plot with a puzzle hash encoded into it instead of pk
plot_id_2 = token_bytes(32)
plotter.create_plot_disk(
str(plot_dir),
str(plot_dir),
str(plot_dir),
filename_2,
18,
stream_plot_info_ph(std_hash(b"random ph"), bt.farmer_pk, AugSchemeMPL.key_gen(bytes([5] * 32))),
plot_id_2,
128,
0,
2000,
0,
False,
)
# Making the same plot, in a different dir. This should not be farmed
plotter.create_plot_disk(
str(plot_dir_sub),
str(plot_dir_sub),
str(plot_dir_sub),
filename_2,
18,
stream_plot_info_ph(std_hash(b"random ph"), bt.farmer_pk, AugSchemeMPL.key_gen(bytes([5] * 32))),
plot_id_2,
128,
0,
2000,
0,
False,
)
res_2 = await client_2.get_plots()
assert len(res_2["plots"]) == num_plots
# Test farmer get_harvesters
async def test_get_harvesters():
farmer_res = await client.get_harvesters()
if len(list(farmer_res["harvesters"])) != 1:
return False
if len(list(farmer_res["harvesters"][0]["plots"])) != num_plots:
return False
return True
await time_out_assert(30, test_get_harvesters)
expected_result: PlotRefreshResult = PlotRefreshResult()
def test_refresh_callback(refresh_result: PlotRefreshResult):
assert refresh_result.loaded_plots == expected_result.loaded_plots
assert refresh_result.removed_plots == expected_result.removed_plots
assert refresh_result.processed_files == expected_result.processed_files
assert refresh_result.remaining_files == expected_result.remaining_files
harvester.plot_manager.set_refresh_callback(test_refresh_callback)
async def test_case(
trigger, expect_loaded, expect_removed, expect_processed, expected_directories, expect_total_plots
):
expected_result.loaded_plots = expect_loaded
expected_result.removed_plots = expect_removed
expected_result.processed_files = expect_processed
await trigger
harvester.plot_manager.trigger_refresh()
assert len(await client_2.get_plot_directories()) == expected_directories
await time_out_assert(5, harvester.plot_manager.needs_refresh, value=False)
result = await client_2.get_plots()
assert len(result["plots"]) == expect_total_plots
assert len(harvester.plot_manager.cache) == expect_total_plots
assert len(harvester.plot_manager.failed_to_open_filenames) == 0
# Add plot_dir with two new plots
await test_case(
client_2.add_plot_directory(str(plot_dir)),
expect_loaded=2,
expect_removed=0,
expect_processed=2,
expected_directories=2,
expect_total_plots=num_plots + 2,
)
# Add plot_dir_sub with one duplicate
await test_case(
client_2.add_plot_directory(str(plot_dir_sub)),
expect_loaded=0,
expect_removed=0,
expect_processed=1,
expected_directories=3,
expect_total_plots=num_plots + 2,
)
# Delete one plot
await test_case(
client_2.delete_plot(str(plot_dir / filename)),
expect_loaded=0,
expect_removed=1,
expect_processed=0,
expected_directories=3,
expect_total_plots=num_plots + 1,
)
# Remove directory with the duplicate
await test_case(
client_2.remove_plot_directory(str(plot_dir_sub)),
expect_loaded=0,
expect_removed=1,
expect_processed=0,
expected_directories=2,
expect_total_plots=num_plots + 1,
)
# Re-add the directory with the duplicate for other tests
await test_case(
client_2.add_plot_directory(str(plot_dir_sub)),
expect_loaded=0,
expect_removed=0,
expect_processed=1,
expected_directories=3,
expect_total_plots=num_plots + 1,
)
# Remove the directory which has the duplicated plot loaded. This removes the duplicated plot from plot_dir
# and in the same run loads the plot from plot_dir_sub which is not longer seen as duplicate.
await test_case(
client_2.remove_plot_directory(str(plot_dir)),
expect_loaded=1,
expect_removed=1,
expect_processed=1,
expected_directories=2,
expect_total_plots=num_plots + 1,
)
# Re-add the directory now the plot seen as duplicate is from plot_dir, not from plot_dir_sub like before
await test_case(
client_2.add_plot_directory(str(plot_dir)),
expect_loaded=0,
expect_removed=0,
expect_processed=1,
expected_directories=3,
expect_total_plots=num_plots + 1,
)
# Remove the duplicated plot
await test_case(
client_2.delete_plot(str(plot_dir / filename_2)),
expect_loaded=0,
expect_removed=1,
expect_processed=0,
expected_directories=3,
expect_total_plots=num_plots + 1,
)
# Remove the directory with the loaded plot which is not longer a duplicate
await test_case(
client_2.remove_plot_directory(str(plot_dir_sub)),
expect_loaded=0,
expect_removed=1,
expect_processed=0,
expected_directories=2,
expect_total_plots=num_plots,
)
# Remove the directory which contains all other plots
await test_case(
client_2.remove_plot_directory(str(get_plot_dir())),
expect_loaded=0,
expect_removed=20,
expect_processed=0,
expected_directories=1,
expect_total_plots=0,
)
# Recover the plots to test caching
# First make sure cache gets written if required and new plots are loaded
await test_case(
client_2.add_plot_directory(str(get_plot_dir())),
expect_loaded=20,
expect_removed=0,
expect_processed=20,
expected_directories=2,
expect_total_plots=20,
)
assert harvester.plot_manager.cache.path().exists()
unlink(harvester.plot_manager.cache.path())
# Should not write the cache again on shutdown because it didn't change
assert not harvester.plot_manager.cache.path().exists()
harvester.plot_manager.stop_refreshing()
assert not harvester.plot_manager.cache.path().exists()
# Manually trigger `save_cache` and make sure it creates a new cache file
harvester.plot_manager.cache.save()
assert harvester.plot_manager.cache.path().exists()
expected_result.loaded_plots = 20
expected_result.removed_plots = 0
expected_result.processed_files = 20
expected_result.remaining_files = 0
plot_manager: PlotManager = PlotManager(harvester.root_path, test_refresh_callback)
plot_manager.start_refreshing()
assert len(harvester.plot_manager.cache) == len(plot_manager.cache)
await time_out_assert(5, plot_manager.needs_refresh, value=False)
for path, plot_info in harvester.plot_manager.plots.items():
assert path in plot_manager.plots
assert plot_manager.plots[path].prover.get_filename() == plot_info.prover.get_filename()
assert plot_manager.plots[path].prover.get_id() == plot_info.prover.get_id()
assert plot_manager.plots[path].prover.get_memo() == plot_info.prover.get_memo()
assert plot_manager.plots[path].prover.get_size() == plot_info.prover.get_size()
assert plot_manager.plots[path].pool_public_key == plot_info.pool_public_key
assert plot_manager.plots[path].pool_contract_puzzle_hash == plot_info.pool_contract_puzzle_hash
assert plot_manager.plots[path].plot_public_key == plot_info.plot_public_key
assert plot_manager.plots[path].file_size == plot_info.file_size
assert plot_manager.plots[path].time_modified == plot_info.time_modified
assert harvester.plot_manager.plot_filename_paths == plot_manager.plot_filename_paths
assert harvester.plot_manager.failed_to_open_filenames == plot_manager.failed_to_open_filenames
assert harvester.plot_manager.no_key_filenames == plot_manager.no_key_filenames
plot_manager.stop_refreshing()
# Modify the content of the plot_manager.dat
with open(harvester.plot_manager.cache.path(), "r+b") as file:
file.write(b"\xff\xff") # Sets Cache.version to 65535
# Make sure it just loads the plots normally if it fails to load the cache
plot_manager = PlotManager(harvester.root_path, test_refresh_callback)
plot_manager.cache.load()
assert len(plot_manager.cache) == 0
plot_manager.set_public_keys(
harvester.plot_manager.farmer_public_keys, harvester.plot_manager.pool_public_keys
)
expected_result.loaded_plots = 20
expected_result.removed_plots = 0
expected_result.processed_files = 20
expected_result.remaining_files = 0
plot_manager.start_refreshing()
await time_out_assert(5, plot_manager.needs_refresh, value=False)
assert len(plot_manager.plots) == len(harvester.plot_manager.plots)
plot_manager.stop_refreshing()
# Test re-trying if processing a plot failed
# First save the plot
retry_test_plot = Path(plot_dir_sub / filename_2).resolve()
retry_test_plot_save = Path(plot_dir_sub / "save").resolve()
copy(retry_test_plot, retry_test_plot_save)
# Invalidate the plot
with open(plot_dir_sub / filename_2, "r+b") as file:
file.write(bytes(100))
# Add it and validate it fails to load
await harvester.add_plot_directory(str(plot_dir_sub))
expected_result.loaded_plots = 0
expected_result.removed_plots = 0
expected_result.processed_files = 1
expected_result.remaining_files = 0
harvester.plot_manager.start_refreshing()
await time_out_assert(5, harvester.plot_manager.needs_refresh, value=False)
assert retry_test_plot in harvester.plot_manager.failed_to_open_filenames
# Make sure the file stays in `failed_to_open_filenames` and doesn't get loaded or processed in the next
# update round
expected_result.loaded_plots = 0
expected_result.processed_files = 0
harvester.plot_manager.trigger_refresh()
await time_out_assert(5, harvester.plot_manager.needs_refresh, value=False)
assert retry_test_plot in harvester.plot_manager.failed_to_open_filenames
# Now decrease the re-try timeout, restore the valid plot file and make sure it properly loads now
harvester.plot_manager.refresh_parameter.retry_invalid_seconds = 0
move(retry_test_plot_save, retry_test_plot)
expected_result.loaded_plots = 1
expected_result.processed_files = 1
harvester.plot_manager.trigger_refresh()
await time_out_assert(5, harvester.plot_manager.needs_refresh, value=False)
assert retry_test_plot not in harvester.plot_manager.failed_to_open_filenames
targets_1 = await client.get_reward_targets(False)
assert "have_pool_sk" not in targets_1
assert "have_farmer_sk" not in targets_1
targets_2 = await client.get_reward_targets(True)
assert targets_2["have_pool_sk"] and targets_2["have_farmer_sk"]
new_ph: bytes32 = create_puzzlehash_for_pk(master_sk_to_wallet_sk(bt.farmer_master_sk, uint32(10)).get_g1())
new_ph_2: bytes32 = create_puzzlehash_for_pk(
master_sk_to_wallet_sk(bt.pool_master_sk, uint32(472)).get_g1()
)
await client.set_reward_targets(encode_puzzle_hash(new_ph, "xch"), encode_puzzle_hash(new_ph_2, "xch"))
targets_3 = await client.get_reward_targets(True)
assert decode_puzzle_hash(targets_3["farmer_target"]) == new_ph
assert decode_puzzle_hash(targets_3["pool_target"]) == new_ph_2
assert targets_3["have_pool_sk"] and targets_3["have_farmer_sk"]
new_ph_3: bytes32 = create_puzzlehash_for_pk(
master_sk_to_wallet_sk(bt.pool_master_sk, uint32(1888)).get_g1()
)
await client.set_reward_targets(None, encode_puzzle_hash(new_ph_3, "xch"))
targets_4 = await client.get_reward_targets(True)
assert decode_puzzle_hash(targets_4["farmer_target"]) == new_ph
assert decode_puzzle_hash(targets_4["pool_target"]) == new_ph_3
assert not targets_4["have_pool_sk"] and targets_3["have_farmer_sk"]
root_path = farmer_api.farmer._root_path
config = load_config(root_path, "config.yaml")
assert config["farmer"]["xch_target_address"] == encode_puzzle_hash(new_ph, "xch")
assert config["pool"]["xch_target_address"] == encode_puzzle_hash(new_ph_3, "xch")
new_ph_3_encoded = encode_puzzle_hash(new_ph_3, "xch")
added_char = new_ph_3_encoded + "a"
with pytest.raises(ValueError):
await client.set_reward_targets(None, added_char)
replaced_char = new_ph_3_encoded[0:-1] + "a"
with pytest.raises(ValueError):
await client.set_reward_targets(None, replaced_char)
assert len((await client.get_pool_state())["pool_state"]) == 0
all_sks = farmer_api.farmer.local_keychain.get_all_private_keys()
auth_sk = master_sk_to_pooling_authentication_sk(all_sks[0][0], 2, 1)
pool_list = [
{
"launcher_id": "ae4ef3b9bfe68949691281a015a9c16630fc8f66d48c19ca548fb80768791afa",
"authentication_public_key": bytes(auth_sk.get_g1()).hex(),
"owner_public_key": "84c3fcf9d5581c1ddc702cb0f3b4a06043303b334dd993ab42b2c320ebfa98e5ce558448615b3f69638ba92cf7f43da5",
"payout_instructions": "c2b08e41d766da4116e388357ed957d04ad754623a915f3fd65188a8746cf3e8",
"pool_url": "localhost",
"p2_singleton_puzzle_hash": "16e4bac26558d315cded63d4c5860e98deb447cc59146dd4de06ce7394b14f17",
"target_puzzle_hash": "344587cf06a39db471d2cc027504e8688a0a67cce961253500c956c73603fd58",
}
]
config["pool"]["pool_list"] = pool_list
save_config(root_path, "config.yaml", config)
await farmer_api.farmer.update_pool_state()
pool_state = (await client.get_pool_state())["pool_state"]
assert len(pool_state) == 1
assert (
pool_state[0]["pool_config"]["payout_instructions"]
== "c2b08e41d766da4116e388357ed957d04ad754623a915f3fd65188a8746cf3e8"
)
await client.set_payout_instructions(hexstr_to_bytes(pool_state[0]["pool_config"]["launcher_id"]), "1234vy")
await farmer_api.farmer.update_pool_state()
pool_state = (await client.get_pool_state())["pool_state"]
assert pool_state[0]["pool_config"]["payout_instructions"] == "1234vy"
finally:
# Checks that the RPC manages to stop the node
client.close()
client_2.close()
await client.await_closed()
await client_2.await_closed()
await rpc_cleanup()
await rpc_cleanup_2()
async def test_wallet_rpc(self, two_wallet_nodes, trusted):
test_rpc_port = uint16(21529)
test_rpc_port_2 = uint16(21536)
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)
await server_3.start_client(PeerInfo("localhost", uint16(full_node_server._port)), None)
if trusted:
wallet_node.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
wallet_node_2.config["trusted_peers"] = {full_node_server.node_id.hex(): full_node_server.node_id.hex()}
else:
wallet_node.config["trusted_peers"] = {}
wallet_node_2.config["trusted_peers"] = {}
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)
wallet_rpc_api_2 = WalletRpcApi(wallet_node_2)
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,
)
rpc_cleanup_2 = await start_rpc_server(
wallet_rpc_api_2,
hostname,
daemon_port,
test_rpc_port_2,
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_2 = await WalletRpcClient.create(self_hostname, test_rpc_port_2, bt.root_path, config)
client_node = await FullNodeRpcClient.create(self_hostname, test_rpc_port_node, bt.root_path, config)
try:
await time_out_assert(5, client.get_synced)
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, memos=["this is a basic tx"])
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 full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph_2))
async def eventual_balance():
return (await client.get_wallet_balance("1"))["confirmed_wallet_balance"]
async def eventual_balance_det(c, wallet_id: str):
return (await c.get_wallet_balance(wallet_id))["confirmed_wallet_balance"]
# Checks that the memo can be retrieved
tx_confirmed = await client.get_transaction("1", transaction_id)
assert tx_confirmed.confirmed
assert len(tx_confirmed.get_memos()) == 1
assert [b"this is a basic tx"] in tx_confirmed.get_memos().values()
assert list(tx_confirmed.get_memos().keys())[0] in [a.name() for a in tx.spend_bundle.additions()]
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 and coin announcement
signed_tx_amount = 888000
tx_coin_announcements = [
Announcement(
std_hash(b"coin_id_1"),
std_hash(b"message"),
b"\xca",
),
Announcement(
std_hash(b"coin_id_2"),
bytes(Program.to("a string")),
),
]
tx_res: TransactionRecord = await client.create_signed_transaction(
[{"amount": signed_tx_amount, "puzzle_hash": ph_3}], coin_announcements=tx_coin_announcements
)
assert tx_res.fee_amount == 0
assert tx_res.amount == signed_tx_amount
assert len(tx_res.additions) == 2 # The output and the change
assert any([addition.amount == signed_tx_amount for addition in tx_res.additions])
# check error for a ASSERT_ANNOUNCE_CONSUMED_FAILED and if the error is not there throw a value error
try:
push_res = await client_node.push_tx(tx_res.spend_bundle)
except ValueError as error:
error_string = error.args[0]["error"] # noqa: # pylint: disable=E1126
if error_string.find("ASSERT_ANNOUNCE_CONSUMED_FAILED") == -1:
raise ValueError from error
# # Test basic transaction to one output and puzzle announcement
signed_tx_amount = 888000
tx_puzzle_announcements = [
Announcement(
std_hash(b"puzzle_hash_1"),
b"message",
b"\xca",
),
Announcement(
std_hash(b"puzzle_hash_2"),
bytes(Program.to("a string")),
),
]
tx_res: TransactionRecord = await client.create_signed_transaction(
[{"amount": signed_tx_amount, "puzzle_hash": ph_3}], puzzle_announcements=tx_puzzle_announcements
)
assert tx_res.fee_amount == 0
assert tx_res.amount == signed_tx_amount
assert len(tx_res.additions) == 2 # The output and the change
assert any([addition.amount == signed_tx_amount for addition in tx_res.additions])
# check error for a ASSERT_ANNOUNCE_CONSUMED_FAILED and if the error is not there throw a value error
try:
push_res = await client_node.push_tx(tx_res.spend_bundle)
except ValueError as error:
error_string = error.args[0]["error"] # noqa: # pylint: disable=E1126
if error_string.find("ASSERT_ANNOUNCE_CONSUMED_FAILED") == -1:
raise ValueError from error
# Test basic transaction to one output
signed_tx_amount = 888000
tx_res: TransactionRecord = await client.create_signed_transaction(
[{"amount": signed_tx_amount, "puzzle_hash": ph_3, "memos": ["My memo"]}]
)
assert tx_res.fee_amount == 0
assert tx_res.amount == signed_tx_amount
assert len(tx_res.additions) == 2 # The output and the change
assert any([addition.amount == signed_tx_amount for addition in tx_res.additions])
push_res = await client.push_tx(tx_res.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.additions:
if addition.amount != signed_tx_amount:
coin_to_spend = addition
assert coin_to_spend is not None
tx_res = await client.create_signed_transaction(
[{"amount": 444, "puzzle_hash": ph_4, "memos": ["hhh"]}, {"amount": 999, "puzzle_hash": ph_5}],
coins=[coin_to_spend],
fee=100,
)
assert tx_res.fee_amount == 100
assert tx_res.amount == 444 + 999
assert len(tx_res.additions) == 3 # The outputs and the change
assert any([addition.amount == 444 for addition in tx_res.additions])
assert any([addition.amount == 999 for addition in tx_res.additions])
assert sum([rem.amount for rem in tx_res.removals]) - sum([ad.amount for ad in tx_res.additions]) == 100
push_res = await client_node.push_tx(tx_res.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)
found: bool = False
for addition in tx_res.spend_bundle.additions():
if addition.amount == 444:
cr: Optional[CoinRecord] = await client_node.get_coin_record_by_name(addition.name())
assert cr is not None
spend: CoinSpend = await client_node.get_puzzle_and_solution(
addition.parent_coin_info, cr.confirmed_block_index
)
sb: SpendBundle = SpendBundle([spend], G2Element())
assert compute_memos(sb) == {addition.name(): [b"hhh"]}
found = True
assert found
new_balance = initial_funds_eventually - tx_amount - signed_tx_amount - 444 - 999 - 100
await time_out_assert(5, eventual_balance, new_balance)
send_tx_res: TransactionRecord = await client.send_transaction_multi(
"1",
[
{"amount": 555, "puzzle_hash": ph_4, "memos": ["FiMemo"]},
{"amount": 666, "puzzle_hash": ph_5, "memos": ["SeMemo"]},
],
fee=200,
)
assert send_tx_res is not None
assert send_tx_res.fee_amount == 200
assert send_tx_res.amount == 555 + 666
assert len(send_tx_res.additions) == 3 # The outputs and the change
assert any([addition.amount == 555 for addition in send_tx_res.additions])
assert any([addition.amount == 666 for addition in send_tx_res.additions])
assert (
sum([rem.amount for rem in send_tx_res.removals]) - sum([ad.amount for ad in send_tx_res.additions])
== 200
)
await asyncio.sleep(3)
for i in range(0, 5):
await client.farm_block(encode_puzzle_hash(ph_2, "xch"))
await asyncio.sleep(0.5)
new_balance = new_balance - 555 - 666 - 200
await time_out_assert(5, eventual_balance, new_balance)
address = await client.get_next_address("1", True)
assert len(address) > 10
transactions = await client.get_transactions("1")
assert len(transactions) > 1
all_transactions = await client.get_transactions("1")
# Test transaction pagination
some_transactions = await client.get_transactions("1", 0, 5)
some_transactions_2 = await client.get_transactions("1", 5, 10)
assert some_transactions == all_transactions[0:5]
assert some_transactions_2 == all_transactions[5:10]
# Testing sorts
# Test the default sort (CONFIRMED_AT_HEIGHT)
assert all_transactions == sorted(all_transactions, key=attrgetter("confirmed_at_height"))
all_transactions = await client.get_transactions("1", reverse=True)
assert all_transactions == sorted(all_transactions, key=attrgetter("confirmed_at_height"), reverse=True)
# Test RELEVANCE
await client.send_transaction("1", 1, encode_puzzle_hash(ph_2, "xch")) # Create a pending tx
all_transactions = await client.get_transactions("1", sort_key=SortKey.RELEVANCE)
sorted_transactions = sorted(all_transactions, key=attrgetter("created_at_time"), reverse=True)
sorted_transactions = sorted(sorted_transactions, key=attrgetter("confirmed_at_height"), reverse=True)
sorted_transactions = sorted(sorted_transactions, key=attrgetter("confirmed"))
assert all_transactions == sorted_transactions
all_transactions = await client.get_transactions("1", sort_key=SortKey.RELEVANCE, reverse=True)
sorted_transactions = sorted(all_transactions, key=attrgetter("created_at_time"))
sorted_transactions = sorted(sorted_transactions, key=attrgetter("confirmed_at_height"))
sorted_transactions = sorted(sorted_transactions, key=attrgetter("confirmed"), reverse=True)
assert all_transactions == sorted_transactions
# Checks that the memo can be retrieved
tx_confirmed = await client.get_transaction("1", send_tx_res.name)
assert tx_confirmed.confirmed
if isinstance(tx_confirmed, SpendBundle):
memos = compute_memos(tx_confirmed)
else:
memos = tx_confirmed.get_memos()
assert len(memos) == 2
print(memos)
assert [b"FiMemo"] in memos.values()
assert [b"SeMemo"] in memos.values()
assert list(memos.keys())[0] in [a.name() for a in send_tx_res.spend_bundle.additions()]
assert list(memos.keys())[1] in [a.name() for a in send_tx_res.spend_bundle.additions()]
##############
# CATS #
##############
# Creates a wallet and a CAT with 20 mojos
res = await client.create_new_cat_and_wallet(20)
assert res["success"]
cat_0_id = res["wallet_id"]
asset_id = bytes.fromhex(res["asset_id"])
assert len(asset_id) > 0
bal_0 = await client.get_wallet_balance(cat_0_id)
assert bal_0["confirmed_wallet_balance"] == 0
assert bal_0["pending_coin_removal_count"] == 1
col = await client.get_cat_asset_id(cat_0_id)
assert col == asset_id
assert (await client.get_cat_name(cat_0_id)) == "CAT Wallet"
await client.set_cat_name(cat_0_id, "My cat")
assert (await client.get_cat_name(cat_0_id)) == "My cat"
wid, name = await client.cat_asset_id_to_name(col)
assert wid == cat_0_id
assert name == "My cat"
should_be_none = await client.cat_asset_id_to_name(bytes([0] * 32))
assert should_be_none is None
verified_asset_id = next(iter(DEFAULT_CATS.items()))[1]["asset_id"]
should_be_none, name = await client.cat_asset_id_to_name(bytes.fromhex(verified_asset_id))
assert should_be_none is None
assert name == next(iter(DEFAULT_CATS.items()))[1]["name"]
await asyncio.sleep(1)
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(10, eventual_balance_det, 20, client, cat_0_id)
bal_0 = await client.get_wallet_balance(cat_0_id)
assert bal_0["pending_coin_removal_count"] == 0
assert bal_0["unspent_coin_count"] == 1
# Creates a second wallet with the same CAT
res = await client_2.create_wallet_for_existing_cat(asset_id)
assert res["success"]
cat_1_id = res["wallet_id"]
colour_1 = bytes.fromhex(res["asset_id"])
assert colour_1 == asset_id
await asyncio.sleep(1)
for i in range(0, 5):
await client.farm_block(encode_puzzle_hash(ph_2, "xch"))
await asyncio.sleep(0.5)
bal_1 = await client_2.get_wallet_balance(cat_1_id)
assert bal_1["confirmed_wallet_balance"] == 0
addr_0 = await client.get_next_address(cat_0_id, False)
addr_1 = await client_2.get_next_address(cat_1_id, False)
assert addr_0 != addr_1
await client.cat_spend(cat_0_id, 4, addr_1, 0, ["the cat memo"])
await asyncio.sleep(1)
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(10, eventual_balance_det, 16, client, cat_0_id)
await time_out_assert(10, eventual_balance_det, 4, client_2, cat_1_id)
##########
# Offers #
##########
# Create an offer of 5 chia for one CAT
offer, trade_record = await client.create_offer_for_ids({uint32(1): -5, cat_0_id: 1}, validate_only=True)
all_offers = await client.get_all_offers()
assert len(all_offers) == 0
assert offer is None
offer, trade_record = await client.create_offer_for_ids({uint32(1): -5, cat_0_id: 1}, fee=uint64(1))
summary = await client.get_offer_summary(offer)
assert summary == {"offered": {"xch": 5}, "requested": {col.hex(): 1}}
assert await client.check_offer_validity(offer)
all_offers = await client.get_all_offers(file_contents=True)
assert len(all_offers) == 1
assert TradeStatus(all_offers[0].status) == TradeStatus.PENDING_ACCEPT
assert all_offers[0].offer == bytes(offer)
trade_record = await client_2.take_offer(offer, fee=uint64(1))
assert TradeStatus(trade_record.status) == TradeStatus.PENDING_CONFIRM
await client.cancel_offer(offer.name(), secure=False)
trade_record = await client.get_offer(offer.name(), file_contents=True)
assert trade_record.offer == bytes(offer)
assert TradeStatus(trade_record.status) == TradeStatus.CANCELLED
await client.cancel_offer(offer.name(), fee=uint64(1), secure=True)
trade_record = await client.get_offer(offer.name())
assert TradeStatus(trade_record.status) == TradeStatus.PENDING_CANCEL
new_offer, new_trade_record = await client.create_offer_for_ids({uint32(1): -5, cat_0_id: 1}, fee=uint64(1))
all_offers = await client.get_all_offers()
assert len(all_offers) == 2
await asyncio.sleep(1)
for i in range(0, 5):
await client.farm_block(encode_puzzle_hash(ph_2, "xch"))
await asyncio.sleep(0.5)
async def is_trade_confirmed(client, trade) -> bool:
trade_record = await client.get_offer(trade.name())
return TradeStatus(trade_record.status) == TradeStatus.CONFIRMED
time_out_assert(15, is_trade_confirmed, True, client, offer)
# Test trade sorting
def only_ids(trades):
return [t.trade_id for t in trades]
trade_record = await client.get_offer(offer.name())
all_offers = await client.get_all_offers(include_completed=True) # confirmed at index descending
assert len(all_offers) == 2
assert only_ids(all_offers) == only_ids([trade_record, new_trade_record])
all_offers = await client.get_all_offers(
include_completed=True, reverse=True
) # confirmed at index ascending
assert only_ids(all_offers) == only_ids([new_trade_record, trade_record])
all_offers = await client.get_all_offers(include_completed=True, sort_key="RELEVANCE") # most relevant
assert only_ids(all_offers) == only_ids([new_trade_record, trade_record])
all_offers = await client.get_all_offers(
include_completed=True, sort_key="RELEVANCE", reverse=True
) # least relevant
assert only_ids(all_offers) == only_ids([trade_record, new_trade_record])
# Test pagination
all_offers = await client.get_all_offers(include_completed=True, start=0, end=1)
assert len(all_offers) == 1
all_offers = await client.get_all_offers(include_completed=True, start=50)
assert len(all_offers) == 0
all_offers = await client.get_all_offers(include_completed=True, start=0, end=50)
assert len(all_offers) == 2
# Keys and addresses
address = await client.get_next_address("1", True)
assert len(address) > 10
all_transactions = await client.get_transactions("1")
some_transactions = await client.get_transactions("1", 0, 5)
some_transactions_2 = await client.get_transactions("1", 5, 10)
assert len(all_transactions) > 1
assert some_transactions == all_transactions[0:5]
assert some_transactions_2 == all_transactions[5:10]
transaction_count = await client.get_transaction_count("1")
assert transaction_count == len(all_transactions)
pks = await client.get_public_keys()
assert len(pks) == 1
assert (await client.get_height_info()) > 0
created_tx = await client.send_transaction("1", tx_amount, addr)
async def tx_in_mempool_2():
tx = await client.get_transaction("1", created_tx.name)
return tx.is_in_mempool()
await time_out_assert(5, tx_in_mempool_2, True)
assert len(await wallet.wallet_state_manager.tx_store.get_unconfirmed_for_wallet(1)) == 1
await client.delete_unconfirmed_transactions("1")
assert len(await wallet.wallet_state_manager.tx_store.get_unconfirmed_for_wallet(1)) == 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]
# Add in reward addresses into farmer and pool for testing delete key checks
# set farmer to first private key
sk = await wallet_node.get_key_for_fingerprint(pks[0])
test_ph = create_puzzlehash_for_pk(master_sk_to_wallet_sk(sk, uint32(0)).get_g1())
test_config = load_config(wallet_node.root_path, "config.yaml")
test_config["farmer"]["xch_target_address"] = encode_puzzle_hash(test_ph, "txch")
# set pool to second private key
sk = await wallet_node.get_key_for_fingerprint(pks[1])
test_ph = create_puzzlehash_for_pk(master_sk_to_wallet_sk(sk, uint32(0)).get_g1())
test_config["pool"]["xch_target_address"] = encode_puzzle_hash(test_ph, "txch")
save_config(wallet_node.root_path, "config.yaml", test_config)
# Check first key
sk_dict = await client.check_delete_key(pks[0])
assert sk_dict["fingerprint"] == pks[0]
assert sk_dict["used_for_farmer_rewards"] is True
assert sk_dict["used_for_pool_rewards"] is False
# Check second key
sk_dict = await client.check_delete_key(pks[1])
assert sk_dict["fingerprint"] == pks[1]
assert sk_dict["used_for_farmer_rewards"] is False
assert sk_dict["used_for_pool_rewards"] is True
# Check unknown key
sk_dict = await client.check_delete_key(123456)
assert sk_dict["fingerprint"] == 123456
assert sk_dict["used_for_farmer_rewards"] is False
assert sk_dict["used_for_pool_rewards"] is False
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
try:
await client.send_transaction(wallets[0]["id"], 100, addr)
raise Exception("Should not create tx if no balance")
except ValueError:
pass
# Delete all keys
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_2.close()
client_node.close()
await client.await_closed()
await client_2.await_closed()
await client_node.await_closed()
await rpc_cleanup()
await rpc_cleanup_2()
await rpc_cleanup_node()
async def recovery_spend(
self,
coin: Coin,
puzhash: bytes32,
parent_innerpuzhash_amounts_for_recovery_ids: List[Tuple[bytes, bytes,
int]],
pubkey: G1Element,
spend_bundle: SpendBundle,
) -> SpendBundle:
assert self.did_info.origin_coin is not None
# innersol is mode new_amount message new_inner_puzhash parent_innerpuzhash_amounts_for_recovery_ids pubkey recovery_list_reveal) # noqa
innersol: Program = Program.to([
2,
coin.amount,
puzhash,
puzhash,
parent_innerpuzhash_amounts_for_recovery_ids,
bytes(pubkey),
self.did_info.backup_ids,
])
# full solution is (parent_info my_amount solution)
assert self.did_info.current_inner is not None
innerpuz: Program = self.did_info.current_inner
full_puzzle: Program = did_wallet_puzzles.create_fullpuz(
innerpuz,
self.did_info.origin_coin.name(),
)
parent_info = await self.get_parent_for_coin(coin)
assert parent_info is not None
fullsol = Program.to([
[
parent_info.parent_name,
parent_info.inner_puzzle_hash,
parent_info.amount,
],
coin.amount,
innersol,
])
list_of_solutions = [CoinSpend(coin, full_puzzle, fullsol)]
index = await self.wallet_state_manager.puzzle_store.index_for_pubkey(
pubkey)
if index is None:
raise ValueError("Unknown pubkey.")
private = master_sk_to_wallet_sk(self.wallet_state_manager.private_key,
index)
message = bytes(puzhash)
sigs = [AugSchemeMPL.sign(private, message)]
for _ in spend_bundle.coin_spends:
sigs.append(AugSchemeMPL.sign(private, message))
aggsig = AugSchemeMPL.aggregate(sigs)
# assert AugSchemeMPL.verify(pubkey, message, aggsig)
if spend_bundle is None:
spend_bundle = SpendBundle(list_of_solutions, aggsig)
else:
spend_bundle = spend_bundle.aggregate(
[spend_bundle,
SpendBundle(list_of_solutions, aggsig)])
# TODO: address hint error and remove ignore
# error: Argument "name" to "TransactionRecord" has incompatible type "bytes"; expected "bytes32"
# [arg-type]
did_record = TransactionRecord(
confirmed_at_height=uint32(0),
created_at_time=uint64(int(time.time())),
to_puzzle_hash=puzhash,
amount=uint64(coin.amount),
fee_amount=uint64(0),
confirmed=False,
sent=uint32(0),
spend_bundle=spend_bundle,
additions=spend_bundle.additions(),
removals=spend_bundle.removals(),
wallet_id=self.wallet_info.id,
sent_to=[],
trade_id=None,
type=uint32(TransactionType.OUTGOING_TX.value),
name=token_bytes(), # type: ignore[arg-type]
)
await self.standard_wallet.push_transaction(did_record)
new_did_info = DIDInfo(
self.did_info.origin_coin,
self.did_info.backup_ids,
self.did_info.num_of_backup_ids_needed,
self.did_info.parent_info,
self.did_info.current_inner,
self.did_info.temp_coin,
self.did_info.temp_puzhash,
self.did_info.temp_pubkey,
True,
)
await self.save_info(new_did_info, True)
return spend_bundle
async def recovery_spend(
self,
coin: Coin,
puzhash: bytes,
parent_innerpuzhash_amounts_for_recovery_ids: List[Tuple[bytes, bytes,
int]],
pubkey: G1Element,
spend_bundle: SpendBundle,
) -> SpendBundle:
assert self.did_info.origin_coin is not None
# innerpuz solution is (mode amount new_puz identity my_puz parent_innerpuzhash_amounts_for_recovery_ids)
innersol = Program.to([
2,
coin.amount,
puzhash,
coin.name(),
coin.puzzle_hash,
parent_innerpuzhash_amounts_for_recovery_ids,
bytes(pubkey),
self.did_info.backup_ids,
self.did_info.num_of_backup_ids_needed,
])
# full solution is (parent_info my_amount solution)
innerpuz = self.did_info.current_inner
full_puzzle: Program = did_wallet_puzzles.create_fullpuz(
innerpuz,
self.did_info.origin_coin.puzzle_hash,
)
parent_info = await self.get_parent_for_coin(coin)
assert parent_info is not None
fullsol = Program.to([
[
self.did_info.origin_coin.parent_coin_info,
self.did_info.origin_coin.amount
],
[
parent_info.parent_name,
parent_info.inner_puzzle_hash,
parent_info.amount,
],
coin.amount,
innersol,
])
list_of_solutions = [CoinSolution(coin, full_puzzle, fullsol)]
index = await self.wallet_state_manager.puzzle_store.index_for_pubkey(
pubkey)
if index is None:
raise ValueError("Unknown pubkey.")
private = master_sk_to_wallet_sk(self.wallet_state_manager.private_key,
index)
message = bytes(puzhash)
sigs = [AugSchemeMPL.sign(private, message)]
for _ in spend_bundle.coin_solutions:
sigs.append(AugSchemeMPL.sign(private, message))
aggsig = AugSchemeMPL.aggregate(sigs)
# assert AugSchemeMPL.verify(pubkey, message, aggsig)
if spend_bundle is None:
spend_bundle = SpendBundle(list_of_solutions, aggsig)
else:
spend_bundle = spend_bundle.aggregate(
[spend_bundle,
SpendBundle(list_of_solutions, aggsig)])
did_record = TransactionRecord(
confirmed_at_height=uint32(0),
created_at_time=uint64(int(time.time())),
to_puzzle_hash=puzhash,
amount=uint64(coin.amount),
fee_amount=uint64(0),
confirmed=False,
sent=uint32(0),
spend_bundle=spend_bundle,
additions=spend_bundle.additions(),
removals=spend_bundle.removals(),
wallet_id=self.wallet_info.id,
sent_to=[],
trade_id=None,
type=uint32(TransactionType.OUTGOING_TX.value),
name=token_bytes(),
)
await self.standard_wallet.push_transaction(did_record)
return spend_bundle
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)
await validate_get_routes(client, wallet_rpc_api)
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 full_node_api.farm_new_transaction_block(
FarmNewBlockProtocol(ph_2))
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: TransactionRecord = await client.create_signed_transaction(
[{
"amount": signed_tx_amount,
"puzzle_hash": ph_3
}])
assert tx_res.fee_amount == 0
assert tx_res.amount == signed_tx_amount
assert len(tx_res.additions) == 2 # The output and the change
assert any([
addition.amount == signed_tx_amount
for addition in tx_res.additions
])
push_res = await client_node.push_tx(tx_res.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.additions:
if addition.amount != signed_tx_amount:
coin_to_spend = 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.fee_amount == 100
assert tx_res.amount == 444 + 999
assert len(tx_res.additions) == 3 # The outputs and the change
assert any(
[addition.amount == 444 for addition in tx_res.additions])
assert any(
[addition.amount == 999 for addition in tx_res.additions])
assert sum([rem.amount for rem in tx_res.removals]) - sum(
[ad.amount for ad in tx_res.additions]) == 100
push_res = await client_node.push_tx(tx_res.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)
new_balance = initial_funds_eventually - tx_amount - signed_tx_amount - 444 - 999 - 100
await time_out_assert(5, eventual_balance, new_balance)
send_tx_res: TransactionRecord = await client.send_transaction_multi(
"1", [{
"amount": 555,
"puzzle_hash": ph_4
}, {
"amount": 666,
"puzzle_hash": ph_5
}],
fee=200)
assert send_tx_res is not None
assert send_tx_res.fee_amount == 200
assert send_tx_res.amount == 555 + 666
assert len(
send_tx_res.additions) == 3 # The outputs and the change
assert any(
[addition.amount == 555 for addition in send_tx_res.additions])
assert any(
[addition.amount == 666 for addition in send_tx_res.additions])
assert (sum([rem.amount for rem in send_tx_res.removals]) -
sum([ad.amount for ad in send_tx_res.additions]) == 200)
await asyncio.sleep(3)
for i in range(0, 5):
await client.farm_block(encode_puzzle_hash(ph_2, "xch"))
await asyncio.sleep(0.5)
new_balance = new_balance - 555 - 666 - 200
await time_out_assert(5, eventual_balance, new_balance)
address = await client.get_next_address("1", True)
assert len(address) > 10
transactions = await client.get_transactions("1")
assert len(transactions) > 1
all_transactions = await client.get_transactions("1")
# Test transaction pagination
some_transactions = await client.get_transactions("1", 0, 5)
some_transactions_2 = await client.get_transactions("1", 5, 10)
assert some_transactions == all_transactions[0:5]
assert some_transactions_2 == all_transactions[5:10]
# Testing sorts
# Test the default sort (CONFIRMED_AT_HEIGHT)
assert all_transactions == sorted(
all_transactions, key=attrgetter("confirmed_at_height"))
all_transactions = await client.get_transactions("1", reverse=True)
assert all_transactions == sorted(
all_transactions,
key=attrgetter("confirmed_at_height"),
reverse=True)
# Test RELEVANCE
await client.send_transaction("1", 1,
encode_puzzle_hash(ph_2, "xch")
) # Create a pending tx
all_transactions = await client.get_transactions(
"1", sort_key=SortKey.RELEVANCE)
sorted_transactions = sorted(all_transactions,
key=attrgetter("created_at_time"),
reverse=True)
sorted_transactions = sorted(sorted_transactions,
key=attrgetter("confirmed_at_height"),
reverse=True)
sorted_transactions = sorted(sorted_transactions,
key=attrgetter("confirmed"))
assert all_transactions == sorted_transactions
all_transactions = await client.get_transactions(
"1", sort_key=SortKey.RELEVANCE, reverse=True)
sorted_transactions = sorted(all_transactions,
key=attrgetter("created_at_time"))
sorted_transactions = sorted(sorted_transactions,
key=attrgetter("confirmed_at_height"))
sorted_transactions = sorted(sorted_transactions,
key=attrgetter("confirmed"),
reverse=True)
assert all_transactions == sorted_transactions
pks = await client.get_public_keys()
assert len(pks) == 1
assert (await client.get_height_info()) > 0
created_tx = await client.send_transaction("1", tx_amount, addr)
async def tx_in_mempool_2():
tx = await client.get_transaction("1", created_tx.name)
return tx.is_in_mempool()
await time_out_assert(5, tx_in_mempool_2, True)
assert len(await wallet.wallet_state_manager.tx_store.
get_unconfirmed_for_wallet(1)) == 2
await client.delete_unconfirmed_transactions("1")
assert len(await wallet.wallet_state_manager.tx_store.
get_unconfirmed_for_wallet(1)) == 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]
fingerprint = await client.get_logged_in_fingerprint()
assert fingerprint == pks[1]
# Add in reward addresses into farmer and pool for testing delete key checks
# set farmer to first private key
sk = await wallet_node.get_key_for_fingerprint(pks[0])
test_ph = create_puzzlehash_for_pk(
master_sk_to_wallet_sk(sk, uint32(0)).get_g1())
test_config = load_config(wallet_node.root_path, "config.yaml")
test_config["farmer"]["xch_target_address"] = encode_puzzle_hash(
test_ph, "txch")
# set pool to second private key
sk = await wallet_node.get_key_for_fingerprint(pks[1])
test_ph = create_puzzlehash_for_pk(
master_sk_to_wallet_sk(sk, uint32(0)).get_g1())
test_config["pool"]["xch_target_address"] = encode_puzzle_hash(
test_ph, "txch")
save_config(wallet_node.root_path, "config.yaml", test_config)
# Check first key
sk_dict = await client.check_delete_key(pks[0])
assert sk_dict["fingerprint"] == pks[0]
assert sk_dict["used_for_farmer_rewards"] is True
assert sk_dict["used_for_pool_rewards"] is False
# Check second key
sk_dict = await client.check_delete_key(pks[1])
assert sk_dict["fingerprint"] == pks[1]
assert sk_dict["used_for_farmer_rewards"] is False
assert sk_dict["used_for_pool_rewards"] is True
# Check unknown key
sk_dict = await client.check_delete_key(123456)
assert sk_dict["fingerprint"] == 123456
assert sk_dict["used_for_farmer_rewards"] is False
assert sk_dict["used_for_pool_rewards"] is False
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()
async def test1(self, simulation):
test_rpc_port = uint16(21522)
test_rpc_port_2 = uint16(21523)
harvester, farmer_api = simulation
def stop_node_cb():
pass
def stop_node_cb_2():
pass
config = bt.config
hostname = config["self_hostname"]
daemon_port = config["daemon_port"]
farmer_rpc_api = FarmerRpcApi(farmer_api.farmer)
harvester_rpc_api = HarvesterRpcApi(harvester)
rpc_cleanup = await start_rpc_server(
farmer_rpc_api,
hostname,
daemon_port,
test_rpc_port,
stop_node_cb,
bt.root_path,
config,
connect_to_daemon=False,
)
rpc_cleanup_2 = await start_rpc_server(
harvester_rpc_api,
hostname,
daemon_port,
test_rpc_port_2,
stop_node_cb_2,
bt.root_path,
config,
connect_to_daemon=False,
)
try:
client = await FarmerRpcClient.create(self_hostname, test_rpc_port,
bt.root_path, config)
client_2 = await HarvesterRpcClient.create(self_hostname,
test_rpc_port_2,
bt.root_path, config)
async def have_connections():
return len(await client.get_connections()) > 0
await time_out_assert(15, have_connections, True)
assert (await client.get_signage_point(std_hash(b"2"))) is None
assert len(await client.get_signage_points()) == 0
async def have_signage_points():
return len(await client.get_signage_points()) > 0
sp = farmer_protocol.NewSignagePoint(std_hash(b"1"),
std_hash(b"2"),
std_hash(b"3"), uint64(1),
uint64(1000000), uint8(2))
await farmer_api.new_signage_point(sp)
await time_out_assert(5, have_signage_points, True)
assert (await client.get_signage_point(std_hash(b"2"))) is not None
async def have_plots():
return len((await client_2.get_plots())["plots"]) > 0
await time_out_assert(5, have_plots, True)
res = await client_2.get_plots()
num_plots = len(res["plots"])
assert num_plots > 0
plot_dir = get_plot_dir() / "subdir"
plot_dir.mkdir(parents=True, exist_ok=True)
plot_dir_sub = get_plot_dir() / "subdir" / "subsubdir"
plot_dir_sub.mkdir(parents=True, exist_ok=True)
plotter = DiskPlotter()
filename = "test_farmer_harvester_rpc_plot.plot"
filename_2 = "test_farmer_harvester_rpc_plot2.plot"
plotter.create_plot_disk(
str(plot_dir),
str(plot_dir),
str(plot_dir),
filename,
18,
stream_plot_info_pk(bt.pool_pk, bt.farmer_pk,
AugSchemeMPL.key_gen(bytes([4] * 32))),
token_bytes(32),
128,
0,
2000,
0,
False,
)
# Making a plot with a puzzle hash encoded into it instead of pk
plot_id_2 = token_bytes(32)
plotter.create_plot_disk(
str(plot_dir),
str(plot_dir),
str(plot_dir),
filename_2,
18,
stream_plot_info_ph(std_hash(b"random ph"), bt.farmer_pk,
AugSchemeMPL.key_gen(bytes([5] * 32))),
plot_id_2,
128,
0,
2000,
0,
False,
)
# Making the same plot, in a different dir. This should not be farmed
plotter.create_plot_disk(
str(plot_dir_sub),
str(plot_dir_sub),
str(plot_dir_sub),
filename_2,
18,
stream_plot_info_ph(std_hash(b"random ph"), bt.farmer_pk,
AugSchemeMPL.key_gen(bytes([5] * 32))),
plot_id_2,
128,
0,
2000,
0,
False,
)
res_2 = await client_2.get_plots()
assert len(res_2["plots"]) == num_plots
# Test farmer get_plots
farmer_res = await client.get_plots()
assert len(list(farmer_res.values())[0]["plots"]) == num_plots
assert len(await client_2.get_plot_directories()) == 1
await client_2.add_plot_directory(str(plot_dir))
await client_2.add_plot_directory(str(plot_dir_sub))
assert len(await client_2.get_plot_directories()) == 3
res_2 = await client_2.get_plots()
assert len(res_2["plots"]) == num_plots + 2
await client_2.delete_plot(str(plot_dir / filename))
await client_2.delete_plot(str(plot_dir / filename_2))
await client_2.refresh_plots()
res_3 = await client_2.get_plots()
assert len(res_3["plots"]) == num_plots + 1
await client_2.remove_plot_directory(str(plot_dir))
assert len(await client_2.get_plot_directories()) == 2
targets_1 = await client.get_reward_targets(False)
assert "have_pool_sk" not in targets_1
assert "have_farmer_sk" not in targets_1
targets_2 = await client.get_reward_targets(True)
assert targets_2["have_pool_sk"] and targets_2["have_farmer_sk"]
new_ph: bytes32 = create_puzzlehash_for_pk(
master_sk_to_wallet_sk(bt.farmer_master_sk,
uint32(10)).get_g1())
new_ph_2: bytes32 = create_puzzlehash_for_pk(
master_sk_to_wallet_sk(bt.pool_master_sk,
uint32(472)).get_g1())
await client.set_reward_targets(
encode_puzzle_hash(new_ph, "xch"),
encode_puzzle_hash(new_ph_2, "xch"))
targets_3 = await client.get_reward_targets(True)
assert decode_puzzle_hash(targets_3["farmer_target"]) == new_ph
assert decode_puzzle_hash(targets_3["pool_target"]) == new_ph_2
assert targets_3["have_pool_sk"] and targets_3["have_farmer_sk"]
new_ph_3: bytes32 = create_puzzlehash_for_pk(
master_sk_to_wallet_sk(bt.pool_master_sk,
uint32(1888)).get_g1())
await client.set_reward_targets(
None, encode_puzzle_hash(new_ph_3, "xch"))
targets_4 = await client.get_reward_targets(True)
assert decode_puzzle_hash(targets_4["farmer_target"]) == new_ph
assert decode_puzzle_hash(targets_4["pool_target"]) == new_ph_3
assert not targets_4["have_pool_sk"] and targets_3["have_farmer_sk"]
root_path = farmer_api.farmer._root_path
config = load_config(root_path, "config.yaml")
assert config["farmer"][
"xch_target_address"] == encode_puzzle_hash(new_ph, "xch")
assert config["pool"]["xch_target_address"] == encode_puzzle_hash(
new_ph_3, "xch")
new_ph_3_encoded = encode_puzzle_hash(new_ph_3, "xch")
added_char = new_ph_3_encoded + "a"
with pytest.raises(ValueError):
await client.set_reward_targets(None, added_char)
replaced_char = new_ph_3_encoded[0:-1] + "a"
with pytest.raises(ValueError):
await client.set_reward_targets(None, replaced_char)
assert len((await client.get_pool_state())["pool_state"]) == 0
all_sks = farmer_api.farmer.keychain.get_all_private_keys()
auth_sk = master_sk_to_pooling_authentication_sk(
all_sks[0][0], 2, 1)
pool_list = [{
"launcher_id":
"ae4ef3b9bfe68949691281a015a9c16630fc8f66d48c19ca548fb80768791afa",
"authentication_public_key":
bytes(auth_sk.get_g1()).hex(),
"owner_public_key":
"84c3fcf9d5581c1ddc702cb0f3b4a06043303b334dd993ab42b2c320ebfa98e5ce558448615b3f69638ba92cf7f43da5",
"payout_instructions":
"c2b08e41d766da4116e388357ed957d04ad754623a915f3fd65188a8746cf3e8",
"pool_url":
"localhost",
"p2_singleton_puzzle_hash":
"16e4bac26558d315cded63d4c5860e98deb447cc59146dd4de06ce7394b14f17",
"target_puzzle_hash":
"344587cf06a39db471d2cc027504e8688a0a67cce961253500c956c73603fd58",
}]
config["pool"]["pool_list"] = pool_list
save_config(root_path, "config.yaml", config)
await farmer_api.farmer.update_pool_state()
pool_state = (await client.get_pool_state())["pool_state"]
assert len(pool_state) == 1
assert (
pool_state[0]["pool_config"]["payout_instructions"] ==
"c2b08e41d766da4116e388357ed957d04ad754623a915f3fd65188a8746cf3e8"
)
await client.set_payout_instructions(
hexstr_to_bytes(pool_state[0]["pool_config"]["launcher_id"]),
"1234vy")
pool_state = (await client.get_pool_state())["pool_state"]
assert pool_state[0]["pool_config"][
"payout_instructions"] == "1234vy"
finally:
# Checks that the RPC manages to stop the node
client.close()
client_2.close()
await client.await_closed()
await client_2.await_closed()
await rpc_cleanup()
await rpc_cleanup_2()