chia-blockchain 2.5.1rc1__py3-none-any.whl

chia/consensus/get_block_challenge.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+import logging
+from typing import Union
+
+from chia.consensus.block_record import BlockRecord
+from chia.consensus.blockchain_interface import BlockRecordsProtocol
+from chia.consensus.constants import ConsensusConstants
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.full_block import FullBlock
+from chia.types.header_block import HeaderBlock
+from chia.types.unfinished_block import UnfinishedBlock
+from chia.types.unfinished_header_block import UnfinishedHeaderBlock
+from chia.util.ints import uint64
+
+log = logging.getLogger(__name__)
+
+
+def final_eos_is_already_included(
+    header_block: Union[UnfinishedHeaderBlock, UnfinishedBlock, HeaderBlock, FullBlock],
+    blocks: BlockRecordsProtocol,
+    sub_slot_iters: uint64,
+) -> bool:
+    """
+    Args:
+        header_block: An overflow block, with potentially missing information about the new sub slot
+        blocks: all blocks that have been included before header_block
+        sub_slot_iters: sub_slot_iters at the header_block
+
+    Returns: True iff the missing sub slot was already included in a previous block. Returns False if the sub
+    slot was not included yet, and therefore it is the responsibility of this block to include it
+
+    """
+    if len(header_block.finished_sub_slots) > 0:
+        # We already have an included empty sub slot, which means the prev block is 2 sub slots behind.
+        return False
+    curr: BlockRecord = blocks.block_record(header_block.prev_header_hash)
+
+    # We also check if curr is close to header_block, which means it's in the same sub slot
+    seen_overflow_block = curr.overflow and (header_block.total_iters - curr.total_iters < sub_slot_iters // 2)
+    while not curr.first_in_sub_slot and not curr.height == 0:
+        if curr.overflow and header_block.total_iters - curr.total_iters < sub_slot_iters // 2:
+            seen_overflow_block = True
+        curr = blocks.block_record(curr.prev_hash)
+
+    if curr.first_in_sub_slot and seen_overflow_block:
+        # We have seen another overflow block in this slot (same as header_block), therefore there are no
+        # missing sub slots
+        return True
+
+    # We have not seen any overflow blocks, therefore header_block will have to include the missing sub slot in
+    # the future
+    return False
+
+
+def get_block_challenge(
+    constants: ConsensusConstants,
+    header_block: Union[UnfinishedHeaderBlock, UnfinishedBlock, HeaderBlock, FullBlock],
+    blocks: BlockRecordsProtocol,
+    genesis_block: bool,
+    overflow: bool,
+    skip_overflow_last_ss_validation: bool,
+) -> bytes32:
+    if len(header_block.finished_sub_slots) > 0:
+        if overflow:
+            # New sub-slot with overflow block
+            if skip_overflow_last_ss_validation:
+                # In this case, we are missing the final sub-slot bundle (it's not finished yet), however
+                # There is a whole empty slot before this block is infused
+                challenge: bytes32 = header_block.finished_sub_slots[-1].challenge_chain.get_hash()
+            else:
+                challenge = header_block.finished_sub_slots[
+                    -1
+                ].challenge_chain.challenge_chain_end_of_slot_vdf.challenge
+        else:
+            # No overflow, new slot with a new challenge
+            challenge = header_block.finished_sub_slots[-1].challenge_chain.get_hash()
+    else:
+        if genesis_block:
+            challenge = constants.GENESIS_CHALLENGE
+        else:
+            if overflow:
+                if skip_overflow_last_ss_validation:
+                    # Overflow infusion without the new slot, so get the last challenge
+                    challenges_to_look_for = 1
+                else:
+                    # Overflow infusion, so get the second to last challenge. skip_overflow_last_ss_validation is False,
+                    # Which means no sub slots are omitted
+                    challenges_to_look_for = 2
+            else:
+                challenges_to_look_for = 1
+            reversed_challenge_hashes: list[bytes32] = []
+            curr: BlockRecord = blocks.block_record(header_block.prev_header_hash)
+            while len(reversed_challenge_hashes) < challenges_to_look_for:
+                if curr.first_in_sub_slot:
+                    assert curr.finished_challenge_slot_hashes is not None
+                    reversed_challenge_hashes += reversed(curr.finished_challenge_slot_hashes)
+                    if len(reversed_challenge_hashes) >= challenges_to_look_for:
+                        break
+                if curr.height == 0:
+                    assert curr.finished_challenge_slot_hashes is not None
+                    assert len(curr.finished_challenge_slot_hashes) > 0
+                    break
+                curr = blocks.block_record(curr.prev_hash)
+            challenge = reversed_challenge_hashes[challenges_to_look_for - 1]
+    return challenge

chia/consensus/get_block_generator.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from collections.abc import Awaitable
+from typing import Callable, Optional
+
+from chia.types.block_protocol import BlockInfo
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.generator_types import BlockGenerator
+from chia.util.ints import uint32
+
+
+async def get_block_generator(
+    lookup_block_generators: Callable[[bytes32, set[uint32]], Awaitable[dict[uint32, bytes]]],
+    block: BlockInfo,
+) -> Optional[BlockGenerator]:
+    ref_list = block.transactions_generator_ref_list
+    if block.transactions_generator is None:
+        assert len(ref_list) == 0
+        return None
+    if len(ref_list) == 0:
+        return BlockGenerator(block.transactions_generator, [])
+
+    generator_refs = set(ref_list)
+    generators: dict[uint32, bytes] = await lookup_block_generators(block.prev_header_hash, generator_refs)
+
+    result = [generators[height] for height in block.transactions_generator_ref_list]
+    return BlockGenerator(block.transactions_generator, result)

chia/consensus/make_sub_epoch_summary.py

@@ -0,0 +1,210 @@
+from __future__ import annotations
+
+import logging
+from typing import Optional, Union
+
+from chia.consensus.block_record import BlockRecord
+from chia.consensus.blockchain_interface import BlockRecordsProtocol
+from chia.consensus.constants import ConsensusConstants
+from chia.consensus.deficit import calculate_deficit
+from chia.consensus.difficulty_adjustment import (
+    _get_next_difficulty,
+    _get_next_sub_slot_iters,
+    can_finish_sub_and_full_epoch,
+    get_next_sub_slot_iters_and_difficulty,
+    height_can_be_first_in_epoch,
+)
+from chia.consensus.pot_iterations import calculate_ip_iters, calculate_sp_iters, is_overflow_block
+from chia.types.blockchain_format.sub_epoch_summary import SubEpochSummary
+from chia.types.full_block import FullBlock
+from chia.types.unfinished_block import UnfinishedBlock
+from chia.util.ints import uint8, uint32, uint64, uint128
+
+log = logging.getLogger(__name__)
+
+
+def make_sub_epoch_summary(
+    constants: ConsensusConstants,
+    blocks: BlockRecordsProtocol,
+    blocks_included_height: uint32,
+    prev_prev_block: BlockRecord,
+    new_difficulty: Optional[uint64],
+    new_sub_slot_iters: Optional[uint64],
+    prev_ses_block: Optional[BlockRecord] = None,
+) -> SubEpochSummary:
+    """
+    Creates a sub-epoch-summary object, assuming that the first block in the new sub-epoch is at height
+    "blocks_included_height". Prev_prev_b is the second to last block in the previous sub-epoch. On a new epoch,
+    new_difficulty and new_sub_slot_iters are also added.
+
+    Args:
+        constants: consensus constants being used for this chain
+        blocks: dictionary from header hash to SBR of all included SBR
+        blocks_included_height: block height in which the SES will be included
+        prev_prev_block: second to last block in epoch
+        new_difficulty: difficulty in new epoch
+        new_sub_slot_iters: sub slot iters in new epoch
+    """
+    assert prev_prev_block.height == blocks_included_height - 2
+    # First sub_epoch
+    # This is not technically because more blocks can potentially be included than 2*MAX_SUB_SLOT_BLOCKS,
+    # But assuming less than 128 overflow blocks get infused in the first 2 slots, it's not an issue
+    if (blocks_included_height + constants.MAX_SUB_SLOT_BLOCKS) // constants.SUB_EPOCH_BLOCKS <= 1:
+        return SubEpochSummary(
+            constants.GENESIS_CHALLENGE,
+            constants.GENESIS_CHALLENGE,
+            uint8(0),
+            None,
+            None,
+        )
+    if prev_ses_block is None:
+        curr: BlockRecord = prev_prev_block
+        while curr.sub_epoch_summary_included is None:
+            curr = blocks.block_record(curr.prev_hash)
+        prev_ses_block = curr
+    assert prev_ses_block is not None
+    assert prev_ses_block.sub_epoch_summary_included is not None
+    assert prev_ses_block.finished_reward_slot_hashes is not None
+
+    prev_ses = prev_ses_block.sub_epoch_summary_included.get_hash()
+    return SubEpochSummary(
+        prev_ses,
+        prev_ses_block.finished_reward_slot_hashes[-1],
+        uint8(prev_ses_block.height % constants.SUB_EPOCH_BLOCKS),
+        new_difficulty,
+        new_sub_slot_iters,
+    )
+
+
+def next_sub_epoch_summary(
+    constants: ConsensusConstants,
+    blocks: BlockRecordsProtocol,
+    required_iters: uint64,
+    block: Union[UnfinishedBlock, FullBlock],
+    can_finish_soon: bool = False,
+) -> Optional[SubEpochSummary]:
+    """
+    Returns the sub-epoch summary that can be included in the block after block. If it should include one. Block
+    must be eligible to be the last block in the epoch. If not, returns None. Assumes that there is a new slot
+    ending after block.
+
+    Args:
+        constants: consensus constants being used for this chain
+        blocks: interface to cached SBR
+        required_iters: required iters of the proof of space in block
+        block: the (potentially) last block in the new epoch
+        can_finish_soon: this is useful when sending SES to timelords. We might not be able to finish it, but we will
+            soon (within MAX_SUB_SLOT_BLOCKS)
+
+    Returns:
+        object: the new sub-epoch summary
+    """
+    signage_point_index = block.reward_chain_block.signage_point_index
+    prev_b: Optional[BlockRecord] = blocks.try_block_record(block.prev_header_hash)
+    if prev_b is None or prev_b.height == 0:
+        return None
+
+    if len(block.finished_sub_slots) > 0 and block.finished_sub_slots[0].challenge_chain.new_difficulty is not None:
+        # We just included a sub-epoch summary
+        return None
+
+    assert prev_b is not None
+    # This is the ssi of the current block
+
+    sub_slot_iters = get_next_sub_slot_iters_and_difficulty(
+        constants, len(block.finished_sub_slots) > 0, prev_b, blocks
+    )[0]
+    overflow = is_overflow_block(constants, signage_point_index)
+
+    if (
+        len(block.finished_sub_slots) > 0
+        and block.finished_sub_slots[0].challenge_chain.subepoch_summary_hash is not None
+    ):
+        return None
+
+    if can_finish_soon:
+        deficit: uint8 = uint8(0)  # Assume that our deficit will go to zero soon
+        can_finish_se = True
+        if height_can_be_first_in_epoch(constants, uint32(prev_b.height + 2)):
+            can_finish_epoch = True
+            if (prev_b.height + 2) % constants.SUB_EPOCH_BLOCKS > 1:
+                curr: BlockRecord = prev_b
+                while curr.height % constants.SUB_EPOCH_BLOCKS > 0:
+                    if (
+                        curr.sub_epoch_summary_included is not None
+                        and curr.sub_epoch_summary_included.new_difficulty is not None
+                    ):
+                        can_finish_epoch = False
+                    curr = blocks.block_record(curr.prev_hash)
+
+                if (
+                    curr.sub_epoch_summary_included is not None
+                    and curr.sub_epoch_summary_included.new_difficulty is not None
+                ):
+                    can_finish_epoch = False
+        elif height_can_be_first_in_epoch(constants, uint32(prev_b.height + constants.MAX_SUB_SLOT_BLOCKS + 2)):
+            can_finish_epoch = True
+        else:
+            can_finish_epoch = False
+    else:
+        deficit = calculate_deficit(
+            constants,
+            uint32(prev_b.height + 1),
+            prev_b,
+            overflow,
+            len(block.finished_sub_slots),
+        )
+        can_finish_se, can_finish_epoch = can_finish_sub_and_full_epoch(
+            constants,
+            blocks,
+            uint32(prev_b.height + 1),
+            prev_b.header_hash if prev_b is not None else None,
+            deficit,
+            False,
+        )
+
+    # can't finish se, no summary
+    if not can_finish_se:
+        return None
+
+    next_difficulty = None
+    next_sub_slot_iters = None
+
+    # if can finish epoch, new difficulty and ssi
+    if can_finish_epoch:
+        sp_iters = calculate_sp_iters(constants, sub_slot_iters, signage_point_index)
+        ip_iters = calculate_ip_iters(constants, sub_slot_iters, signage_point_index, required_iters)
+
+        next_difficulty = _get_next_difficulty(
+            constants,
+            blocks,
+            block.prev_header_hash,
+            uint32(prev_b.height + 1),
+            uint64(prev_b.weight - blocks.block_record(prev_b.prev_hash).weight),
+            deficit,
+            False,  # Already checked above
+            True,
+            uint128(block.total_iters - ip_iters + sp_iters - (sub_slot_iters if overflow else 0)),
+            True,
+        )
+        next_sub_slot_iters = _get_next_sub_slot_iters(
+            constants,
+            blocks,
+            block.prev_header_hash,
+            uint32(prev_b.height + 1),
+            sub_slot_iters,
+            deficit,
+            False,  # Already checked above
+            True,
+            uint128(block.total_iters - ip_iters + sp_iters - (sub_slot_iters if overflow else 0)),
+            True,
+        )
+
+    return make_sub_epoch_summary(
+        constants,
+        blocks,
+        uint32(prev_b.height + 2),
+        prev_b,
+        next_difficulty,
+        next_sub_slot_iters,
+    )

chia/consensus/multiprocess_validation.py

@@ -0,0 +1,268 @@
+from __future__ import annotations
+
+import asyncio
+import copy
+import logging
+import time
+import traceback
+from collections.abc import Awaitable, Collection
+from concurrent.futures import Executor
+from dataclasses import dataclass
+from typing import Optional
+
+from chia_rs import SpendBundleConditions, get_flags_for_height_and_constants, run_block_generator, run_block_generator2
+
+from chia.consensus.block_header_validation import validate_finished_header_block
+from chia.consensus.block_record import BlockRecord
+from chia.consensus.blockchain_interface import BlockRecordsProtocol
+from chia.consensus.constants import ConsensusConstants
+from chia.consensus.full_block_to_block_record import block_to_block_record
+from chia.consensus.get_block_challenge import get_block_challenge
+from chia.consensus.get_block_generator import get_block_generator
+from chia.consensus.pot_iterations import calculate_iterations_quality, is_overflow_block
+from chia.types.blockchain_format.coin import Coin
+from chia.types.blockchain_format.proof_of_space import verify_and_get_quality_string
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.blockchain_format.sub_epoch_summary import SubEpochSummary
+from chia.types.full_block import FullBlock
+from chia.types.generator_types import BlockGenerator
+from chia.types.validation_state import ValidationState
+from chia.util.augmented_chain import AugmentedBlockchain
+from chia.util.errors import Err
+from chia.util.generator_tools import get_block_header, tx_removals_and_additions
+from chia.util.ints import uint16, uint32, uint64
+from chia.util.streamable import Streamable, streamable
+
+log = logging.getLogger(__name__)
+
+
+@streamable
+@dataclass(frozen=True)
+class PreValidationResult(Streamable):
+    error: Optional[uint16]
+    required_iters: Optional[uint64]  # Iff error is None
+    conds: Optional[SpendBundleConditions]  # Iff error is None and block is a transaction block
+    timing: uint32  # the time (in milliseconds) it took to pre-validate the block
+
+    @property
+    def validated_signature(self) -> bool:
+        if self.conds is None:
+            return False
+        return self.conds.validated_signature
+
+
+# this layer of abstraction is here to let wallet tests monkeypatch it
+def _run_block(
+    block: FullBlock, prev_generators: list[bytes], constants: ConsensusConstants
+) -> tuple[Optional[int], Optional[SpendBundleConditions]]:
+    assert block.transactions_generator is not None
+    assert block.transactions_info is not None
+    flags = get_flags_for_height_and_constants(block.height, constants)
+    if block.height >= constants.HARD_FORK_HEIGHT:
+        run_block = run_block_generator2
+    else:
+        run_block = run_block_generator
+    return run_block(
+        bytes(block.transactions_generator),
+        prev_generators,
+        block.transactions_info.cost,
+        flags,
+        block.transactions_info.aggregated_signature,
+        None,
+        constants,
+    )
+
+
+def _pre_validate_block(
+    constants: ConsensusConstants,
+    blockchain: BlockRecordsProtocol,
+    block: FullBlock,
+    prev_generators: Optional[list[bytes]],
+    conds: Optional[SpendBundleConditions],
+    expected_vs: ValidationState,
+) -> PreValidationResult:
+    """
+    Args:
+        constants:
+        blockchain:
+        block:
+        prev_generators:
+        conds:
+        expected_vs: The validation state that we calculate for the next block
+            if it's validated.
+    """
+
+    try:
+        validation_start = time.monotonic()
+        removals_and_additions: Optional[tuple[Collection[bytes32], Collection[Coin]]] = None
+        if conds is not None:
+            assert conds.validated_signature is True
+            assert block.transactions_generator is not None
+            removals_and_additions = tx_removals_and_additions(conds)
+        elif block.transactions_generator is not None:
+            assert prev_generators is not None
+            assert block.transactions_info is not None
+
+            if block.transactions_info.cost > constants.MAX_BLOCK_COST_CLVM:
+                validation_time = time.monotonic() - validation_start
+                return PreValidationResult(
+                    uint16(Err.BLOCK_COST_EXCEEDS_MAX.value), None, None, uint32(validation_time * 1000)
+                )
+
+            err, conds = _run_block(block, prev_generators, constants)
+
+            assert (err is None) != (conds is None)
+            if err is not None:
+                validation_time = time.monotonic() - validation_start
+                return PreValidationResult(uint16(err), None, None, uint32(validation_time * 1000))
+            assert conds is not None
+            assert conds.validated_signature is True
+            removals_and_additions = tx_removals_and_additions(conds)
+        elif block.is_transaction_block():
+            # This is a transaction block with just reward coins.
+            removals_and_additions = ([], [])
+
+        assert conds is None or conds.validated_signature is True
+        header_block = get_block_header(block, removals_and_additions)
+        required_iters, error = validate_finished_header_block(
+            constants,
+            blockchain,
+            header_block,
+            True,  # check_filter
+            expected_vs,
+        )
+        error_int: Optional[uint16] = None
+        if error is not None:
+            error_int = uint16(error.code.value)
+
+        validation_time = time.monotonic() - validation_start
+        return PreValidationResult(
+            error_int,
+            required_iters,
+            conds,
+            uint32(validation_time * 1000),
+        )
+    except Exception:
+        error_stack = traceback.format_exc()
+        log.error(f"Exception: {error_stack}")
+        validation_time = time.monotonic() - validation_start
+        return PreValidationResult(uint16(Err.UNKNOWN.value), None, None, uint32(validation_time * 1000))
+
+
+async def pre_validate_block(
+    constants: ConsensusConstants,
+    blockchain: AugmentedBlockchain,
+    block: FullBlock,
+    pool: Executor,
+    conds: Optional[SpendBundleConditions],
+    vs: ValidationState,
+    *,
+    wp_summaries: Optional[list[SubEpochSummary]] = None,
+) -> Awaitable[PreValidationResult]:
+    """
+    This method must be called under the blockchain lock
+    The block passed to this function is submitted to be validated in the
+    executor passed in as "pool". The future for the job is then returned.
+    When awaited, the return value is the PreValidationResult for the block.
+    The PreValidationResult indicates whether the block was valid or not.
+
+    Args:
+        constants:
+        blockchain: The blockchain object to validate these blocks with respect to.
+            It's an AugmentedBlockchain to allow for previous batches of blocks to
+            be included, even if they haven't been added to the underlying blockchain
+            database yet. The blocks passed in will be added/augmented onto this blockchain.
+        pool: The executor to submit the validation jobs to
+        block: The full block to validate (must be connected to current chain)
+        conds: The SpendBundleConditions for transaction blocks, if we have one.
+            This will be computed if None is passed.
+        vs: The ValidationState refers to the state for the block.
+            This is an in-out parameter that will be updated to the validation state
+            for the next block. It includes subslot iterators, difficulty and
+            the previous sub epoch summary (ses) block.
+        wp_summaries:
+        validate_signatures:
+    """
+    prev_b: Optional[BlockRecord] = None
+
+    async def return_error(error_code: Err) -> PreValidationResult:
+        return PreValidationResult(uint16(error_code.value), None, None, uint32(0))
+
+    if block.height > 0:
+        curr = blockchain.try_block_record(block.prev_header_hash)
+        if curr is None:
+            return return_error(Err.INVALID_PREV_BLOCK_HASH)
+        prev_b = curr
+
+    assert isinstance(block, FullBlock)
+    if len(block.finished_sub_slots) > 0:
+        if block.finished_sub_slots[0].challenge_chain.new_difficulty is not None:
+            vs.difficulty = block.finished_sub_slots[0].challenge_chain.new_difficulty
+        if block.finished_sub_slots[0].challenge_chain.new_sub_slot_iters is not None:
+            vs.ssi = block.finished_sub_slots[0].challenge_chain.new_sub_slot_iters
+    overflow = is_overflow_block(constants, block.reward_chain_block.signage_point_index)
+    challenge = get_block_challenge(constants, block, blockchain, prev_b is None, overflow, False)
+    if block.reward_chain_block.challenge_chain_sp_vdf is None:
+        cc_sp_hash: bytes32 = challenge
+    else:
+        cc_sp_hash = block.reward_chain_block.challenge_chain_sp_vdf.output.get_hash()
+    q_str: Optional[bytes32] = verify_and_get_quality_string(
+        block.reward_chain_block.proof_of_space, constants, challenge, cc_sp_hash, height=block.height
+    )
+    if q_str is None:
+        return return_error(Err.INVALID_POSPACE)
+
+    required_iters: uint64 = calculate_iterations_quality(
+        constants.DIFFICULTY_CONSTANT_FACTOR,
+        q_str,
+        block.reward_chain_block.proof_of_space.size,
+        vs.difficulty,
+        cc_sp_hash,
+    )
+
+    try:
+        block_rec = block_to_block_record(
+            constants,
+            blockchain,
+            required_iters,
+            block,
+            sub_slot_iters=vs.ssi,
+            prev_ses_block=vs.prev_ses_block,
+        )
+    except ValueError:
+        log.exception("block_to_block_record()")
+        return return_error(Err.INVALID_SUB_EPOCH_SUMMARY)
+
+    if block_rec.sub_epoch_summary_included is not None and wp_summaries is not None:
+        next_ses = wp_summaries[int(block.height / constants.SUB_EPOCH_BLOCKS) - 1]
+        if not block_rec.sub_epoch_summary_included.get_hash() == next_ses.get_hash():
+            log.error("sub_epoch_summary does not match wp sub_epoch_summary list")
+            return return_error(Err.INVALID_SUB_EPOCH_SUMMARY)
+
+    blockchain.add_extra_block(block, block_rec)  # Temporarily add block to chain
+    prev_b = block_rec
+
+    previous_generators: Optional[list[bytes]] = None
+
+    try:
+        block_generator: Optional[BlockGenerator] = await get_block_generator(blockchain.lookup_block_generators, block)
+        if block_generator is not None:
+            previous_generators = block_generator.generator_refs
+    except ValueError:
+        return return_error(Err.FAILED_GETTING_GENERATOR_MULTIPROCESSING)
+
+    future = asyncio.get_running_loop().run_in_executor(
+        pool,
+        _pre_validate_block,
+        constants,
+        blockchain,
+        block,
+        previous_generators,
+        conds,
+        copy.copy(vs),
+    )
+
+    if block_rec.sub_epoch_summary_included is not None:
+        vs.prev_ses_block = block_rec
+
+    return future

chia/consensus/pos_quality.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from chia.util.ints import uint64
+
+# The actual space in bytes of a plot, is _expected_plot_size(k) * UI_ACTUAL_SPACE_CONSTANT_FACTO
+# This is not used in consensus, only for display purposes
+UI_ACTUAL_SPACE_CONSTANT_FACTOR = 0.78
+
+
+def _expected_plot_size(k: int) -> uint64:
+    """
+    Given the plot size parameter k (which is between 32 and 59), computes the
+    expected size of the plot in bytes (times a constant factor). This is based on efficient encoding
+    of the plot, and aims to be scale agnostic, so larger plots don't
+    necessarily get more rewards per byte. The +1 is added to give half a bit more space per entry, which
+    is necessary to store the entries in the plot.
+    """
+
+    return uint64(((2 * k) + 1) * (2 ** (k - 1)))