dont cache bls private key

src/harvester/harvester.py

@@ -88,9 +88,7 @@ class Harvester:
                     "plot-seed": prover.get_id(),
                     "pool_public_key": plot_info.pool_public_key,
                     "pool_contract_puzzle_hash": plot_info.pool_contract_puzzle_hash,
-                    "farmer_public_key": plot_info.farmer_public_key,
                     "plot_public_key": plot_info.plot_public_key,
-                    "local_sk": plot_info.local_sk,
                     "file_size": plot_info.file_size,
                     "time_modified": plot_info.time_modified,
                 }

src/harvester/harvester_api.py

@@ -21,6 +21,8 @@ from src.types.blockchain_format.sized_bytes import bytes32
 from src.util.api_decorators import api_request, peer_required
 from src.util.ints import uint8, uint64, uint32
 
+from src.plotting.plot_tools import parse_plot_info
+from src.wallet.derive_keys import master_sk_to_local_sk
 
 class HarvesterAPI:
     harvester: Harvester
@@ -116,8 +118,15 @@ class HarvesterAPI:
                                 self.harvester.log.error(f"Exception fetching full proof for {filename}")
                                 continue
 
+                            # 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(plot_info.prover.get_memo())
+                            local_sk = master_sk_to_local_sk(local_master_sk)
                             plot_public_key = ProofOfSpace.generate_plot_public_key(
-                                plot_info.local_sk.get_g1(), plot_info.farmer_public_key
+                                local_sk.get_g1(), farmer_public_key
                             )
                             responses.append(
                                 (
@@ -213,8 +222,15 @@ class HarvesterAPI:
             self.harvester.log.warning(f"KeyError plot {plot_filename} does not exist.")
             return
 
-        local_sk = plot_info.local_sk
+        # Look up local_sk from plot to save locked memory
-        agg_pk = ProofOfSpace.generate_plot_public_key(local_sk.get_g1(), plot_info.farmer_public_key)
+        (
+            pool_public_key_or_puzzle_hash,
+            farmer_public_key,
+            local_master_sk,
+        ) = parse_plot_info(plot_info.prover.get_memo())
+        local_sk = master_sk_to_local_sk(local_master_sk)
+
+        agg_pk = ProofOfSpace.generate_plot_public_key(local_sk.get_g1(), farmer_public_key)
 
         # This is only a partial signature. When combined with the farmer's half, it will
         # form a complete PrependSignature.
@@ -228,7 +244,7 @@ class HarvesterAPI:
             request.challenge_hash,
             request.sp_hash,
             local_sk.get_g1(),
-            plot_info.farmer_public_key,
+            farmer_public_key,
             message_signatures,
         )
 

src/plotting/check_plots.py

@@ -10,6 +10,9 @@ from src.plotting.plot_tools import load_plots, get_plot_filenames, find_duplica
 from src.util.hash import std_hash
 from src.wallet.derive_keys import master_sk_to_farmer_sk
 
+from src.plotting.plot_tools import parse_plot_info
+from src.wallet.derive_keys import master_sk_to_local_sk
+
 log = logging.getLogger(__name__)
 
 
@@ -83,8 +86,16 @@ def check_plots(root_path, num, challenge_start, grep_string, list_duplicates, d
         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}")
+        # 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):

src/plotting/plot_tools.py

@@ -22,9 +22,7 @@ class PlotInfo:
     prover: DiskProver
     pool_public_key: Optional[G1Element]
     pool_contract_puzzle_hash: Optional[bytes32]
-    farmer_public_key: G1Element
     plot_public_key: G1Element
-    local_sk: PrivateKey
     file_size: int
     time_modified: float
 
@@ -238,9 +236,7 @@ def load_plots(
                     prover,
                     pool_public_key,
                     pool_contract_puzzle_hash,
-                    farmer_public_key,
                     plot_public_key,
-                    local_sk,
                     stat_info.st_size,
                     stat_info.st_mtime,
                 )

src/util/block_tools.py

@@ -70,6 +70,9 @@ from src.wallet.derive_keys import (
 )
 from src.consensus.default_constants import DEFAULT_CONSTANTS
 
+from src.plotting.plot_tools import parse_plot_info
+from src.wallet.derive_keys import master_sk_to_local_sk
+
 test_constants = DEFAULT_CONSTANTS.replace(
     **{
         "DIFFICULTY_STARTING": 2 ** 12,
@@ -217,9 +220,16 @@ class BlockTools:
         """
         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)
+            # 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(plot_info.prover.get_memo())
+            local_sk = master_sk_to_local_sk(local_master_sk)
+            agg_pk = ProofOfSpace.generate_plot_public_key(local_sk.get_g1(), farmer_public_key)
             if agg_pk == plot_pk:
-                harv_share = AugSchemeMPL.sign(plot_info.local_sk, m, agg_pk)
+                harv_share = AugSchemeMPL.sign(local_sk, m, agg_pk)
                 farm_share = AugSchemeMPL.sign(farmer_sk, m, agg_pk)
                 return AugSchemeMPL.aggregate([harv_share, farm_share])
 
@@ -892,9 +902,17 @@ class BlockTools:
                     )
                     if required_iters < calculate_sp_interval_iters(constants, sub_slot_iters):
                         proof_xs: bytes = plot_info.prover.get_full_proof(new_challenge, proof_index)
+
+                        # 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(plot_info.prover.get_memo())
+                        local_sk = master_sk_to_local_sk(local_master_sk)
                         plot_pk = ProofOfSpace.generate_plot_public_key(
-                            plot_info.local_sk.get_g1(),
+                            local_sk.get_g1(),
-                            plot_info.farmer_public_key,
+                            farmer_public_key,
                         )
                         proof_of_space: ProofOfSpace = ProofOfSpace(
                             new_challenge,