async def setup_farmer(port, dic={}):
config = load_config(root_path, "config.yaml", "farmer")
pool_sk = bt.pool_sk
pool_target = create_puzzlehash_for_pk(
BLSPublicKey(bytes(pool_sk.get_public_key())))
wallet_sk = bt.wallet_sk
wallet_target = create_puzzlehash_for_pk(
BLSPublicKey(bytes(wallet_sk.get_public_key())))
key_config = {
"wallet_sk": bytes(wallet_sk).hex(),
"wallet_target": wallet_target.hex(),
"pool_sks": [bytes(pool_sk).hex()],
"pool_target": pool_target.hex(),
}
test_constants_copy = test_constants.copy()
for k in dic.keys():
test_constants_copy[k] = dic[k]
net_config = load_config(root_path, "config.yaml")
ping_interval = net_config.get("ping_interval")
network_id = net_config.get("network_id")
farmer = Farmer(config, key_config, test_constants_copy)
assert ping_interval is not None
assert network_id is not None
server = ChiaServer(port, farmer, NodeType.FARMER, ping_interval,
network_id)
_ = await server.start_server(farmer._on_connect)
yield (farmer, server)
server.close_all()
await server.await_closed()
def generate(args, parser):
root_path = args.root_path
keys_yaml = "keys.yaml"
key_config_filename = config_path_for_filename(root_path, keys_yaml)
if args.keys != ["keys"]:
parser.print_help()
print("\nTry `chia generate keys`")
return 1
if key_config_filename.exists():
# If the file exists, warn the user
yn = input(
f"The keys file {key_config_filename} already exists. Are you sure"
f" you want to override the keys? Plots might become invalid. (y/n): "
)
if not (yn.lower() == "y" or yn.lower() == "yes"):
return 1
else:
# Create the file if if doesn't exist
mkdir(key_config_filename.parent)
open(key_config_filename, "a").close()
key_config = load_config(root_path, keys_yaml)
if key_config is None:
key_config = {}
wallet_target = None
if args.wallet:
wallet_sk = ExtendedPrivateKey.from_seed(token_bytes(32))
wallet_target = create_puzzlehash_for_pk(
BLSPublicKey(bytes(wallet_sk.public_child(0).get_public_key()))
)
key_config["wallet_sk"] = bytes(wallet_sk).hex()
key_config["wallet_target"] = wallet_target.hex()
save_config(root_path, keys_yaml, key_config)
if args.harvester:
# Replaces the harvester's sk seed. Used to generate plot private keys, which are
# used to sign farmed blocks.
key_config["sk_seed"] = token_bytes(32).hex()
save_config(root_path, keys_yaml, key_config)
if args.pool:
# Replaces the pools keys and targes. Only useful if running a pool, or doing
# solo farming. The pool target allows spending of the coinbase.
pool_sks = [PrivateKey.from_seed(token_bytes(32)) for _ in range(2)]
if wallet_target is None:
pool_target = create_puzzlehash_for_pk(
BLSPublicKey(bytes(pool_sks[0].get_public_key()))
)
else:
pool_target = wallet_target
key_config["pool_sks"] = [bytes(pool_sk).hex() for pool_sk in pool_sks]
key_config["pool_target"] = pool_target.hex()
save_config(root_path, keys_yaml, key_config)
if args.pooltarget:
# Compute a new pool target and save it to the config
assert "wallet_target" in key_config
key_config["pool_target"] = key_config["wallet_target"]
save_config(root_path, keys_yaml, key_config)
def show_all_keys():
"""
Prints all keys and mnemonics (if available).
"""
private_keys = keychain.get_all_private_keys()
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:",
create_puzzlehash_for_pk(
master_sk_to_wallet_sk(sk, uint32(0)).get_g1()).hex(),
)
assert seed is not None
mnemonic = bytes_to_mnemonic(seed)
mnemonic_string = mnemonic_to_string(mnemonic)
print(" Mnemonic seed:")
print(mnemonic_string)
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,
}
def check_keys(new_root):
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)
def __init__(
self,
constants: ConsensusConstants = test_constants,
root_path: Optional[Path] = None,
):
self._tempdir = None
if root_path is None:
self._tempdir = tempfile.TemporaryDirectory()
root_path = Path(self._tempdir.name)
self.root_path = root_path
self.constants = constants
create_default_chia_config(root_path)
self.keychain = Keychain("testing-1.8.0", True)
self.keychain.delete_all_keys()
self.farmer_master_sk = self.keychain.add_private_key(
bytes_to_mnemonic(std_hash(b"block_tools farmer key")), ""
)
self.pool_master_sk = self.keychain.add_private_key(bytes_to_mnemonic(std_hash(b"block_tools pool key")), "")
self.farmer_pk = master_sk_to_farmer_sk(self.farmer_master_sk).get_g1()
self.pool_pk = master_sk_to_pool_sk(self.pool_master_sk).get_g1()
self.init_plots(root_path)
initialize_ssl(root_path)
self.farmer_ph: bytes32 = create_puzzlehash_for_pk(
master_sk_to_wallet_sk(self.farmer_master_sk, uint32(0)).get_g1()
)
self.pool_ph: bytes32 = create_puzzlehash_for_pk(
master_sk_to_wallet_sk(self.pool_master_sk, uint32(0)).get_g1()
)
self.all_sks: List[PrivateKey] = [sk for sk, _ in self.keychain.get_all_private_keys()]
self.pool_pubkeys: List[G1Element] = [master_sk_to_pool_sk(sk).get_g1() for sk in self.all_sks]
farmer_pubkeys: List[G1Element] = [master_sk_to_farmer_sk(sk).get_g1() for sk in self.all_sks]
if len(self.pool_pubkeys) == 0 or len(farmer_pubkeys) == 0:
raise RuntimeError("Keys not generated. Run `chia generate keys`")
_, loaded_plots, _, _ = load_plots({}, {}, farmer_pubkeys, self.pool_pubkeys, None, root_path)
self.plots: Dict[Path, PlotInfo] = loaded_plots
self._config = load_config(self.root_path, "config.yaml")
def check_keys(new_root):
print("\nchecking keys.yaml")
keys_config = load_config(new_root, "keys.yaml")
wallet_sk = ExtendedPrivateKey.from_bytes(
bytes.fromhex(keys_config["wallet_sk"]))
wallet_target = create_puzzlehash_for_pk(
BLSPublicKey(bytes(wallet_sk.public_child(0).get_public_key())))
if (wallet_target.hex() != keys_config["wallet_target"]
or wallet_target.hex() != keys_config["pool_target"]):
keys_config["wallet_target"] = wallet_target.hex()
keys_config["pool_target"] = wallet_target.hex()
print(
f"updating wallet target and pool target to {wallet_target.hex()}")
save_config(new_root, "keys.yaml", keys_config)
def check_keys(new_root):
keychain: Keychain = Keychain()
all_pubkeys = keychain.get_all_public_keys()
if len(all_pubkeys) == 0:
print(
"No keys are present in the keychain. Generate them with 'chia keys generate_and_add'"
)
return
all_targets = [
create_puzzlehash_for_pk(
BLSPublicKey(bytes(epk.public_child(0).get_public_key()))
).hex()
for epk in all_pubkeys
]
config: Dict = load_config(new_root, "config.yaml")
# Set the destinations
if (
"xch_target_puzzle_hash" not in config["farmer"]
or config["farmer"]["xch_target_puzzle_hash"] not in all_targets
):
print(
f"Setting the xch destination address for coinbase fees reward to {all_targets[0]}"
)
config["farmer"]["xch_target_puzzle_hash"] = all_targets[0]
if "pool" in config:
if (
"xch_target_puzzle_hash" not in config["pool"]
or config["pool"]["xch_target_puzzle_hash"] not in all_targets
):
print(
f"Setting the xch destination address for coinbase reward to {all_targets[0]}"
)
config["pool"]["xch_target_puzzle_hash"] = all_targets[0]
# Set the pool pks in the farmer
all_pubkeys_hex = set([bytes(pk.get_public_key()).hex() for pk in all_pubkeys])
if "pool_public_keys" in config["farmer"]:
for pk_hex in config["farmer"]["pool_public_keys"]:
# Add original ones in config
all_pubkeys_hex.add(pk_hex)
config["farmer"]["pool_public_keys"] = all_pubkeys_hex
save_config(new_root, "config.yaml", config)
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 __init__(
self,
root_path: Optional[Path] = None,
real_plots: bool = False,
):
self._tempdir = None
if root_path is None:
self._tempdir = tempfile.TemporaryDirectory()
root_path = Path(self._tempdir.name)
self.root_path = root_path
self.real_plots = real_plots
if not real_plots:
create_default_chia_config(root_path)
initialize_ssl(root_path)
# No real plots supplied, so we will use the small test plots
self.use_any_pos = True
self.keychain = Keychain("testing-1.8.0", True)
self.keychain.delete_all_keys()
self.farmer_master_sk = self.keychain.add_private_key(
bytes_to_mnemonic(std_hash(b"block_tools farmer key")), "")
self.pool_master_sk = self.keychain.add_private_key(
bytes_to_mnemonic(std_hash(b"block_tools pool key")), "")
self.farmer_pk = master_sk_to_farmer_sk(
self.farmer_master_sk).get_g1()
self.pool_pk = master_sk_to_pool_sk(self.pool_master_sk).get_g1()
plot_dir = get_plot_dir()
mkdir(plot_dir)
temp_dir = plot_dir / "tmp"
mkdir(temp_dir)
args = Namespace()
# Can't go much lower than 18, since plots start having no solutions
args.size = 18
# Uses many plots for testing, in order to guarantee proofs of space at every height
args.num = 40
args.buffer = 32
args.farmer_public_key = bytes(self.farmer_pk).hex()
args.pool_public_key = bytes(self.pool_pk).hex()
args.tmp_dir = temp_dir
args.tmp2_dir = plot_dir
args.final_dir = plot_dir
args.plotid = None
args.memo = None
test_private_keys = [
AugSchemeMPL.key_gen(std_hash(bytes([i])))
for i in range(args.num)
]
try:
# No datetime in the filename, to get deterministic filenames and not replot
create_plots(
args,
root_path,
use_datetime=False,
test_private_keys=test_private_keys,
)
except KeyboardInterrupt:
shutil.rmtree(plot_dir, ignore_errors=True)
sys.exit(1)
else:
initialize_ssl(root_path)
self.keychain = Keychain()
self.use_any_pos = False
sk_and_ent = self.keychain.get_first_private_key()
assert sk_and_ent is not None
self.farmer_master_sk = sk_and_ent[0]
self.pool_master_sk = sk_and_ent[0]
self.farmer_ph = create_puzzlehash_for_pk(
master_sk_to_wallet_sk(self.farmer_master_sk, uint32(0)).get_g1())
self.pool_ph = create_puzzlehash_for_pk(
master_sk_to_wallet_sk(self.pool_master_sk, uint32(0)).get_g1())
self.all_sks = self.keychain.get_all_private_keys()
self.pool_pubkeys: List[G1Element] = [
master_sk_to_pool_sk(sk).get_g1() for sk, _ in self.all_sks
]
farmer_pubkeys: List[G1Element] = [
master_sk_to_farmer_sk(sk).get_g1() for sk, _ in self.all_sks
]
if len(self.pool_pubkeys) == 0 or len(farmer_pubkeys) == 0:
raise RuntimeError("Keys not generated. Run `chia generate keys`")
_, self.plots, _, _ = load_plots({}, {}, farmer_pubkeys,
self.pool_pubkeys, root_path)
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))
res_3 = await client_2.get_plots()
assert len(res_3["plots"]) == num_plots
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 __init__(
self,
root_path: Path = TEST_ROOT_PATH,
real_plots: bool = False,
):
create_default_chia_config(root_path)
initialize_ssl(root_path)
self.root_path = root_path
self.n_wesolowski = uint8(0)
self.real_plots = real_plots
if not real_plots:
# No real plots supplied, so we will use the small test plots
self.use_any_pos = True
self.plot_config: Dict = {"plots": {}}
# Can't go much lower than 19, since plots start having no solutions
k: uint8 = uint8(19)
# Uses many plots for testing, in order to guarantee proofs of space at every height
num_plots = 40
# Use the empty string as the seed for the private key
self.keychain = Keychain("testing", True)
self.keychain.delete_all_keys()
self.keychain.add_private_key_seed(b"block_tools")
pool_sk: PrivateKey = self.keychain.get_all_private_keys(
)[0][0].get_private_key()
pool_pk: PublicKey = pool_sk.get_public_key()
plot_sks: List[PrivateKey] = [
PrivateKey.from_seed(pn.to_bytes(4, "big"))
for pn in range(num_plots)
]
plot_pks: List[PublicKey] = [
sk.get_public_key() for sk in plot_sks
]
plot_seeds: List[bytes32] = [
ProofOfSpace.calculate_plot_seed(pool_pk, plot_pk)
for plot_pk in plot_pks
]
plot_dir = get_plot_dir(root_path)
mkdir(plot_dir)
filenames: List[str] = [
f"genesis-plots-{k}{std_hash(int.to_bytes(i, 4, 'big')).hex()}.dat"
for i in range(num_plots)
]
done_filenames = set()
temp_dir = plot_dir / "plot.tmp"
mkdir(temp_dir)
try:
for pn, filename in enumerate(filenames):
if not (plot_dir / filename).exists():
plotter = DiskPlotter()
plotter.create_plot_disk(
str(plot_dir),
str(plot_dir),
str(plot_dir),
filename,
k,
b"genesis",
plot_seeds[pn],
)
done_filenames.add(filename)
self.plot_config["plots"][str(plot_dir / filename)] = {
"pool_pk": bytes(pool_pk).hex(),
"sk": bytes(plot_sks[pn]).hex(),
"pool_sk": bytes(pool_sk).hex(),
}
save_config(self.root_path, "plots.yaml", self.plot_config)
except KeyboardInterrupt:
for filename in filenames:
if (filename not in done_filenames
and (plot_dir / filename).exists()):
(plot_dir / filename).unlink()
sys.exit(1)
else:
try:
plot_config = load_config(DEFAULT_ROOT_PATH, "plots.yaml")
normal_config = load_config(DEFAULT_ROOT_PATH, "config.yaml")
except FileNotFoundError:
raise RuntimeError(
"Plots not generated. Run chia-create-plots")
self.keychain = Keychain(testing=False)
private_keys: List[PrivateKey] = [
k.get_private_key()
for (k, _) in self.keychain.get_all_private_keys()
]
pool_pubkeys: List[PublicKey] = [
sk.get_public_key() for sk in private_keys
]
if len(private_keys) == 0:
raise RuntimeError(
"Keys not generated. Run `chia generate keys`")
self.prover_dict, _, _ = load_plots(normal_config["harvester"],
plot_config, pool_pubkeys,
DEFAULT_ROOT_PATH)
new_plot_config: Dict = {"plots": {}}
for key, value in plot_config["plots"].items():
for sk in private_keys:
if (bytes(sk.get_public_key()).hex() == value["pool_pk"]
and key in self.prover_dict):
new_plot_config["plots"][key] = value
new_plot_config["plots"][key]["pool_sk"] = bytes(
sk).hex()
self.plot_config = new_plot_config
self.use_any_pos = False
a = self.plot_config["plots"]
print(f"Using {len(a)} reals plots to initialize block_tools")
private_key = self.keychain.get_all_private_keys()[0][0]
self.fee_target = create_puzzlehash_for_pk(
BLSPublicKey(bytes(private_key.public_child(1).get_public_key())))
def main():
"""
Allows replacing keys of farmer, harvester, and pool, all default to True.
"""
root_path = DEFAULT_ROOT_PATH
keys_yaml = "keys.yaml"
parser = argparse.ArgumentParser(description="Chia key generator script.")
parser.add_argument(
"-a",
"--harvester",
type=str2bool,
nargs="?",
const=True,
default=True,
help="Regenerate plot key seed",
)
parser.add_argument(
"-p",
"--pool",
type=str2bool,
nargs="?",
const=True,
default=True,
help="Regenerate pool keys",
)
parser.add_argument(
"-w",
"--wallet",
type=str2bool,
nargs="?",
const=True,
default=True,
help="Regenerate wallet keys",
)
args = parser.parse_args()
key_config_filename = config_path_for_filename(root_path, keys_yaml)
if key_config_filename.exists():
# If the file exists, warn the user
yn = input(
f"The keys file {key_config_filename} already exists. Are you sure"
f" you want to override the keys? Plots might become invalid. (y/n): "
)
if not (yn.lower() == "y" or yn.lower() == "yes"):
quit()
else:
# Create the file if if doesn't exist
mkdir(key_config_filename.parent)
open(key_config_filename, "a").close()
key_config = load_config(root_path, keys_yaml)
if key_config is None:
key_config = {}
wallet_target = None
if args.wallet:
wallet_sk = ExtendedPrivateKey.from_seed(token_bytes(32))
wallet_target = create_puzzlehash_for_pk(
BLSPublicKey(bytes(wallet_sk.public_child(0).get_public_key())))
key_config["wallet_sk"] = bytes(wallet_sk).hex()
key_config["wallet_target"] = wallet_target.hex()
save_config(root_path, keys_yaml, key_config)
if args.harvester:
# Replaces the harvester's sk seed. Used to generate plot private keys, which are
# used to sign farmed blocks.
key_config["sk_seed"] = token_bytes(32).hex()
save_config(root_path, keys_yaml, key_config)
if args.pool:
# Replaces the pools keys and targes. Only useful if running a pool, or doing
# solo farming. The pool target allows spending of the coinbase.
pool_sks = [PrivateKey.from_seed(token_bytes(32)) for _ in range(2)]
if wallet_target is None:
pool_target = create_puzzlehash_for_pk(
BLSPublicKey(bytes(pool_sks[0].get_public_key())))
else:
pool_target = wallet_target
key_config["pool_sks"] = [bytes(pool_sk).hex() for pool_sk in pool_sks]
key_config["pool_target"] = pool_target.hex()
save_config(root_path, keys_yaml, key_config)
def migrate_from(
old_root: Path, new_root: Path, manifest: List[str], do_not_migrate_keys: List[str]
):
"""
Copy all the files in "manifest" to the new config directory.
"""
if old_root == new_root:
print(f"same as new path, exiting")
return 1
if not old_root.is_dir():
print(f"{old_root} not found")
return 0
print(f"\n{old_root} found")
print(f"Copying files from {old_root} to {new_root}\n")
not_found = []
for f in manifest:
old_path = old_root / f
new_path = new_root / f
if old_path.is_file():
print(f"{new_path}")
mkdir(new_path.parent)
shutil.copy(old_path, new_path)
else:
not_found.append(f)
print(f"{old_path} not found, skipping")
# update config yaml with new keys
config: Dict = load_config(new_root, "config.yaml")
config_str: str = initial_config_file("config.yaml")
default_config: Dict = yaml.safe_load(config_str)
flattened_keys = unflatten_properties({k: "" for k in do_not_migrate_keys})
dict_add_new_default(config, default_config, flattened_keys)
save_config(new_root, "config.yaml", config)
# migrate plots
# for now, we simply leave them where they are
# and make what may have been relative paths absolute
if "config/trusted.key" in not_found or "config/trusted.key" in not_found:
initialize_ssl(new_root)
plots_config: Dict = load_config(new_root, "plots.yaml")
plot_root = (
load_config(new_root, "config.yaml").get("harvester", {}).get("plot_root", ".")
)
old_plots_root: Path = path_from_root(old_root, plot_root)
new_plots_root: Path = path_from_root(new_root, plot_root)
old_plot_paths = plots_config.get("plots", {})
if len(old_plot_paths) == 0:
print("no plots found, no plots migrated")
return 1
print("\nmigrating plots.yaml")
new_plot_paths: Dict = {}
for path, values in old_plot_paths.items():
old_path_full = path_from_root(old_plots_root, path)
new_path_relative = make_path_relative(old_path_full, new_plots_root)
print(f"rewriting {path}\n as {new_path_relative}")
new_plot_paths[str(new_path_relative)] = values
plots_config_new: Dict = {"plots": new_plot_paths}
save_config(new_root, "plots.yaml", plots_config_new)
print("\nUpdated plots.yaml to point to where your existing plots are.")
print(
"\nYour plots have not been moved so be careful deleting old preferences folders."
)
print("\nmigrating keys.yaml")
keys_config = load_config(new_root, "keys.yaml")
wallet_sk = ExtendedPrivateKey.from_bytes(bytes.fromhex(keys_config["wallet_sk"]))
wallet_target = create_puzzlehash_for_pk(
BLSPublicKey(bytes(wallet_sk.public_child(0).get_public_key()))
)
if (
wallet_target.hex() != keys_config["wallet_target"]
or wallet_target.hex() != keys_config["pool_target"]
):
keys_config["wallet_target"] = wallet_target.hex()
keys_config["pool_target"] = wallet_target.hex()
print(f"updating wallet target and pool target to {wallet_target.hex()}")
save_config(new_root, "keys.yaml", keys_config)
print("\nIf you want to move your plot files, you should also modify")
print(f"{config_path_for_filename(new_root, 'plots.yaml')}")
return 1
