chia-blockchain 2.2.0rc1__tar.gz → 2.2.0rc3__tar.gz

{chia-blockchain-2.2.0rc1 → chia-blockchain-2.2.0rc3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: chia-blockchain
-Version: 2.2.0rc1
+Version: 2.2.0rc3
 Summary: Chia blockchain full node, farmer, timelord, and wallet.
 Home-page: https://chia.net/
 Author: Mariano Sorgente
@@ -20,7 +20,7 @@ Requires-Dist: chiabip158==1.3
 Requires-Dist: chiapos==2.0.3
 Requires-Dist: clvm==0.9.8
 Requires-Dist: clvm_tools==0.4.7
-Requires-Dist: chia_rs==0.4.0
+Requires-Dist: chia_rs==0.4.1
 Requires-Dist: clvm-tools-rs==0.1.40
 Requires-Dist: aiohttp==3.9.1
 Requires-Dist: aiosqlite==0.19.0

{chia-blockchain-2.2.0rc1 → chia-blockchain-2.2.0rc3}/build_scripts/assets/deb/control.j2

@@ -1,5 +1,5 @@
 Package: chia-blockchain-cli
-Version: {{ CHIA_INSTALLER_VERSION }}
+Version: {{ CHIA_DEB_CONTROL_VERSION }}
 Architecture: {{ PLATFORM }}
 Maintainer: Chia Network Inc <hello@chia.net>
 Description: Chia Blockchain

{chia-blockchain-2.2.0rc1 → chia-blockchain-2.2.0rc3}/build_scripts/build_linux_deb-2-installer.sh

@@ -51,12 +51,20 @@ bash ./build_license_directory.sh
 
 # Builds CLI only .deb
 # need j2 for templating the control file
+format_deb_version_string() {
+  version_str=$1
+  # Use sed to conform to expected apt versioning conventions:
+  # - conditionally insert a hyphen before 'rc' or 'beta' if not already present
+  # - replace '.dev' with '-dev'
+  echo "$version_str" | sed -E 's/([0-9])(rc|beta)/\1-\2/g; s/\.dev/-dev/g'
+}
 pip install j2cli
 CLI_DEB_BASE="chia-blockchain-cli_$CHIA_INSTALLER_VERSION-1_$PLATFORM"
 mkdir -p "dist/$CLI_DEB_BASE/opt/chia"
 mkdir -p "dist/$CLI_DEB_BASE/usr/bin"
 mkdir -p "dist/$CLI_DEB_BASE/DEBIAN"
 mkdir -p "dist/$CLI_DEB_BASE/etc/systemd/system"
+CHIA_DEB_CONTROL_VERSION=$(format_deb_version_string "$CHIA_INSTALLER_VERSION"); export CHIA_DEB_CONTROL_VERSION
 j2 -o "dist/$CLI_DEB_BASE/DEBIAN/control" assets/deb/control.j2
 cp assets/systemd/*.service "dist/$CLI_DEB_BASE/etc/systemd/system/"
 cp -r dist/daemon/* "dist/$CLI_DEB_BASE/opt/chia/"
@@ -89,6 +97,11 @@ if [ "$PLATFORM" = "arm64" ]; then
   # @TODO Maybe versions of sub dependencies should be managed by gem lock file.
   # @TODO Once ruby 2.6 can be installed on `apt install ruby`, installing public_suffix below should be removed.
   sudo gem install public_suffix -v 4.0.7
+  # ERROR:  Error installing fpm:
+  #     The last version of dotenv (>= 0) to support your Ruby & RubyGems was 2.8.1. Try installing it with `gem install dotenv -v 2.8.1` and then running the current command again
+  #     dotenv requires Ruby version >= 3.0. The current ruby version is 2.7.0.0.
+  # @TODO Once ruby 3.0 can be installed on `apt install ruby`, installing dotenv below should be removed.
+  sudo gem install dotenv -v 2.8.1
   sudo gem install fpm
   echo USE_SYSTEM_FPM=true npx electron-builder build --linux deb --arm64 \
     --config.extraMetadata.name=chia-blockchain \

{chia-blockchain-2.2.0rc1 → chia-blockchain-2.2.0rc3}/chia/cmds/configure.py

@@ -4,9 +4,11 @@ from pathlib import Path
 from typing import Optional
 
 import click
+import yaml
 
 from chia.server.outbound_message import NodeType
 from chia.util.config import (
+    initial_config_file,
     load_defaults_for_missing_services,
     lock_and_load_config,
     save_config,
@@ -103,6 +105,24 @@ def configure(
         if testnet:
             if testnet == "true" or testnet == "t":
                 print("Setting Testnet")
+                # check if network_overrides.constants.testnet11 exists
+                if (
+                    "testnet11" not in config["network_overrides"]["constants"]
+                    or "testnet11" not in config["network_overrides"]["config"]
+                ):
+                    print("Testnet11 constants missing. Adding to config...")
+                    initial_config_str: str = initial_config_file("config.yaml")
+                    initial_config = yaml.safe_load(initial_config_str)
+                    if "testnet11" not in config["network_overrides"]["constants"]:
+                        config["network_overrides"]["constants"]["testnet11"] = initial_config["network_overrides"][
+                            "constants"
+                        ]["testnet11"]
+
+                    if "testnet11" not in config["network_overrides"]["config"]:
+                        config["network_overrides"]["config"]["testnet11"] = initial_config["network_overrides"][
+                            "config"
+                        ]["testnet11"]
+
                 testnet_port = "58444"
                 testnet_introducer = "introducer-testnet11.chia.net"
                 testnet_dns_introducer = "dns-introducer-testnet11.chia.net"

{chia-blockchain-2.2.0rc1 → chia-blockchain-2.2.0rc3}/chia/cmds/data.py

@@ -51,14 +51,15 @@ def create_changelist_option() -> Callable[[FC], FC]:
     )
 
 
-def create_key_option() -> Callable[[FC], FC]:
+def create_key_option(multiple: bool = False) -> Callable[[FC], FC]:
     return click.option(
         "-k",
         "--key",
-        "key_string",
+        "key_strings" if multiple else "key_string",
         help="str representing the key",
         type=str,
         required=True,
+        multiple=multiple,
     )
 
 
@@ -530,3 +531,48 @@ def wallet_log_in(
             fingerprint=fingerprint,
         )
     )
+
+
+@data_cmd.command(
+    "get_proof",
+    help="Obtains a merkle proof of inclusion for a given key",
+)
+@create_data_store_id_option()
+@create_rpc_port_option()
+@create_key_option(multiple=True)
+@options.create_fingerprint()
+def get_proof(
+    id: str,
+    key_strings: List[str],
+    data_rpc_port: int,
+    fingerprint: Optional[int],
+) -> None:
+    from chia.cmds.data_funcs import get_proof_cmd
+
+    store_id = bytes32.from_hexstr(id)
+
+    run(get_proof_cmd(rpc_port=data_rpc_port, store_id=store_id, fingerprint=fingerprint, key_strings=key_strings))
+
+
+@data_cmd.command(
+    "verify_proof",
+    help="Verifies a merkle proof of inclusion",
+)
+@click.option(
+    "-p",
+    "--proof",
+    "proof_string",
+    help="Proof to validate in JSON format.",
+    type=str,
+)
+@create_rpc_port_option()
+@options.create_fingerprint()
+def verify_proof(
+    proof_string: str,
+    data_rpc_port: int,
+    fingerprint: Optional[int],
+) -> None:
+    from chia.cmds.data_funcs import verify_proof_cmd
+
+    proof_dict = json.loads(proof_string)
+    run(verify_proof_cmd(rpc_port=data_rpc_port, fingerprint=fingerprint, proof=proof_dict))

{chia-blockchain-2.2.0rc1 → chia-blockchain-2.2.0rc3}/chia/cmds/data_funcs.py

@@ -286,3 +286,32 @@ async def clear_pending_roots(
         print(json.dumps(result, indent=4, sort_keys=True))
 
     return result
+
+
+async def get_proof_cmd(
+    store_id: bytes32,
+    key_strings: List[str],
+    rpc_port: Optional[int],
+    root_path: Optional[Path] = None,
+    fingerprint: Optional[int] = None,
+) -> Dict[str, Any]:
+    result = dict()
+    async with get_client(rpc_port=rpc_port, fingerprint=fingerprint, root_path=root_path) as (client, _):
+        result = await client.get_proof(store_id=store_id, keys=[hexstr_to_bytes(key) for key in key_strings])
+        print(json.dumps(result, indent=4, sort_keys=True))
+
+    return result
+
+
+async def verify_proof_cmd(
+    proof: Dict[str, Any],
+    rpc_port: Optional[int],
+    root_path: Optional[Path] = None,
+    fingerprint: Optional[int] = None,
+) -> Dict[str, Any]:
+    result = dict()
+    async with get_client(rpc_port=rpc_port, fingerprint=fingerprint, root_path=root_path) as (client, _):
+        result = await client.verify_proof(proof=proof)
+        print(json.dumps(result, indent=4, sort_keys=True))
+
+    return result

{chia-blockchain-2.2.0rc1 → chia-blockchain-2.2.0rc3}/chia/data_layer/data_layer.py

@@ -312,14 +312,12 @@ class DataLayer:
             node = await self.data_store.get_node_by_key(tree_id=store_id, key=key, root_hash=root_hash)
             return node.hash
 
-    async def get_value(self, store_id: bytes32, key: bytes, root_hash: Optional[bytes32] = None) -> Optional[bytes]:
+    async def get_value(self, store_id: bytes32, key: bytes, root_hash: Optional[bytes32] = None) -> bytes:
         await self._update_confirmation_status(tree_id=store_id)
 
         async with self.data_store.transaction():
+            # this either returns the node or raises an exception
             res = await self.data_store.get_node_by_key(tree_id=store_id, key=key, root_hash=root_hash)
-            if res is None:
-                self.log.error("Failed to fetch key")
-                return None
             return res.value
 
     async def get_keys_values(self, store_id: bytes32, root_hash: Optional[bytes32]) -> List[TerminalNode]:

{chia-blockchain-2.2.0rc1 → chia-blockchain-2.2.0rc3}/chia/data_layer/data_layer_errors.py

@@ -42,5 +42,9 @@ class OfferIntegrityError(Exception):
     pass
 
 
+class ProofIntegrityError(Exception):
+    pass
+
+
 class LauncherCoinNotFoundError(Exception):
     pass

{chia-blockchain-2.2.0rc1 → chia-blockchain-2.2.0rc3}/chia/data_layer/data_layer_util.py

@@ -9,15 +9,19 @@ from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Type, Union
 import aiosqlite as aiosqlite
 from typing_extensions import final
 
+from chia.data_layer.data_layer_errors import ProofIntegrityError
+from chia.server.ws_connection import WSChiaConnection
 from chia.types.blockchain_format.program import Program
 from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.util.byte_types import hexstr_to_bytes
 from chia.util.db_wrapper import DBWrapper2
-from chia.util.ints import uint64
+from chia.util.ints import uint8, uint64
 from chia.util.streamable import Streamable, streamable
+from chia.wallet.db_wallet.db_wallet_puzzles import create_host_fullpuz
 
 if TYPE_CHECKING:
     from chia.data_layer.data_store import DataStore
+    from chia.wallet.wallet_node import WalletNode
 
 
 def internal_hash(left_hash: bytes32, right_hash: bytes32) -> bytes32:
@@ -735,3 +739,157 @@ class InsertResult:
 class UnsubscribeData:
     tree_id: bytes32
     retain_data: bool
+
+
+#
+# GetProof and VerifyProof support classes
+#
+@streamable
+@dataclasses.dataclass(frozen=True)
+class ProofLayer(Streamable):
+    # This class is basically Layer but streamable
+    other_hash_side: uint8
+    other_hash: bytes32
+    combined_hash: bytes32
+
+
+@streamable
+@dataclasses.dataclass(frozen=True)
+class HashOnlyProof(Streamable):
+    key_clvm_hash: bytes32
+    value_clvm_hash: bytes32
+    node_hash: bytes32
+    layers: List[ProofLayer]
+
+    def root(self) -> bytes32:
+        if len(self.layers) == 0:
+            return self.node_hash
+        return self.layers[-1].combined_hash
+
+    @classmethod
+    def from_key_value(cls, key: bytes, value: bytes, node_hash: bytes32, layers: List[ProofLayer]) -> HashOnlyProof:
+        return cls(
+            key_clvm_hash=Program.to(key).get_tree_hash(),
+            value_clvm_hash=Program.to(value).get_tree_hash(),
+            node_hash=node_hash,
+            layers=layers,
+        )
+
+
+@streamable
+@dataclasses.dataclass(frozen=True)
+class KeyValueHashes(Streamable):
+    key_clvm_hash: bytes32
+    value_clvm_hash: bytes32
+
+
+@streamable
+@dataclasses.dataclass(frozen=True)
+class ProofResultInclusions(Streamable):
+    store_id: bytes32
+    inclusions: List[KeyValueHashes]
+
+
+@streamable
+@dataclasses.dataclass(frozen=True)
+class GetProofRequest(Streamable):
+    store_id: bytes32
+    keys: List[bytes]
+
+
+@streamable
+@dataclasses.dataclass(frozen=True)
+class StoreProofsHashes(Streamable):
+    store_id: bytes32
+    proofs: List[HashOnlyProof]
+
+
+@streamable
+@dataclasses.dataclass(frozen=True)
+class DLProof(Streamable):
+    store_proofs: StoreProofsHashes
+    coin_id: bytes32
+    inner_puzzle_hash: bytes32
+
+
+@streamable
+@dataclasses.dataclass(frozen=True)
+class GetProofResponse(Streamable):
+    proof: DLProof
+    success: bool
+
+
+@streamable
+@dataclasses.dataclass(frozen=True)
+class VerifyProofResponse(Streamable):
+    verified_clvm_hashes: ProofResultInclusions
+    current_root: bool
+    success: bool
+
+
+def dl_verify_proof_internal(dl_proof: DLProof, puzzle_hash: bytes32) -> List[KeyValueHashes]:
+    """Verify a proof of inclusion for a DL singleton"""
+
+    verified_keys: List[KeyValueHashes] = []
+
+    for reference_proof in dl_proof.store_proofs.proofs:
+        inner_puz_hash = dl_proof.inner_puzzle_hash
+        host_fullpuz_program = create_host_fullpuz(
+            inner_puz_hash, reference_proof.root(), dl_proof.store_proofs.store_id
+        )
+        expected_puzzle_hash = host_fullpuz_program.get_tree_hash_precalc(inner_puz_hash)
+
+        if puzzle_hash != expected_puzzle_hash:
+            raise ProofIntegrityError(
+                "Invalid Proof: incorrect puzzle hash: expected:"
+                f"{expected_puzzle_hash.hex()} received: {puzzle_hash.hex()}"
+            )
+
+        proof = ProofOfInclusion(
+            node_hash=reference_proof.node_hash,
+            layers=[
+                ProofOfInclusionLayer(
+                    other_hash_side=Side(layer.other_hash_side),
+                    other_hash=layer.other_hash,
+                    combined_hash=layer.combined_hash,
+                )
+                for layer in reference_proof.layers
+            ],
+        )
+
+        leaf_hash = internal_hash(left_hash=reference_proof.key_clvm_hash, right_hash=reference_proof.value_clvm_hash)
+        if leaf_hash != proof.node_hash:
+            raise ProofIntegrityError("Invalid Proof: node hash does not match key and value")
+
+        if not proof.valid():
+            raise ProofIntegrityError("Invalid Proof: invalid proof of inclusion found")
+
+        verified_keys.append(
+            KeyValueHashes(key_clvm_hash=reference_proof.key_clvm_hash, value_clvm_hash=reference_proof.value_clvm_hash)
+        )
+
+    return verified_keys
+
+
+async def dl_verify_proof(
+    request: Dict[str, Any],
+    wallet_node: WalletNode,
+    peer: WSChiaConnection,
+) -> Dict[str, Any]:
+    """Verify a proof of inclusion for a DL singleton"""
+
+    dlproof = DLProof.from_json_dict(request)
+
+    coin_id = dlproof.coin_id
+    coin_states = await wallet_node.get_coin_state([coin_id], peer=peer)
+    if len(coin_states) == 0:
+        raise ProofIntegrityError(f"Invalid Proof: No DL singleton found at coin id: {coin_id.hex()}")
+
+    verified_keys = dl_verify_proof_internal(dlproof, coin_states[0].coin.puzzle_hash)
+
+    response = VerifyProofResponse(
+        verified_clvm_hashes=ProofResultInclusions(dlproof.store_proofs.store_id, verified_keys),
+        success=True,
+        current_root=coin_states[0].spent_height is None,
+    )
+    return response.to_json_dict()

{chia-blockchain-2.2.0rc1 → chia-blockchain-2.2.0rc3}/chia/data_layer/download_data.py

@@ -158,7 +158,8 @@ async def insert_from_delta_file(
         if downloader is None:
             # use http downloader
             if not await http_download(client_foldername, filename, proxy_url, server_info, timeout, log):
-                break
+                await data_store.server_misses_file(tree_id, server_info, timestamp)
+                return False
         else:
             log.info(f"Using downloader {downloader} for store {tree_id.hex()}.")
             async with aiohttp.ClientSession() as session:

{chia-blockchain-2.2.0rc1 → chia-blockchain-2.2.0rc3}/chia/farmer/farmer_api.py

@@ -153,6 +153,7 @@ class FarmerAPI:
                     new_proof_of_space.sp_hash,
                     [sp.challenge_chain_sp, sp.reward_chain_sp],
                     message_data=sp_src_data,
+                    rc_block_unfinished=None,
                 )
 
                 if new_proof_of_space.sp_hash not in self.farmer.proofs_of_space:
@@ -284,6 +285,7 @@ class FarmerAPI:
                     new_proof_of_space.sp_hash,
                     [m_to_sign],
                     message_data=m_src_data,
+                    rc_block_unfinished=None,
                 )
                 response: Any = await peer.call_api(HarvesterAPI.request_signatures, request)
                 if not isinstance(response, harvester_protocol.RespondSignatures):
@@ -565,30 +567,28 @@ class FarmerAPI:
             full_node_request.quality_string
         ]
 
-        foliage_block_data: Optional[SignatureRequestSourceData] = None
-        foliage_transaction_block_data: Optional[SignatureRequestSourceData] = None
-        include_source_data = False
+        message_data: Optional[List[Optional[SignatureRequestSourceData]]] = None
 
         if full_node_request.foliage_block_data is not None:
-            include_source_data = True
-            foliage_block_data = SignatureRequestSourceData(
-                uint8(SigningDataKind.FOLIAGE_BLOCK_DATA), bytes(full_node_request.foliage_block_data)
-            )
-
-        if full_node_request.foliage_transaction_block_data is not None:
-            assert foliage_block_data
-            include_source_data = True
-            foliage_transaction_block_data = SignatureRequestSourceData(
-                uint8(SigningDataKind.FOLIAGE_TRANSACTION_BLOCK),
-                bytes(full_node_request.foliage_transaction_block_data),
-            )
+            message_data = [
+                SignatureRequestSourceData(
+                    uint8(SigningDataKind.FOLIAGE_BLOCK_DATA), bytes(full_node_request.foliage_block_data)
+                ),
+                None
+                if full_node_request.foliage_transaction_block_data is None
+                else SignatureRequestSourceData(
+                    uint8(SigningDataKind.FOLIAGE_TRANSACTION_BLOCK),
+                    bytes(full_node_request.foliage_transaction_block_data),
+                ),
+            ]
 
         request = harvester_protocol.RequestSignatures(
             plot_identifier,
             challenge_hash,
             sp_hash,
             [full_node_request.foliage_block_data_hash, full_node_request.foliage_transaction_block_hash],
-            message_data=[foliage_block_data, foliage_transaction_block_data] if include_source_data else None,
+            message_data=message_data,
+            rc_block_unfinished=full_node_request.rc_block_unfinished,
         )
 
         response = await self.farmer.server.call_api_of_specific(HarvesterAPI.request_signatures, request, node_id)

{chia-blockchain-2.2.0rc1 → chia-blockchain-2.2.0rc3}/chia/full_node/coin_store.py

@@ -598,7 +598,7 @@ class CoinStore:
                 "unspent.coin_parent, "
                 "parent.amount, "
                 "parent.coin_parent "
-                "FROM coin_record AS unspent "
+                "FROM coin_record AS unspent INDEXED BY coin_puzzle_hash "
                 "LEFT JOIN coin_record AS parent ON unspent.coin_parent = parent.coin_name "
                 "WHERE unspent.spent_index = 0 "
                 "AND parent.spent_index > 0 "

{chia-blockchain-2.2.0rc1 → chia-blockchain-2.2.0rc3}/chia/full_node/full_node_api.py

@@ -48,6 +48,7 @@ from chia.types.blockchain_format.coin import Coin, hash_coin_ids
 from chia.types.blockchain_format.foliage import FoliageBlockData, FoliageTransactionBlock
 from chia.types.blockchain_format.pool_target import PoolTarget
 from chia.types.blockchain_format.proof_of_space import verify_and_get_quality_string
+from chia.types.blockchain_format.reward_chain_block import RewardChainBlockUnfinished
 from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.blockchain_format.sub_epoch_summary import SubEpochSummary
 from chia.types.coin_record import CoinRecord
@@ -1021,8 +1022,10 @@ class FullNodeAPI:
 
             foliage_block_data: Optional[FoliageBlockData] = None
             foliage_transaction_block_data: Optional[FoliageTransactionBlock] = None
+            rc_block_unfinished: Optional[RewardChainBlockUnfinished] = None
             if request.include_signature_source_data:
                 foliage_block_data = unfinished_block.foliage.foliage_block_data
+                rc_block_unfinished = unfinished_block.reward_chain_block
                 if unfinished_block.is_transaction_block():
                     foliage_transaction_block_data = unfinished_block.foliage_transaction_block
 
@@ -1030,8 +1033,9 @@ class FullNodeAPI:
                 quality_string,
                 foliage_sb_data_hash,
                 foliage_transaction_block_hash,
-                foliage_block_data,
-                foliage_transaction_block_data,
+                foliage_block_data=foliage_block_data,
+                foliage_transaction_block_data=foliage_transaction_block_data,
+                rc_block_unfinished=rc_block_unfinished,
             )
             await peer.send_message(make_msg(ProtocolMessageTypes.request_signed_values, message))
 

{chia-blockchain-2.2.0rc1 → chia-blockchain-2.2.0rc3}/chia/full_node/mempool.py

@@ -29,7 +29,7 @@ log = logging.getLogger(__name__)
 # Maximum number of mempool items that can be skipped (not considered) during
 # the creation of a block bundle. An item is skipped if it won't fit in the
 # block we're trying to create.
-MAX_SKIPPED_ITEMS = 20
+MAX_SKIPPED_ITEMS = 10
 
 # Threshold after which we stop including mempool items with eligible spends
 # during the creation of a block bundle. We do that to avoid spending too much

{chia-blockchain-2.2.0rc1 → chia-blockchain-2.2.0rc3}/chia/full_node/mempool_manager.py

@@ -169,6 +169,8 @@ class MempoolManager:
     peak: Optional[BlockRecordProtocol]
     mempool: Mempool
     _worker_queue_size: int
+    max_block_clvm_cost: uint64
+    max_tx_clvm_cost: uint64
 
     def __init__(
         self,
@@ -177,6 +179,7 @@ class MempoolManager:
         multiprocessing_context: Optional[BaseContext] = None,
         *,
         single_threaded: bool = False,
+        max_tx_clvm_cost: Optional[uint64] = None,
     ):
         self.constants: ConsensusConstants = consensus_constants
 
@@ -190,8 +193,11 @@ class MempoolManager:
         # spends.
         self.nonzero_fee_minimum_fpc = 5
 
-        BLOCK_SIZE_LIMIT_FACTOR = 0.5
+        BLOCK_SIZE_LIMIT_FACTOR = 0.6
         self.max_block_clvm_cost = uint64(self.constants.MAX_BLOCK_COST_CLVM * BLOCK_SIZE_LIMIT_FACTOR)
+        self.max_tx_clvm_cost = (
+            max_tx_clvm_cost if max_tx_clvm_cost is not None else uint64(self.constants.MAX_BLOCK_COST_CLVM // 2)
+        )
         self.mempool_max_total_cost = int(self.constants.MAX_BLOCK_COST_CLVM * self.constants.MEMPOOL_BLOCK_BUFFER)
 
         # Transactions that were unable to enter mempool, used for retry. (they were invalid)
@@ -306,7 +312,7 @@ class MempoolManager:
                 self.pool,
                 validate_clvm_and_signature,
                 new_spend_bytes,
-                self.max_block_clvm_cost,
+                self.max_tx_clvm_cost,
                 self.constants,
                 self.peak.height,
             )
@@ -513,7 +519,7 @@ class MempoolManager:
         if cost == 0:
             return Err.UNKNOWN, None, []
 
-        if cost > self.max_block_clvm_cost:
+        if cost > self.max_tx_clvm_cost:
             return Err.BLOCK_COST_EXCEEDS_MAX, None, []
 
         # this is not very likely to happen, but it's here to ensure SQLite

{chia-blockchain-2.2.0rc1 → chia-blockchain-2.2.0rc3}/chia/protocols/farmer_protocol.py

@@ -9,6 +9,7 @@ from chia.types.blockchain_format.classgroup import ClassgroupElement
 from chia.types.blockchain_format.foliage import FoliageBlockData, FoliageTransactionBlock
 from chia.types.blockchain_format.pool_target import PoolTarget
 from chia.types.blockchain_format.proof_of_space import ProofOfSpace
+from chia.types.blockchain_format.reward_chain_block import RewardChainBlockUnfinished
 from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.blockchain_format.slots import ChallengeChainSubSlot, RewardChainSubSlot
 from chia.util.ints import uint8, uint32, uint64
@@ -78,6 +79,7 @@ class RequestSignedValues(Streamable):
     foliage_transaction_block_hash: bytes32
     foliage_block_data: Optional[FoliageBlockData] = None
     foliage_transaction_block_data: Optional[FoliageTransactionBlock] = None
+    rc_block_unfinished: Optional[RewardChainBlockUnfinished] = None
 
 
 @streamable

{chia-blockchain-2.2.0rc1 → chia-blockchain-2.2.0rc3}/chia/protocols/harvester_protocol.py

@@ -7,6 +7,7 @@ from typing import List, Optional, Tuple
 from chia_rs import G1Element, G2Element
 
 from chia.types.blockchain_format.proof_of_space import ProofOfSpace
+from chia.types.blockchain_format.reward_chain_block import RewardChainBlockUnfinished
 from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.util.ints import int16, uint8, uint32, uint64
 from chia.util.streamable import Streamable, streamable
@@ -90,7 +91,9 @@ class RequestSignatures(Streamable):
     challenge_hash: bytes32
     sp_hash: bytes32
     messages: List[bytes32]
+    # This, and rc_block_unfinished are only set when using a third-party harvester (see CHIP-22)
     message_data: Optional[List[Optional[SignatureRequestSourceData]]]
+    rc_block_unfinished: Optional[RewardChainBlockUnfinished]
 
 
 @streamable