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 __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 __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.wallet_sk: PrivateKey = PrivateKey.from_seed(b"coinbase")
self.coinbase_target = std_hash(bytes(self.wallet_sk.get_public_key()))
self.fee_target = std_hash(bytes(self.wallet_sk.get_public_key()))
self.n_wesolowski = uint8(0)
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
pool_sk: PrivateKey = PrivateKey.from_seed(b"")
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 = root_path / "plots"
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(),
}
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:
# Real plots supplied, so we will use these instead of the test plots
config = load_config_cli(root_path, "config.yaml", "harvester")
try:
key_config = load_config(root_path, "keys.yaml")
except FileNotFoundError:
raise RuntimeError("Keys not generated. Run `chia generate keys`")
try:
plot_config = load_config(root_path, "plots.yaml")
except FileNotFoundError:
raise RuntimeError("Plots not generated. Run chia-create-plots")
pool_sks: List[PrivateKey] = [
PrivateKey.from_bytes(bytes.fromhex(ce))
for ce in key_config["pool_sks"]
]
for key, value in plot_config["plots"].items():
for pool_sk in pool_sks:
if bytes(pool_sk.get_public_key()).hex() == value["pool_pk"]:
plot_config["plots"][key]["pool_sk"] = bytes(pool_sk).hex()
self.plot_config = plot_config
self.use_any_pos = False
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())))
