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_default_farmer_public_key() -> G1Element:
keychain: Keychain = Keychain()
sk_ent = keychain.get_first_private_key()
if sk_ent is None:
raise RuntimeError(
"No keys, please run 'chia keys generate' or provide a public key with -f"
)
return master_sk_to_farmer_sk(sk_ent[0]).get_g1()
def get_farmer_public_key(alt_fingerprint: Optional[int] = None) -> G1Element:
sk_ent: Optional[Tuple[PrivateKey, bytes]]
keychain: Keychain = Keychain()
if alt_fingerprint is not None:
sk_ent = keychain.get_private_key_by_fingerprint(alt_fingerprint)
else:
sk_ent = keychain.get_first_private_key()
if sk_ent is None:
raise RuntimeError("No keys, please run 'chia keys add', 'chia keys generate' or provide a public key with -f")
return master_sk_to_farmer_sk(sk_ent[0]).get_g1()
def __init__(
self,
farmer_config: Dict,
pool_config: Dict,
keychain: Keychain,
consensus_constants: ConsensusConstants,
):
self.config = farmer_config
# Keep track of all sps, keyed on challenge chain signage point hash
self.sps: Dict[bytes32, List[farmer_protocol.NewSignagePoint]] = {}
# Keep track of harvester plot identifier (str), target sp index, and PoSpace for each challenge
self.proofs_of_space: Dict[bytes32, List[Tuple[str, ProofOfSpace]]] = {}
# Quality string to plot identifier and challenge_hash, for use with harvester.RequestSignatures
self.quality_str_to_identifiers: Dict[bytes32, Tuple[str, bytes32, bytes32, bytes32]] = {}
# number of responses to each signage point
self.number_of_responses: Dict[bytes32, int] = {}
# A dictionary of keys to time added. These keys refer to keys in the above 4 dictionaries. This is used
# to periodically clear the memory
self.cache_add_time: Dict[bytes32, uint64] = {}
self.cache_clear_task: asyncio.Task
self.constants = consensus_constants
self._shut_down = False
self.server: Any = None
self.keychain = keychain
self.state_changed_callback: Optional[Callable] = None
self.log = log
all_sks = self.keychain.get_all_private_keys()
self._private_keys = [master_sk_to_farmer_sk(sk) for sk, _ in all_sks] + [
master_sk_to_pool_sk(sk) for sk, _ in all_sks
]
if len(self.get_public_keys()) == 0:
error_str = "No keys exist. Please run 'chia keys generate' or open the UI."
raise RuntimeError(error_str)
# This is the farmer configuration
self.wallet_target = decode_puzzle_hash(self.config["xch_target_address"])
self.pool_public_keys = [G1Element.from_bytes(bytes.fromhex(pk)) for pk in self.config["pool_public_keys"]]
# This is the pool configuration, which should be moved out to the pool once it exists
self.pool_target = decode_puzzle_hash(pool_config["xch_target_address"])
self.pool_sks_map: Dict = {}
for key in self.get_private_keys():
self.pool_sks_map[bytes(key.get_g1())] = key
assert len(self.wallet_target) == 32
assert len(self.pool_target) == 32
if len(self.pool_sks_map) == 0:
error_str = "No keys exist. Please run 'chia keys generate' or open the UI."
raise RuntimeError(error_str)
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 get_plot_signature(self, m: bytes32, plot_pk: G1Element) -> G2Element:
"""
Returns the plot signature of the header data.
"""
farmer_sk = master_sk_to_farmer_sk(self.all_sks[0])
for _, plot_info in self.plots.items():
agg_pk = ProofOfSpace.generate_plot_public_key(plot_info.local_sk.get_g1(), plot_info.farmer_public_key)
if agg_pk == plot_pk:
harv_share = AugSchemeMPL.sign(plot_info.local_sk, m, agg_pk)
farm_share = AugSchemeMPL.sign(farmer_sk, m, agg_pk)
return AugSchemeMPL.aggregate([harv_share, farm_share])
raise ValueError(f"Do not have key {plot_pk}")
def get_plot_signature(self, header_data: HeaderData,
plot_pk: G1Element) -> Optional[G2Element]:
"""
Returns the plot signature of the header data.
"""
farmer_sk = master_sk_to_farmer_sk(self.all_sks[0][0])
for _, plot_info in self.plots.items():
agg_pk = ProofOfSpace.generate_plot_public_key(
plot_info.local_sk.get_g1(), plot_info.farmer_public_key)
if agg_pk == plot_pk:
m = header_data.get_hash()
harv_share = AugSchemeMPL.sign(plot_info.local_sk, m, agg_pk)
farm_share = AugSchemeMPL.sign(farmer_sk, m, agg_pk)
return AugSchemeMPL.aggregate([harv_share, farm_share])
return None
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)
def check_plots(args, root_path):
config = load_config(root_path, "config.yaml")
if args.num is not None:
num = args.num
else:
num = 20
if args.grep_string is not None:
match_str = args.grep_string
else:
match_str = None
v = Verifier()
log.info("Loading plots in config.yaml using plot_tools loading code\n")
kc: Keychain = Keychain()
pks = [
master_sk_to_farmer_sk(sk).get_g1()
for sk, _ in kc.get_all_private_keys()
]
pool_public_keys = [
G1Element.from_bytes(bytes.fromhex(pk))
for pk in config["farmer"]["pool_public_keys"]
]
_, provers, failed_to_open_filenames, no_key_filenames = load_plots(
{},
{},
pks,
pool_public_keys,
match_str,
root_path,
open_no_key_filenames=True,
)
if len(provers) > 0:
log.info("")
log.info("")
log.info(f"Starting to test each plot with {num} challenges each\n")
total_good_plots: Counter = Counter()
total_bad_plots = 0
total_size = 0
for plot_path, plot_info in provers.items():
pr = plot_info.prover
log.info(f"Testing plot {plot_path} k={pr.get_size()}")
log.info(f"\tPool public key: {plot_info.pool_public_key}")
log.info(f"\tFarmer public key: {plot_info.farmer_public_key}")
log.info(f"\tLocal sk: {plot_info.local_sk}")
total_proofs = 0
try:
for i in range(num):
challenge = std_hash(i.to_bytes(32, "big"))
for index, quality_str in enumerate(
pr.get_qualities_for_challenge(challenge)):
proof = pr.get_full_proof(challenge, index)
total_proofs += 1
ver_quality_str = v.validate_proof(pr.get_id(),
pr.get_size(),
challenge, proof)
assert quality_str == ver_quality_str
except BaseException as e:
if isinstance(e, KeyboardInterrupt):
log.warning("Interrupted, closing")
return
log.error(
f"{type(e)}: {e} error in proving/verifying for plot {plot_path}"
)
if total_proofs > 0:
log.info(
f"\tProofs {total_proofs} / {num}, {round(total_proofs/float(num), 4)}"
)
total_good_plots[pr.get_size()] += 1
total_size += plot_path.stat().st_size
else:
total_bad_plots += 1
log.error(
f"\tProofs {total_proofs} / {num}, {round(total_proofs/float(num), 4)}"
)
log.info("")
log.info("")
log.info("Summary")
total_plots: int = sum(list(total_good_plots.values()))
log.info(
f"Found {total_plots} valid plots, total size {total_size / (1024 * 1024 * 1024 * 1024):.5f} TiB"
)
for (k, count) in sorted(dict(total_good_plots).items()):
log.info(f"{count} plots of size {k}")
grand_total_bad = total_bad_plots + len(failed_to_open_filenames)
if grand_total_bad > 0:
log.warning(f"{grand_total_bad} invalid plots")
if len(no_key_filenames) > 0:
log.warning(
f"There are {len(no_key_filenames)} plots with a farmer or pool public key that "
f"is not on this machine. The farmer private key must be in the keychain in order to "
f"farm them, use 'chia keys' to transfer keys. The pool public keys must be in the config.yaml"
)
def check_plots(root_path, num, challenge_start, grep_string, list_duplicates,
debug_show_memo):
config = load_config(root_path, "config.yaml")
if num is not None:
if num == 0:
log.warning("Not opening plot files")
else:
if num < 5:
log.warning(
f"{num} challenges is too low, setting it to the minimum of 5"
)
num = 5
if num < 30:
log.warning(
"Use 30 challenges (our default) for balance of speed and accurate results"
)
else:
num = 30
if challenge_start is not None:
num_start = challenge_start
num_end = num_start + num
else:
num_start = 0
num_end = num
challenges = num_end - num_start
if grep_string is not None:
match_str = grep_string
else:
match_str = None
if list_duplicates:
log.warning("Checking for duplicate Plot IDs")
log.info("Plot filenames expected to end with -[64 char plot ID].plot")
show_memo: bool = debug_show_memo
if list_duplicates:
plot_filenames: Dict[Path, List[Path]] = get_plot_filenames(
config["harvester"])
all_filenames: List[Path] = []
for paths in plot_filenames.values():
all_filenames += paths
find_duplicate_plot_IDs(all_filenames)
if num == 0:
return
v = Verifier()
log.info("Loading plots in config.yaml using plot_tools loading code\n")
kc: Keychain = Keychain()
pks = [
master_sk_to_farmer_sk(sk).get_g1()
for sk, _ in kc.get_all_private_keys()
]
pool_public_keys = [
G1Element.from_bytes(bytes.fromhex(pk))
for pk in config["farmer"]["pool_public_keys"]
]
_, provers, failed_to_open_filenames, no_key_filenames = load_plots(
{},
{},
pks,
pool_public_keys,
match_str,
show_memo,
root_path,
open_no_key_filenames=True,
)
if len(provers) > 0:
log.info("")
log.info("")
log.info(f"Starting to test each plot with {num} challenges each\n")
total_good_plots: Counter = Counter()
total_bad_plots = 0
total_size = 0
bad_plots_list: List[Path] = []
for plot_path, plot_info in provers.items():
pr = plot_info.prover
log.info(f"Testing plot {plot_path} k={pr.get_size()}")
log.info(f"\tPool public key: {plot_info.pool_public_key}")
# Look up local_sk from plot to save locked memory
(
pool_public_key_or_puzzle_hash,
farmer_public_key,
local_master_sk,
) = parse_plot_info(pr.get_memo())
local_sk = master_sk_to_local_sk(local_master_sk)
log.info(f"\tFarmer public key: {farmer_public_key}")
log.info(f"\tLocal sk: {local_sk}")
total_proofs = 0
caught_exception: bool = False
for i in range(num_start, num_end):
challenge = std_hash(i.to_bytes(32, "big"))
# Some plot errors cause get_qualities_for_challenge to throw a RuntimeError
try:
for index, quality_str in enumerate(
pr.get_qualities_for_challenge(challenge)):
# Other plot errors cause get_full_proof or validate_proof to throw an AssertionError
try:
proof = pr.get_full_proof(challenge, index)
total_proofs += 1
ver_quality_str = v.validate_proof(
pr.get_id(), pr.get_size(), challenge, proof)
assert quality_str == ver_quality_str
except AssertionError as e:
log.error(
f"{type(e)}: {e} error in proving/verifying for plot {plot_path}"
)
caught_exception = True
except BaseException as e:
if isinstance(e, KeyboardInterrupt):
log.warning("Interrupted, closing")
return
log.error(
f"{type(e)}: {e} error in getting challenge qualities for plot {plot_path}"
)
caught_exception = True
if caught_exception is True:
break
if total_proofs > 0 and caught_exception is False:
log.info(
f"\tProofs {total_proofs} / {challenges}, {round(total_proofs/float(challenges), 4)}"
)
total_good_plots[pr.get_size()] += 1
total_size += plot_path.stat().st_size
else:
total_bad_plots += 1
log.error(
f"\tProofs {total_proofs} / {challenges}, {round(total_proofs/float(challenges), 4)}"
)
bad_plots_list.append(plot_path)
log.info("")
log.info("")
log.info("Summary")
total_plots: int = sum(list(total_good_plots.values()))
log.info(
f"Found {total_plots} valid plots, total size {total_size / (1024 * 1024 * 1024 * 1024):.5f} TiB"
)
for (k, count) in sorted(dict(total_good_plots).items()):
log.info(f"{count} plots of size {k}")
grand_total_bad = total_bad_plots + len(failed_to_open_filenames)
if grand_total_bad > 0:
log.warning(f"{grand_total_bad} invalid plots found:")
for bad_plot_path in bad_plots_list:
log.warning(f"{bad_plot_path}")
if len(no_key_filenames) > 0:
log.warning(
f"There are {len(no_key_filenames)} plots with a farmer or pool public key that "
f"is not on this machine. The farmer private key must be in the keychain in order to "
f"farm them, use 'chia keys' to transfer keys. The pool public keys must be in the config.yaml"
)
def _get_private_keys(self):
all_sks = self.keychain.get_all_private_keys()
return [master_sk_to_farmer_sk(sk) for sk, _ in all_sks] + [
master_sk_to_pool_sk(sk) for sk, _ in all_sks
]
