From 9b7a1ab32bd2b362feb11e244fd20d27addf8230 Mon Sep 17 00:00:00 2001 From: Matthew Howard Date: Tue, 28 Jan 2025 12:22:12 +0000 Subject: [PATCH 1/4] initial commit --- chia/_tests/blockchain/test_blockchain.py | 19 ++++-- .../core/consensus/test_pot_iterations.py | 63 +++++++++++++------ .../full_node/stores/test_full_node_store.py | 6 +- chia/_tests/core/full_node/test_full_node.py | 6 +- .../_tests/core/full_node/test_performance.py | 8 ++- chia/_tests/core/test_full_node_rpc.py | 9 ++- chia/consensus/block_header_validation.py | 32 ++++++---- chia/consensus/full_block_to_block_record.py | 7 ++- chia/consensus/make_sub_epoch_summary.py | 19 ++++-- chia/consensus/multiprocess_validation.py | 14 ++++- chia/consensus/pot_iterations.py | 41 +----------- chia/farmer/farmer_api.py | 8 +-- chia/full_node/full_node.py | 4 +- chia/full_node/full_node_api.py | 11 +++- chia/full_node/full_node_store.py | 5 +- chia/full_node/weight_proof.py | 27 +++++--- chia/harvester/harvester_api.py | 8 ++- chia/simulator/block_tools.py | 60 +++++++++++------- chia/timelord/iters_from_block.py | 12 +++- chia/timelord/timelord.py | 10 ++- 20 files changed, 224 insertions(+), 145 deletions(-) diff --git a/chia/_tests/blockchain/test_blockchain.py b/chia/_tests/blockchain/test_blockchain.py index 0ce70a5647cf..2eb863118d85 100644 --- a/chia/_tests/blockchain/test_blockchain.py +++ b/chia/_tests/blockchain/test_blockchain.py @@ -10,7 +10,7 @@ from typing import Optional import pytest -from chia_rs import AugSchemeMPL, G2Element, MerkleSet +from chia_rs import AugSchemeMPL, G2Element, MerkleSet, is_overflow_block from clvm.casts import int_to_bytes from chia._tests.blockchain.blockchain_test_utils import ( @@ -34,7 +34,6 @@ from chia.consensus.full_block_to_block_record import block_to_block_record from chia.consensus.get_block_generator import get_block_generator from chia.consensus.multiprocess_validation import PreValidationResult, pre_validate_block -from chia.consensus.pot_iterations import is_overflow_block from chia.simulator.block_tools import BlockTools, create_block_tools_async from chia.simulator.keyring import TempKeyring from chia.simulator.wallet_tools import WalletTool @@ -854,7 +853,11 @@ async def test_invalid_cc_sub_slot_vdf(self, empty_blockchain: Blockchain, bt: B block = blocks[-1] if ( len(block.finished_sub_slots) - and is_overflow_block(bt.constants, block.reward_chain_block.signage_point_index) + and is_overflow_block( + bt.constants.NUM_SPS_SUB_SLOT, + bt.constants.NUM_SP_INTERVALS_EXTRA, + block.reward_chain_block.signage_point_index, + ) and block.finished_sub_slots[-1].challenge_chain.challenge_chain_end_of_slot_vdf.output != ClassgroupElement.get_default_element() ): @@ -1101,7 +1104,9 @@ async def test_no_ses_if_no_se(self, empty_blockchain: Blockchain, bt: BlockTool while True: blocks = bt.get_consecutive_blocks(1, block_list_input=blocks) if len(blocks[-1].finished_sub_slots) > 0 and is_overflow_block( - bt.constants, blocks[-1].reward_chain_block.signage_point_index + bt.constants.NUM_SPS_SUB_SLOT, + bt.constants.NUM_SP_INTERVALS_EXTRA, + blocks[-1].reward_chain_block.signage_point_index, ): new_finished_ss: EndOfSubSlotBundle = recursive_replace( blocks[-1].finished_sub_slots[0], @@ -1206,7 +1211,11 @@ async def test_sp_0_no_sp(self, empty_blockchain: Blockchain, bt: BlockTools) -> block_bad = recursive_replace(blocks[-1], "reward_chain_block.signage_point_index", uint8(1)) await _validate_and_add_block(empty_blockchain, block_bad, expected_error=Err.INVALID_SP_INDEX) - elif not is_overflow_block(bt.constants, blocks[-1].reward_chain_block.signage_point_index): + elif not is_overflow_block( + bt.constants.NUM_SPS_SUB_SLOT, + bt.constants.NUM_SP_INTERVALS_EXTRA, + blocks[-1].reward_chain_block.signage_point_index, + ): case_2 = True block_bad = recursive_replace(blocks[-1], "reward_chain_block.signage_point_index", uint8(0)) await _validate_and_add_block_multi_error( diff --git a/chia/_tests/core/consensus/test_pot_iterations.py b/chia/_tests/core/consensus/test_pot_iterations.py index 2141617acf27..0f93ed8b621e 100644 --- a/chia/_tests/core/consensus/test_pot_iterations.py +++ b/chia/_tests/core/consensus/test_pot_iterations.py @@ -1,14 +1,16 @@ from __future__ import annotations +from chia_rs import ( + calculate_ip_iters, + calculate_sp_iters, + is_overflow_block, +) from pytest import raises from chia.consensus.default_constants import DEFAULT_CONSTANTS from chia.consensus.pos_quality import _expected_plot_size from chia.consensus.pot_iterations import ( - calculate_ip_iters, calculate_iterations_quality, - calculate_sp_iters, - is_overflow_block, ) from chia.util.hash import std_hash from chia.util.ints import uint8, uint16, uint32, uint64, uint128 @@ -18,19 +20,19 @@ class TestPotIterations: def test_is_overflow_block(self): - assert not is_overflow_block(test_constants, uint8(27)) - assert not is_overflow_block(test_constants, uint8(28)) - assert is_overflow_block(test_constants, uint8(29)) - assert is_overflow_block(test_constants, uint8(30)) - assert is_overflow_block(test_constants, uint8(31)) + assert not is_overflow_block(test_constants.NUM_SPS_SUB_SLOT, test_constants.NUM_SP_INTERVALS_EXTRA, uint8(27)) + assert not is_overflow_block(test_constants.NUM_SPS_SUB_SLOT, test_constants.NUM_SP_INTERVALS_EXTRA, uint8(28)) + assert is_overflow_block(test_constants.NUM_SPS_SUB_SLOT, test_constants.NUM_SP_INTERVALS_EXTRA, uint8(29)) + assert is_overflow_block(test_constants.NUM_SPS_SUB_SLOT, test_constants.NUM_SP_INTERVALS_EXTRA, uint8(30)) + assert is_overflow_block(test_constants.NUM_SPS_SUB_SLOT, test_constants.NUM_SP_INTERVALS_EXTRA, uint8(31)) with raises(ValueError): - assert is_overflow_block(test_constants, uint8(32)) + assert is_overflow_block(test_constants.NUM_SPS_SUB_SLOT, test_constants.NUM_SP_INTERVALS_EXTRA, uint8(32)) def test_calculate_sp_iters(self): ssi: uint64 = uint64(100001 * 64 * 4) with raises(ValueError): - calculate_sp_iters(test_constants, ssi, uint8(32)) - calculate_sp_iters(test_constants, ssi, uint8(31)) + calculate_sp_iters(test_constants.NUM_SPS_SUB_SLOT, ssi, uint8(32)) + calculate_sp_iters(test_constants.NUM_SPS_SUB_SLOT, ssi, uint8(31)) def test_calculate_ip_iters(self): ssi: uint64 = uint64(100001 * 64 * 4) @@ -44,33 +46,58 @@ def test_calculate_ip_iters(self): with raises(ValueError): # required_iters too high - calculate_ip_iters(test_constants, ssi, sp_interval_iters, sp_interval_iters) + calculate_ip_iters( + test_constants.NUM_SPS_SUB_SLOT, + test_constants.NUM_SP_INTERVALS_EXTRA, + ssi, + sp_interval_iters, + sp_interval_iters, + ) with raises(ValueError): # required_iters too high - calculate_ip_iters(test_constants, ssi, sp_interval_iters, sp_interval_iters * 12) + calculate_ip_iters( + test_constants.NUM_SPS_SUB_SLOT, + test_constants.NUM_SP_INTERVALS_EXTRA, + ssi, + sp_interval_iters, + sp_interval_iters * 12, + ) with raises(ValueError): # required_iters too low (0) - calculate_ip_iters(test_constants, ssi, sp_interval_iters, uint64(0)) + calculate_ip_iters( + test_constants.NUM_SPS_SUB_SLOT, + test_constants.NUM_SP_INTERVALS_EXTRA, + ssi, + sp_interval_iters, + uint64(0), + ) required_iters = sp_interval_iters - 1 - ip_iters = calculate_ip_iters(test_constants, ssi, uint8(13), required_iters) + ip_iters = calculate_ip_iters( + test_constants.NUM_SPS_SUB_SLOT, test_constants.NUM_SP_INTERVALS_EXTRA, ssi, uint8(13), required_iters + ) assert ip_iters == sp_iters + test_constants.NUM_SP_INTERVALS_EXTRA * sp_interval_iters + required_iters required_iters = uint64(1) - ip_iters = calculate_ip_iters(test_constants, ssi, uint8(13), required_iters) + ip_iters = calculate_ip_iters( + test_constants.NUM_SPS_SUB_SLOT, test_constants.NUM_SP_INTERVALS_EXTRA, ssi, uint8(13), required_iters + ) assert ip_iters == sp_iters + test_constants.NUM_SP_INTERVALS_EXTRA * sp_interval_iters + required_iters required_iters = uint64(int(ssi * 4 / 300)) - ip_iters = calculate_ip_iters(test_constants, ssi, uint8(13), required_iters) + ip_iters = calculate_ip_iters( + test_constants.NUM_SPS_SUB_SLOT, test_constants.NUM_SP_INTERVALS_EXTRA, ssi, uint8(13), required_iters + ) assert ip_iters == sp_iters + test_constants.NUM_SP_INTERVALS_EXTRA * sp_interval_iters + required_iters assert sp_iters < ip_iters # Overflow sp_iters = sp_interval_iters * (test_constants.NUM_SPS_SUB_SLOT - 1) ip_iters = calculate_ip_iters( - test_constants, + test_constants.NUM_SPS_SUB_SLOT, + test_constants.NUM_SP_INTERVALS_EXTRA, ssi, uint8(test_constants.NUM_SPS_SUB_SLOT - 1), required_iters, diff --git a/chia/_tests/core/full_node/stores/test_full_node_store.py b/chia/_tests/core/full_node/stores/test_full_node_store.py index 802939c31a43..53887b81e078 100644 --- a/chia/_tests/core/full_node/stores/test_full_node_store.py +++ b/chia/_tests/core/full_node/stores/test_full_node_store.py @@ -6,6 +6,7 @@ from typing import Optional import pytest +from chia_rs import is_overflow_block from chia._tests.blockchain.blockchain_test_utils import _validate_and_add_block, _validate_and_add_block_no_error from chia._tests.util.blockchain import create_blockchain @@ -17,7 +18,6 @@ from chia.consensus.difficulty_adjustment import get_next_sub_slot_iters_and_difficulty from chia.consensus.find_fork_point import find_fork_point_in_chain from chia.consensus.multiprocess_validation import PreValidationResult -from chia.consensus.pot_iterations import is_overflow_block from chia.full_node.full_node_store import FullNodeStore, UnfinishedBlockEntry, find_best_block from chia.full_node.signage_point import SignagePoint from chia.protocols import timelord_protocol @@ -817,7 +817,9 @@ async def test_basic_store( sb.signage_point_index + custom_block_tools.constants.NUM_SP_INTERVALS_EXTRA, custom_block_tools.constants.NUM_SPS_SUB_SLOT, ): - if is_overflow_block(custom_block_tools.constants, uint8(i)): + if is_overflow_block( + custom_block_tools.constants.NUM_SPS_SUB_SLOT, custom_block_tools.constants.NUM_SP_INTERVALS_EXTRA, uint8(i) + ): finished_sub_slots = blocks_5[-1].finished_sub_slots else: finished_sub_slots = [] diff --git a/chia/_tests/core/full_node/test_full_node.py b/chia/_tests/core/full_node/test_full_node.py index 0a3deb278111..d293033addd1 100644 --- a/chia/_tests/core/full_node/test_full_node.py +++ b/chia/_tests/core/full_node/test_full_node.py @@ -17,6 +17,7 @@ SpendBundleConditions, additions_and_removals, get_flags_for_height_and_constants, + is_overflow_block, ) from clvm.casts import int_to_bytes from packaging.version import Version @@ -32,7 +33,6 @@ from chia._tests.util.time_out_assert import time_out_assert, time_out_assert_custom_interval, time_out_messages from chia.consensus.block_body_validation import ForkInfo from chia.consensus.multiprocess_validation import PreValidationResult, pre_validate_block -from chia.consensus.pot_iterations import is_overflow_block from chia.full_node.coin_store import CoinStore from chia.full_node.full_node import WalletUpdate from chia.full_node.full_node_api import FullNodeAPI @@ -1402,7 +1402,9 @@ async def test_unfinished_block_with_replaced_generator(wallet_nodes, self_hostn blocks = bt.get_consecutive_blocks(1, block_list_input=blocks) block: FullBlock = blocks[0] - overflow = is_overflow_block(bt.constants, block.reward_chain_block.signage_point_index) + overflow = is_overflow_block( + bt.constants.NUM_SPS_SUB_SLOT, bt.constants.NUM_SP_INTERVALS_EXTRA, block.reward_chain_block.signage_point_index + ) replaced_generator = SerializedProgram.from_bytes(b"\x80") diff --git a/chia/_tests/core/full_node/test_performance.py b/chia/_tests/core/full_node/test_performance.py index 8dc2f924b45f..eb7871513bd5 100644 --- a/chia/_tests/core/full_node/test_performance.py +++ b/chia/_tests/core/full_node/test_performance.py @@ -4,6 +4,7 @@ import random import pytest +from chia_rs import is_overflow_block from clvm.casts import int_to_bytes from chia._tests.connection_utils import add_dummy_connection @@ -12,7 +13,6 @@ from chia._tests.util.misc import BenchmarkRunner from chia._tests.util.time_out_assert import time_out_assert from chia.consensus.block_record import BlockRecord -from chia.consensus.pot_iterations import is_overflow_block from chia.full_node.full_node_api import FullNodeAPI from chia.protocols import full_node_protocol as fnp from chia.types.condition_opcodes import ConditionOpcode @@ -150,7 +150,11 @@ async def test_full_block_performance( guarantee_transaction_block=True, ) block = blocks[-1] - if is_overflow_block(bt.constants, block.reward_chain_block.signage_point_index): + if is_overflow_block( + bt.constants.NUM_SPS_SUB_SLOT, + bt.constants.NUM_SP_INTERVALS_EXTRA, + block.reward_chain_block.signage_point_index, + ): sub_slots = block.finished_sub_slots[:-1] else: sub_slots = block.finished_sub_slots diff --git a/chia/_tests/core/test_full_node_rpc.py b/chia/_tests/core/test_full_node_rpc.py index 5233ecb1eaf1..8137243c2e00 100644 --- a/chia/_tests/core/test_full_node_rpc.py +++ b/chia/_tests/core/test_full_node_rpc.py @@ -1,7 +1,7 @@ from __future__ import annotations import pytest -from chia_rs import AugSchemeMPL +from chia_rs import AugSchemeMPL, is_overflow_block from clvm.casts import int_to_bytes from chia import __version__ @@ -10,7 +10,6 @@ from chia._tests.util.rpc import validate_get_routes from chia._tests.util.time_out_assert import time_out_assert from chia.consensus.block_record import BlockRecord -from chia.consensus.pot_iterations import is_overflow_block from chia.full_node.signage_point import SignagePoint from chia.protocols import full_node_protocol from chia.rpc.full_node_rpc_api import get_average_block_time, get_nearest_transaction_block @@ -61,7 +60,11 @@ async def test1(two_nodes_sim_and_wallets_services, self_hostname, consensus_mod assert len(await client.get_unfinished_block_headers()) == 0 assert len(await client.get_block_records(0, 100)) == 0 for block in blocks: - if is_overflow_block(bt.constants, block.reward_chain_block.signage_point_index): + if is_overflow_block( + bt.constants.NUM_SPS_SUB_SLOT, + bt.constants.NUM_SP_INTERVAL_EXTRA, + block.reward_chain_block.signage_point_index, + ): finished_ss = block.finished_sub_slots[:-1] else: finished_ss = block.finished_sub_slots diff --git a/chia/consensus/block_header_validation.py b/chia/consensus/block_header_validation.py index ee428d59ece8..5dcb4b12ca33 100644 --- a/chia/consensus/block_header_validation.py +++ b/chia/consensus/block_header_validation.py @@ -4,7 +4,13 @@ import time from typing import Optional -from chia_rs import AugSchemeMPL +from chia_rs import ( + AugSchemeMPL, + calculate_ip_iters, + calculate_sp_interval_iters, + calculate_sp_iters, + is_overflow_block, +) from chia.consensus.block_record import BlockRecord from chia.consensus.blockchain_interface import BlockRecordsProtocol @@ -13,13 +19,7 @@ from chia.consensus.difficulty_adjustment import can_finish_sub_and_full_epoch from chia.consensus.get_block_challenge import final_eos_is_already_included, get_block_challenge from chia.consensus.make_sub_epoch_summary import make_sub_epoch_summary -from chia.consensus.pot_iterations import ( - calculate_ip_iters, - calculate_iterations_quality, - calculate_sp_interval_iters, - calculate_sp_iters, - is_overflow_block, -) +from chia.consensus.pot_iterations import calculate_iterations_quality from chia.consensus.vdf_info_computation import get_signage_point_vdf_info from chia.types.blockchain_format.classgroup import ClassgroupElement from chia.types.blockchain_format.proof_of_space import verify_and_get_quality_string @@ -66,7 +66,11 @@ def validate_unfinished_header_block( if genesis_block and header_block.prev_header_hash != constants.GENESIS_CHALLENGE: return None, ValidationError(Err.INVALID_PREV_BLOCK_HASH) - overflow = is_overflow_block(constants, header_block.reward_chain_block.signage_point_index) + overflow = is_overflow_block( + constants.NUM_SPS_SUB_SLOT, + constants.NUM_SP_INTERVALS_EXTRA, + header_block.reward_chain_block.signage_point_index, + ) if skip_overflow_last_ss_validation and overflow: if final_eos_is_already_included(header_block, blocks, expected_vs.ssi): skip_overflow_last_ss_validation = False @@ -508,7 +512,7 @@ def validate_unfinished_header_block( ) # 7. check required iters - if required_iters >= calculate_sp_interval_iters(constants, expected_vs.ssi): + if required_iters >= calculate_sp_interval_iters(constants.NUM_SPS_SUB_SLOT, expected_vs.ssi): return None, ValidationError(Err.INVALID_REQUIRED_ITERS) # 8a. check signage point index 0 has no cc sp @@ -524,13 +528,14 @@ def validate_unfinished_header_block( return None, ValidationError(Err.INVALID_SP_INDEX) sp_iters: uint64 = calculate_sp_iters( - constants, + constants.NUM_SPS_SUB_SLOT, expected_vs.ssi, header_block.reward_chain_block.signage_point_index, ) ip_iters: uint64 = calculate_ip_iters( - constants, + constants.NUM_SPS_SUB_SLOT, + constants.NUM_SP_INTERVALS_EXTRA, expected_vs.ssi, header_block.reward_chain_block.signage_point_index, required_iters, @@ -874,7 +879,8 @@ def validate_finished_header_block( new_sub_slot: bool = len(header_block.finished_sub_slots) > 0 ip_iters: uint64 = calculate_ip_iters( - constants, + constants.NUM_SPS_SUB_SLOT, + constants.NUM_SP_INTERVALS_EXTRA, expected_vs.ssi, header_block.reward_chain_block.signage_point_index, required_iters, diff --git a/chia/consensus/full_block_to_block_record.py b/chia/consensus/full_block_to_block_record.py index b9ff5e0e5920..3f82cd138b2e 100644 --- a/chia/consensus/full_block_to_block_record.py +++ b/chia/consensus/full_block_to_block_record.py @@ -2,13 +2,14 @@ from typing import Optional, Union +from chia_rs import is_overflow_block + 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_sub_slot_iters_and_difficulty from chia.consensus.make_sub_epoch_summary import make_sub_epoch_summary -from chia.consensus.pot_iterations import is_overflow_block from chia.types.blockchain_format.classgroup import ClassgroupElement from chia.types.blockchain_format.sized_bytes import bytes32 from chia.types.blockchain_format.slots import ChallengeBlockInfo @@ -34,7 +35,9 @@ def block_to_block_record( sub_slot_iters, _ = get_next_sub_slot_iters_and_difficulty( constants, len(block.finished_sub_slots) > 0, prev_b, blocks ) - overflow = is_overflow_block(constants, block.reward_chain_block.signage_point_index) + overflow = is_overflow_block( + constants.NUM_SPS_SUB_SLOT, constants.NUM_SP_INTERVALS_EXTRA, block.reward_chain_block.signage_point_index + ) deficit = calculate_deficit( constants, block.height, diff --git a/chia/consensus/make_sub_epoch_summary.py b/chia/consensus/make_sub_epoch_summary.py index c945f518acaf..737aa916af13 100644 --- a/chia/consensus/make_sub_epoch_summary.py +++ b/chia/consensus/make_sub_epoch_summary.py @@ -3,6 +3,12 @@ import logging from typing import Optional, Union +from chia_rs import ( + calculate_ip_iters, + calculate_sp_iters, + is_overflow_block, +) + from chia.consensus.block_record import BlockRecord from chia.consensus.blockchain_interface import BlockRecordsProtocol from chia.consensus.constants import ConsensusConstants @@ -14,7 +20,6 @@ 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 @@ -114,7 +119,7 @@ def next_sub_epoch_summary( 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) + overflow = is_overflow_block(constants.NUM_SPS_SUB_SLOT, constants.NUM_SP_INTERVALS_EXTRA, signage_point_index) if ( len(block.finished_sub_slots) > 0 @@ -172,8 +177,14 @@ def next_sub_epoch_summary( # 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) + sp_iters = calculate_sp_iters(constants.NUM_SPS_SUB_SLOT, sub_slot_iters, signage_point_index) + ip_iters = calculate_ip_iters( + constants.NUM_SPS_SUB_SLOT, + constants.NUM_SP_INTERVALS_EXTRA, + sub_slot_iters, + signage_point_index, + required_iters, + ) next_difficulty = _get_next_difficulty( constants, diff --git a/chia/consensus/multiprocess_validation.py b/chia/consensus/multiprocess_validation.py index 8c247c7280f2..974535344e1d 100644 --- a/chia/consensus/multiprocess_validation.py +++ b/chia/consensus/multiprocess_validation.py @@ -10,7 +10,13 @@ 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_rs import ( + SpendBundleConditions, + get_flags_for_height_and_constants, + is_overflow_block, + run_block_generator, + run_block_generator2, +) from chia.consensus.block_header_validation import validate_finished_header_block from chia.consensus.block_record import BlockRecord @@ -19,7 +25,7 @@ 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.consensus.pot_iterations import calculate_iterations_quality 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 @@ -200,7 +206,9 @@ async def return_error(error_code: Err) -> PreValidationResult: 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) + overflow = is_overflow_block( + constants.NUM_SPS_SUB_SLOT, constants.NUM_SP_INTERVALS_EXTRA, 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 diff --git a/chia/consensus/pot_iterations.py b/chia/consensus/pot_iterations.py index 0aee32f522cc..b399539859b8 100644 --- a/chia/consensus/pot_iterations.py +++ b/chia/consensus/pot_iterations.py @@ -1,48 +1,9 @@ from __future__ import annotations -from chia.consensus.constants import ConsensusConstants from chia.consensus.pos_quality import _expected_plot_size from chia.types.blockchain_format.sized_bytes import bytes32 from chia.util.hash import std_hash -from chia.util.ints import uint8, uint64, uint128 - - -def is_overflow_block(constants: ConsensusConstants, signage_point_index: uint8) -> bool: - if signage_point_index >= constants.NUM_SPS_SUB_SLOT: - raise ValueError("SP index too high") - return signage_point_index >= constants.NUM_SPS_SUB_SLOT - constants.NUM_SP_INTERVALS_EXTRA - - -def calculate_sp_interval_iters(constants: ConsensusConstants, sub_slot_iters: uint64) -> uint64: - assert sub_slot_iters % constants.NUM_SPS_SUB_SLOT == 0 - return uint64(sub_slot_iters // constants.NUM_SPS_SUB_SLOT) - - -def calculate_sp_iters(constants: ConsensusConstants, sub_slot_iters: uint64, signage_point_index: uint8) -> uint64: - if signage_point_index >= constants.NUM_SPS_SUB_SLOT: - raise ValueError("SP index too high") - return uint64(calculate_sp_interval_iters(constants, sub_slot_iters) * signage_point_index) - - -def calculate_ip_iters( - constants: ConsensusConstants, - sub_slot_iters: uint64, - signage_point_index: uint8, - required_iters: uint64, -) -> uint64: - # Note that the SSI is for the block passed in, which might be in the previous epoch - sp_iters = calculate_sp_iters(constants, sub_slot_iters, signage_point_index) - sp_interval_iters: uint64 = calculate_sp_interval_iters(constants, sub_slot_iters) - if sp_iters % sp_interval_iters != 0 or sp_iters >= sub_slot_iters: - raise ValueError(f"Invalid sp iters {sp_iters} for this ssi {sub_slot_iters}") - - if required_iters >= sp_interval_iters or required_iters == 0: - raise ValueError( - f"Required iters {required_iters} is not below the sp interval iters {sp_interval_iters} " - f"{sub_slot_iters} or not >0." - ) - - return uint64((sp_iters + constants.NUM_SP_INTERVALS_EXTRA * sp_interval_iters + required_iters) % sub_slot_iters) +from chia.util.ints import uint64, uint128 def calculate_iterations_quality( diff --git a/chia/farmer/farmer_api.py b/chia/farmer/farmer_api.py index 2dd7c590f489..90217bcb76a0 100644 --- a/chia/farmer/farmer_api.py +++ b/chia/farmer/farmer_api.py @@ -6,10 +6,10 @@ from typing import TYPE_CHECKING, Any, ClassVar, Optional, Union, cast import aiohttp -from chia_rs import AugSchemeMPL, G2Element, PrivateKey +from chia_rs import AugSchemeMPL, G2Element, PrivateKey, calculate_sp_interval_iters from chia import __version__ -from chia.consensus.pot_iterations import calculate_iterations_quality, calculate_sp_interval_iters +from chia.consensus.pot_iterations import calculate_iterations_quality from chia.farmer.farmer import Farmer, increment_pool_stats, strip_old_entries from chia.harvester.harvester_api import HarvesterAPI from chia.protocols import farmer_protocol, harvester_protocol @@ -119,7 +119,7 @@ async def new_proof_of_space( ) # If the iters are good enough to make a block, proceed with the block making flow - if required_iters < calculate_sp_interval_iters(self.farmer.constants, sp.sub_slot_iters): + if required_iters < calculate_sp_interval_iters(self.farmer.constants.NUM_SPS_SUB_SLOT, sp.sub_slot_iters): if new_proof_of_space.farmer_reward_address_override is not None: self.farmer.notify_farmer_reward_taken_by_harvester_as_fee(sp, new_proof_of_space) @@ -225,7 +225,7 @@ async def new_proof_of_space( new_proof_of_space.sp_hash, ) if required_iters >= calculate_sp_interval_iters( - self.farmer.constants, self.farmer.constants.POOL_SUB_SLOT_ITERS + self.farmer.constants.NUM_SPS_SUB_SLOT, self.farmer.constants.POOL_SUB_SLOT_ITERS ): self.farmer.log.info( f"Proof of space not good enough for pool {pool_url}: {pool_state_dict['current_difficulty']}" diff --git a/chia/full_node/full_node.py b/chia/full_node/full_node.py index c6fd6e2e7b38..e56165419777 100644 --- a/chia/full_node/full_node.py +++ b/chia/full_node/full_node.py @@ -18,6 +18,7 @@ from chia_rs import ( AugSchemeMPL, BLSCache, + calculate_sp_iters, get_flags_for_height_and_constants, run_block_generator, run_block_generator2, @@ -34,7 +35,6 @@ from chia.consensus.difficulty_adjustment import get_next_sub_slot_iters_and_difficulty from chia.consensus.make_sub_epoch_summary import next_sub_epoch_summary from chia.consensus.multiprocess_validation import PreValidationResult, pre_validate_block -from chia.consensus.pot_iterations import calculate_sp_iters from chia.full_node.block_store import BlockStore from chia.full_node.coin_store import CoinStore from chia.full_node.full_node_api import FullNodeAPI @@ -2587,7 +2587,7 @@ async def new_infusion_point_vdf( sp_total_iters = uint128( sub_slot_start_iters + calculate_sp_iters( - self.constants, + self.constants.NUM_SPS_SUB_SLOT, sub_slot_iters, unfinished_block.reward_chain_block.signage_point_index, ) diff --git a/chia/full_node/full_node_api.py b/chia/full_node/full_node_api.py index f6bcc802172d..52734a00cab0 100644 --- a/chia/full_node/full_node_api.py +++ b/chia/full_node/full_node_api.py @@ -16,6 +16,8 @@ G2Element, MerkleSet, additions_and_removals, + calculate_ip_iters, + calculate_sp_iters, get_flags_for_height_and_constants, ) from chiabip158 import PyBIP158 @@ -24,7 +26,7 @@ from chia.consensus.block_record import BlockRecord from chia.consensus.blockchain import BlockchainMutexPriority from chia.consensus.get_block_generator import get_block_generator -from chia.consensus.pot_iterations import calculate_ip_iters, calculate_iterations_quality, calculate_sp_iters +from chia.consensus.pot_iterations import calculate_iterations_quality from chia.full_node.bundle_tools import simple_solution_generator, simple_solution_generator_backrefs from chia.full_node.coin_store import CoinStore from chia.full_node.fee_estimate import FeeEstimate, FeeEstimateGroup, fee_rate_v2_to_v1 @@ -989,9 +991,12 @@ def get_pool_sig(_1: PoolTarget, _2: Optional[G1Element]) -> Optional[G2Element] difficulty, request.challenge_chain_sp, ) - sp_iters: uint64 = calculate_sp_iters(self.full_node.constants, sub_slot_iters, request.signage_point_index) + sp_iters: uint64 = calculate_sp_iters( + self.full_node.constants.NUM_SPS_SUB_SLOT, sub_slot_iters, request.signage_point_index + ) ip_iters: uint64 = calculate_ip_iters( - self.full_node.constants, + self.full_node.constants.NUM_SPS_SUB_SLOT, + self.full_node.constants.NUM_SP_INTERVALS_EXTRA, sub_slot_iters, request.signage_point_index, required_iters, diff --git a/chia/full_node/full_node_store.py b/chia/full_node/full_node_store.py index 709a2252f8ae..e9bf69398de5 100644 --- a/chia/full_node/full_node_store.py +++ b/chia/full_node/full_node_store.py @@ -6,13 +6,14 @@ import time from typing import Optional +from chia_rs import calculate_sp_interval_iters + from chia.consensus.block_record import BlockRecord from chia.consensus.blockchain_interface import BlockRecordsProtocol from chia.consensus.constants import ConsensusConstants from chia.consensus.difficulty_adjustment import can_finish_sub_and_full_epoch from chia.consensus.make_sub_epoch_summary import make_sub_epoch_summary from chia.consensus.multiprocess_validation import PreValidationResult -from chia.consensus.pot_iterations import calculate_sp_interval_iters from chia.full_node.signage_point import SignagePoint from chia.protocols import timelord_protocol from chia.server.outbound_message import Message @@ -911,7 +912,7 @@ def new_peak( # If there was a reorg and a difficulty adjustment, just clear all the slots self.clear_slots() else: - interval_iters = calculate_sp_interval_iters(self.constants, peak.sub_slot_iters) + interval_iters = calculate_sp_interval_iters(self.constants.NUM_SPS_SUB_SLOT, peak.sub_slot_iters) # If it's not a reorg, or there is a reorg on the same difficulty, we can keep signage points # that we had before, in the cache for index, (sub_slot, sps, total_iters) in enumerate(self.finished_sub_slots): diff --git a/chia/full_node/weight_proof.py b/chia/full_node/weight_proof.py index ef8edf1caf8e..76dbeca95fe9 100644 --- a/chia/full_node/weight_proof.py +++ b/chia/full_node/weight_proof.py @@ -10,18 +10,19 @@ from multiprocessing.context import BaseContext from typing import IO, Optional +from chia_rs import ( + calculate_ip_iters, + calculate_sp_iters, + is_overflow_block, +) + from chia.consensus.block_header_validation import validate_finished_header_block from chia.consensus.block_record import BlockRecord from chia.consensus.blockchain_interface import BlockchainInterface from chia.consensus.constants import ConsensusConstants from chia.consensus.deficit import calculate_deficit from chia.consensus.full_block_to_block_record import header_block_to_sub_block_record -from chia.consensus.pot_iterations import ( - calculate_ip_iters, - calculate_iterations_quality, - calculate_sp_iters, - is_overflow_block, -) +from chia.consensus.pot_iterations import calculate_iterations_quality from chia.consensus.vdf_info_computation import get_signage_point_vdf_info from chia.types.blockchain_format.classgroup import ClassgroupElement from chia.types.blockchain_format.proof_of_space import verify_and_get_quality_string @@ -1002,7 +1003,13 @@ def _validate_segment( if required_iters is None: return False, uint64(0), uint64(0), uint64(0), [] assert sub_slot_data.signage_point_index is not None - ip_iters += calculate_ip_iters(constants, curr_ssi, sub_slot_data.signage_point_index, required_iters) + ip_iters += calculate_ip_iters( + constants.NUM_SPS_SUB_SLOT, + constants.NUM_SP_INTERVALS_EXTRA, + curr_ssi, + sub_slot_data.signage_point_index, + required_iters, + ) vdf_list = _get_challenge_block_vdfs(constants, idx, segment.sub_slots, curr_ssi) to_validate.extend(vdf_list) elif sampled and after_challenge: @@ -1028,7 +1035,9 @@ def _get_challenge_block_vdfs( assert sub_slot_data.signage_point_index sp_input = ClassgroupElement.get_default_element() if not sub_slot_data.cc_signage_point.normalized_to_identity and sub_slot_idx >= 1: - is_overflow = is_overflow_block(constants, sub_slot_data.signage_point_index) + is_overflow = is_overflow_block( + constants.NUM_SPS_SUB_SLOT, constants.NUM_SP_INTERVALS_EXTRA, sub_slot_data.signage_point_index + ) prev_ssd = sub_slots[sub_slot_idx - 1] sp_input = sub_slot_data_vdf_input( constants, sub_slot_data, sub_slot_idx, sub_slots, is_overflow, prev_ssd.is_end_of_slot(), ssi @@ -1573,7 +1582,7 @@ def get_sp_total_iters( assert sub_slot_data.cc_ip_vdf_info is not None assert sub_slot_data.total_iters is not None assert sub_slot_data.signage_point_index is not None - sp_iters = calculate_sp_iters(constants, ssi, sub_slot_data.signage_point_index) + sp_iters = calculate_sp_iters(constants.NUM_SPS_SUB_SLOT, ssi, sub_slot_data.signage_point_index) ip_iters = sub_slot_data.cc_ip_vdf_info.number_of_iterations sp_sub_slot_total_iters = uint128(sub_slot_data.total_iters - ip_iters) if is_overflow: diff --git a/chia/harvester/harvester_api.py b/chia/harvester/harvester_api.py index 66d9b237b271..e570a620f943 100644 --- a/chia/harvester/harvester_api.py +++ b/chia/harvester/harvester_api.py @@ -6,9 +6,9 @@ from pathlib import Path from typing import TYPE_CHECKING, ClassVar, Optional, cast -from chia_rs import AugSchemeMPL, G1Element, G2Element +from chia_rs import AugSchemeMPL, G1Element, G2Element, calculate_sp_interval_iters -from chia.consensus.pot_iterations import calculate_iterations_quality, calculate_sp_interval_iters +from chia.consensus.pot_iterations import calculate_iterations_quality from chia.harvester.harvester import Harvester from chia.plotting.util import PlotInfo, parse_plot_info from chia.protocols import harvester_protocol @@ -151,7 +151,9 @@ def blocking_lookup(filename: Path, plot_info: PlotInfo) -> list[tuple[bytes32, difficulty, new_challenge.sp_hash, ) - sp_interval_iters = calculate_sp_interval_iters(self.harvester.constants, sub_slot_iters) + sp_interval_iters = calculate_sp_interval_iters( + self.harvester.constants.NUM_SPS_SUB_SLOT, sub_slot_iters + ) if required_iters < sp_interval_iters: # Found a very good proof of space! will fetch the whole proof from disk, # then send to farmer diff --git a/chia/simulator/block_tools.py b/chia/simulator/block_tools.py index a841c0970489..3d606a97ab05 100644 --- a/chia/simulator/block_tools.py +++ b/chia/simulator/block_tools.py @@ -18,7 +18,18 @@ import anyio from chia_puzzles_py.programs import CHIALISP_DESERIALISATION, ROM_BOOTSTRAP_GENERATOR -from chia_rs import MEMPOOL_MODE, AugSchemeMPL, G1Element, G2Element, PrivateKey, solution_generator +from chia_rs import ( + MEMPOOL_MODE, + AugSchemeMPL, + G1Element, + G2Element, + PrivateKey, + calculate_ip_iters, + calculate_sp_interval_iters, + calculate_sp_iters, + is_overflow_block, + solution_generator, +) from chia.consensus.block_creation import create_unfinished_block, unfinished_block_to_full_block from chia.consensus.block_record import BlockRecord @@ -30,13 +41,7 @@ from chia.consensus.deficit import calculate_deficit from chia.consensus.full_block_to_block_record import block_to_block_record from chia.consensus.make_sub_epoch_summary import next_sub_epoch_summary -from chia.consensus.pot_iterations import ( - calculate_ip_iters, - calculate_iterations_quality, - calculate_sp_interval_iters, - calculate_sp_iters, - is_overflow_block, -) +from chia.consensus.pot_iterations import calculate_iterations_quality from chia.consensus.vdf_info_computation import get_signage_point_vdf_info from chia.daemon.keychain_proxy import KeychainProxy, connect_to_keychain_and_validate, wrap_local_keychain from chia.full_node.bundle_tools import simple_solution_generator, simple_solution_generator_backrefs @@ -705,7 +710,7 @@ def get_consecutive_blocks( for signage_point_index in range(0, constants.NUM_SPS_SUB_SLOT - constants.NUM_SP_INTERVALS_EXTRA): curr = latest_block while curr.total_iters > sub_slot_start_total_iters + calculate_sp_iters( - constants, sub_slot_iters, uint8(signage_point_index) + constants.NUM_SPS_SUB_SLOT, sub_slot_iters, uint8(signage_point_index) ): if curr.height == 0: break @@ -1272,17 +1277,20 @@ def create_genesis_block( # Try each of the proofs of space for required_iters, proof_of_space in qualified_proofs: sp_iters: uint64 = calculate_sp_iters( - constants, + constants.NUM_SPS_SUB_SLOT, uint64(constants.SUB_SLOT_ITERS_STARTING), uint8(signage_point_index), ) ip_iters = calculate_ip_iters( - constants, + constants.NUM_SPS_SUB_SLOT, + constants.NUM_SP_INTERVALS_EXTRA, uint64(constants.SUB_SLOT_ITERS_STARTING), uint8(signage_point_index), required_iters, ) - is_overflow = is_overflow_block(constants, uint8(signage_point_index)) + is_overflow = is_overflow_block( + constants.NUM_SPS_SUB_SLOT, constants.NUM_SP_INTERVALS_EXTRA, uint8(signage_point_index) + ) if force_overflow and not is_overflow: continue if len(finished_sub_slots) < skip_slots: @@ -1386,7 +1394,7 @@ def create_genesis_block( total_iters_sp = uint128( sub_slot_total_iters + calculate_sp_iters( - self.constants, + self.constants.NUM_SPS_SUB_SLOT, self.constants.SUB_SLOT_ITERS_STARTING, unfinished_block.reward_chain_block.signage_point_index, ) @@ -1438,7 +1446,7 @@ def get_pospaces_for_challenge( difficulty, signage_point, ) - if required_iters < calculate_sp_interval_iters(constants, sub_slot_iters): + if required_iters < calculate_sp_interval_iters(constants.NUM_SPS_SUB_SLOT, 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 @@ -1484,10 +1492,10 @@ def get_signage_point( ) -> SignagePoint: if signage_point_index == 0: return SignagePoint(None, None, None, None) - sp_iters = calculate_sp_iters(constants, sub_slot_iters, signage_point_index) - overflow = is_overflow_block(constants, signage_point_index) + sp_iters = calculate_sp_iters(constants.NUM_SPS_SUB_SLOT, sub_slot_iters, signage_point_index) + overflow = is_overflow_block(constants.NUM_SPS_SUB_SLOT, constants.NUM_SP_INTERVALS_EXTRA, signage_point_index) sp_total_iters = uint128( - sub_slot_start_total_iters + calculate_sp_iters(constants, sub_slot_iters, signage_point_index) + sub_slot_start_total_iters + calculate_sp_iters(constants.NUM_SPS_SUB_SLOT, sub_slot_iters, signage_point_index) ) ( @@ -1548,7 +1556,7 @@ def finish_block( difficulty: uint64, normalized_to_identity_cc_ip: bool = False, ) -> tuple[FullBlock, BlockRecord]: - is_overflow = is_overflow_block(constants, signage_point_index) + is_overflow = is_overflow_block(constants.NUM_SPS_SUB_SLOT, constants.NUM_SP_INTERVALS_EXTRA, signage_point_index) cc_vdf_challenge = slot_cc_challenge if len(finished_sub_slots) == 0: new_ip_iters = uint64(unfinished_block.total_iters - latest_block.total_iters) @@ -1599,7 +1607,7 @@ def finish_block( ) assert unfinished_block is not None sp_total_iters = uint128( - sub_slot_start_total_iters + calculate_sp_iters(constants, sub_slot_iters, signage_point_index) + sub_slot_start_total_iters + calculate_sp_iters(constants.NUM_SPS_SUB_SLOT, sub_slot_iters, signage_point_index) ) full_block: FullBlock = unfinished_block_to_full_block( unfinished_block, @@ -1810,8 +1818,14 @@ def get_full_block_and_block_record( timestamp = max(int(time.time()), last_timestamp + time_per_block) else: timestamp = last_timestamp + time_per_block - 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) + sp_iters = calculate_sp_iters(constants.NUM_SPS_SUB_SLOT, sub_slot_iters, signage_point_index) + ip_iters = calculate_ip_iters( + constants.NUM_SPS_SUB_SLOT, + constants.NUM_SP_INTERVALS_EXTRA, + sub_slot_iters, + signage_point_index, + required_iters, + ) unfinished_block = create_unfinished_block( constants, @@ -2032,7 +2046,9 @@ def create_block_tools( def make_unfinished_block( block: FullBlock, constants: ConsensusConstants, *, force_overflow: bool = False ) -> UnfinishedBlock: - if force_overflow or is_overflow_block(constants, block.reward_chain_block.signage_point_index): + if force_overflow or is_overflow_block( + constants.NUM_SPS_SUB_SLOT, constants.NUM_SP_INTERVALS_EXTRA, block.reward_chain_block.signage_point_index + ): finished_ss = block.finished_sub_slots[:-1] else: finished_ss = block.finished_sub_slots diff --git a/chia/timelord/iters_from_block.py b/chia/timelord/iters_from_block.py index f57b88997161..f113498e0abf 100644 --- a/chia/timelord/iters_from_block.py +++ b/chia/timelord/iters_from_block.py @@ -2,8 +2,13 @@ from typing import Optional, Union +from chia_rs import ( + calculate_ip_iters, + calculate_sp_iters, +) + from chia.consensus.constants import ConsensusConstants -from chia.consensus.pot_iterations import calculate_ip_iters, calculate_iterations_quality, calculate_sp_iters +from chia.consensus.pot_iterations import calculate_iterations_quality from chia.types.blockchain_format.proof_of_space import verify_and_get_quality_string from chia.types.blockchain_format.reward_chain_block import RewardChainBlock, RewardChainBlockUnfinished from chia.types.blockchain_format.sized_bytes import bytes32 @@ -40,9 +45,10 @@ def iters_from_block( cc_sp, ) return ( - calculate_sp_iters(constants, sub_slot_iters, reward_chain_block.signage_point_index), + calculate_sp_iters(constants.NUM_SPS_SUB_SLOT, sub_slot_iters, reward_chain_block.signage_point_index), calculate_ip_iters( - constants, + constants.NUM_SPS_SUB_SLOT, + constants.NUM_SP_INTERVALS_EXTRA, sub_slot_iters, reward_chain_block.signage_point_index, required_iters, diff --git a/chia/timelord/timelord.py b/chia/timelord/timelord.py index 660a968211f6..8557ebd5e444 100644 --- a/chia/timelord/timelord.py +++ b/chia/timelord/timelord.py @@ -15,10 +15,10 @@ from pathlib import Path from typing import IO, TYPE_CHECKING, Any, ClassVar, Optional, cast +from chia_rs import calculate_sp_iters, is_overflow_block from chiavdf import create_discriminant, prove from chia.consensus.constants import ConsensusConstants -from chia.consensus.pot_iterations import calculate_sp_iters, is_overflow_block from chia.protocols import timelord_protocol from chia.protocols.protocol_message_types import ProtocolMessageTypes from chia.rpc.rpc_server import StateChangedProtocol, default_get_connections @@ -258,7 +258,11 @@ def _can_infuse_unfinished_block(self, block: timelord_protocol.NewUnfinishedBlo log.warning(f"Received invalid unfinished block: {e}.") return None block_sp_total_iters = self.last_state.total_iters - ip_iters + block_sp_iters - if is_overflow_block(self.constants, block.reward_chain_block.signage_point_index): + if is_overflow_block( + self.constants.NUM_SPS_SUB_SLOT, + self.constants.NUM_SP_INTERVALS_EXTRA, + block.reward_chain_block.signage_point_index, + ): block_sp_total_iters -= self.last_state.get_sub_slot_iters() found_index = -1 for index, (rc, total_iters) in enumerate(self.last_state.reward_challenge_cache): @@ -633,7 +637,7 @@ async def _check_for_new_ip(self, iter_to_look_for: uint64) -> None: ip_total_iters - ip_iters + calculate_sp_iters( - self.constants, + self.constants.NUM_SPS_SUB_SLOT, block.sub_slot_iters, block.reward_chain_block.signage_point_index, ) From f641e8edab8f6e2c1fd383b3cd660d840dd23fb0 Mon Sep 17 00:00:00 2001 From: Matthew Howard Date: Tue, 28 Jan 2025 12:29:05 +0000 Subject: [PATCH 2/4] migrate pos_quality --- chia/_tests/core/consensus/test_pot_iterations.py | 2 +- chia/_tests/plot_sync/test_receiver.py | 3 ++- chia/consensus/pos_quality.py | 14 -------------- chia/consensus/pot_iterations.py | 3 ++- chia/plot_sync/receiver.py | 3 ++- chia/plotting/manager.py | 3 ++- 6 files changed, 9 insertions(+), 19 deletions(-) diff --git a/chia/_tests/core/consensus/test_pot_iterations.py b/chia/_tests/core/consensus/test_pot_iterations.py index 0f93ed8b621e..12dfb7dd3d90 100644 --- a/chia/_tests/core/consensus/test_pot_iterations.py +++ b/chia/_tests/core/consensus/test_pot_iterations.py @@ -5,10 +5,10 @@ calculate_sp_iters, is_overflow_block, ) +from chia_rs import expected_plot_size as _expected_plot_size from pytest import raises from chia.consensus.default_constants import DEFAULT_CONSTANTS -from chia.consensus.pos_quality import _expected_plot_size from chia.consensus.pot_iterations import ( calculate_iterations_quality, ) diff --git a/chia/_tests/plot_sync/test_receiver.py b/chia/_tests/plot_sync/test_receiver.py index a291664de98c..0f175b52633d 100644 --- a/chia/_tests/plot_sync/test_receiver.py +++ b/chia/_tests/plot_sync/test_receiver.py @@ -8,9 +8,10 @@ import pytest from chia_rs import G1Element +from chia_rs import expected_plot_size as _expected_plot_size from chia._tests.plot_sync.util import get_dummy_connection -from chia.consensus.pos_quality import UI_ACTUAL_SPACE_CONSTANT_FACTOR, _expected_plot_size +from chia.consensus.pos_quality import UI_ACTUAL_SPACE_CONSTANT_FACTOR from chia.plot_sync.delta import Delta from chia.plot_sync.receiver import Receiver, Sync, get_list_or_len from chia.plot_sync.util import ErrorCodes, State diff --git a/chia/consensus/pos_quality.py b/chia/consensus/pos_quality.py index 4a5b12464925..37a70f76c032 100644 --- a/chia/consensus/pos_quality.py +++ b/chia/consensus/pos_quality.py @@ -1,19 +1,5 @@ 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))) diff --git a/chia/consensus/pot_iterations.py b/chia/consensus/pot_iterations.py index b399539859b8..ebcff9dadb26 100644 --- a/chia/consensus/pot_iterations.py +++ b/chia/consensus/pot_iterations.py @@ -1,6 +1,7 @@ from __future__ import annotations -from chia.consensus.pos_quality import _expected_plot_size +from chia_rs import expected_plot_size as _expected_plot_size + from chia.types.blockchain_format.sized_bytes import bytes32 from chia.util.hash import std_hash from chia.util.ints import uint64, uint128 diff --git a/chia/plot_sync/receiver.py b/chia/plot_sync/receiver.py index 0379a446426a..4043794fd502 100644 --- a/chia/plot_sync/receiver.py +++ b/chia/plot_sync/receiver.py @@ -6,9 +6,10 @@ from dataclasses import dataclass, field from typing import Any, Callable, Optional, Union +from chia_rs import expected_plot_size as _expected_plot_size from typing_extensions import Protocol -from chia.consensus.pos_quality import UI_ACTUAL_SPACE_CONSTANT_FACTOR, _expected_plot_size +from chia.consensus.pos_quality import UI_ACTUAL_SPACE_CONSTANT_FACTOR from chia.plot_sync.delta import Delta, PathListDelta, PlotListDelta from chia.plot_sync.exceptions import ( InvalidIdentifierError, diff --git a/chia/plotting/manager.py b/chia/plotting/manager.py index 460d7fc036fb..6f3f28a27d43 100644 --- a/chia/plotting/manager.py +++ b/chia/plotting/manager.py @@ -9,9 +9,10 @@ from typing import Any, Callable, Optional from chia_rs import G1Element +from chia_rs import expected_plot_size as _expected_plot_size from chiapos import DiskProver, decompressor_context_queue -from chia.consensus.pos_quality import UI_ACTUAL_SPACE_CONSTANT_FACTOR, _expected_plot_size +from chia.consensus.pos_quality import UI_ACTUAL_SPACE_CONSTANT_FACTOR from chia.plotting.cache import Cache, CacheEntry from chia.plotting.util import ( HarvestingMode, From 18359878a574d485f94330772308145d85cf9806 Mon Sep 17 00:00:00 2001 From: Matthew Howard Date: Tue, 28 Jan 2025 12:50:50 +0000 Subject: [PATCH 3/4] fix test_pot_iterations.py --- chia/_tests/core/consensus/test_pot_iterations.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/chia/_tests/core/consensus/test_pot_iterations.py b/chia/_tests/core/consensus/test_pot_iterations.py index 12dfb7dd3d90..e758114aa47f 100644 --- a/chia/_tests/core/consensus/test_pot_iterations.py +++ b/chia/_tests/core/consensus/test_pot_iterations.py @@ -40,7 +40,7 @@ def test_calculate_ip_iters(self): with raises(ValueError): # Invalid signage point index - calculate_ip_iters(test_constants, ssi, uint8(123), uint64(100000)) + calculate_ip_iters(test_constants.NUM_SPS_SUB_SLOT, test_constants.NUM_SP_INTERVALS_EXTRA, ssi, uint8(123), uint64(100000)) sp_iters = sp_interval_iters * 13 From 7b77d754420ec1c841d4b3e96d91d39993f450f2 Mon Sep 17 00:00:00 2001 From: Matthew Howard Date: Tue, 28 Jan 2025 13:23:02 +0000 Subject: [PATCH 4/4] fix another case of missing args and format --- chia/_tests/core/consensus/test_pot_iterations.py | 4 +++- chia/consensus/block_header_validation.py | 6 +++++- 2 files changed, 8 insertions(+), 2 deletions(-) diff --git a/chia/_tests/core/consensus/test_pot_iterations.py b/chia/_tests/core/consensus/test_pot_iterations.py index e758114aa47f..ae7bba3a8d24 100644 --- a/chia/_tests/core/consensus/test_pot_iterations.py +++ b/chia/_tests/core/consensus/test_pot_iterations.py @@ -40,7 +40,9 @@ def test_calculate_ip_iters(self): with raises(ValueError): # Invalid signage point index - calculate_ip_iters(test_constants.NUM_SPS_SUB_SLOT, test_constants.NUM_SP_INTERVALS_EXTRA, ssi, uint8(123), uint64(100000)) + calculate_ip_iters( + test_constants.NUM_SPS_SUB_SLOT, test_constants.NUM_SP_INTERVALS_EXTRA, ssi, uint8(123), uint64(100000) + ) sp_iters = sp_interval_iters * 13 diff --git a/chia/consensus/block_header_validation.py b/chia/consensus/block_header_validation.py index 5dcb4b12ca33..76bcd03be4aa 100644 --- a/chia/consensus/block_header_validation.py +++ b/chia/consensus/block_header_validation.py @@ -989,7 +989,11 @@ def validate_finished_header_block( # 31. Check infused challenge chain infusion point VDF if not genesis_block: - overflow = is_overflow_block(constants, header_block.reward_chain_block.signage_point_index) + overflow = is_overflow_block( + constants.NUM_SPS_SUB_SLOT, + constants.NUM_SP_INTERVALS_EXTRA, + header_block.reward_chain_block.signage_point_index, + ) deficit = calculate_deficit( constants, header_block.height,