chia-blockchain 2.5.4rc2__py3-none-any.whl → 2.5.5__py3-none-any.whl

chia/_tests/wallet/test_wallet_state_manager.py

@@ -2,17 +2,16 @@ from __future__ import annotations
 
 from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
+from dataclasses import dataclass
 
 import pytest
-from chia_rs import G2Element
+from chia_rs import CoinState, G2Element
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64
 
 from chia._tests.environments.wallet import WalletStateTransition, WalletTestFramework
 from chia._tests.util.setup_nodes import OldSimulatorsAndWallets
-from chia.protocols.wallet_protocol import CoinState
-from chia.rpc.wallet_request_types import PushTransactions
-from chia.server.outbound_message import NodeType
+from chia.protocols.outbound_message import NodeType
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
 from chia.types.coin_spend import make_spend
@@ -22,6 +21,8 @@ from chia.wallet.derive_keys import master_sk_to_wallet_sk, master_sk_to_wallet_
 from chia.wallet.transaction_record import TransactionRecord
 from chia.wallet.util.transaction_type import TransactionType
 from chia.wallet.util.wallet_types import WalletType
+from chia.wallet.wallet_request_types import PushTransactions
+from chia.wallet.wallet_rpc_api import MAX_DERIVATION_INDEX_DELTA
 from chia.wallet.wallet_spend_bundle import WalletSpendBundle
 from chia.wallet.wallet_state_manager import WalletStateManager
 
@@ -221,7 +222,7 @@ async def test_confirming_txs_not_ours(wallet_environments: WalletTestFramework)
     async with env_1.wallet_state_manager.new_action_scope(wallet_environments.tx_config, push=False) as action_scope:
         await env_1.xch_wallet.generate_signed_transaction(
             [uint64(1)],
-            [await env_1.xch_wallet.get_puzzle_hash(new=False)],
+            [await action_scope.get_puzzle_hash(env_1.wallet_state_manager)],
             action_scope,
         )
 
@@ -257,3 +258,188 @@ async def test_confirming_txs_not_ours(wallet_environments: WalletTestFramework)
             ),
         ]
     )
+
+
+@dataclass
+class PuzzleHashState:
+    highest_index: int
+    used_up_to_index: int
+
+
+@pytest.mark.parametrize(
+    "wallet_environments",
+    [{"num_environments": 1, "blocks_needed": [1], "trusted": True, "reuse_puzhash": True}],
+    indirect=True,
+)
+@pytest.mark.limit_consensus_modes(reason="irrelevant")
+@pytest.mark.anyio
+async def test_puzzle_hash_requests(wallet_environments: WalletTestFramework) -> None:
+    wsm = wallet_environments.environments[0].wallet_state_manager
+
+    async def get_puzzle_hash_state() -> PuzzleHashState:
+        last_index = await wsm.puzzle_store.get_last_derivation_path_for_wallet(wsm.main_wallet.id())
+        assert last_index is not None
+        return PuzzleHashState(
+            last_index,
+            int((await wsm.puzzle_store.get_used_count(wsm.main_wallet.id())) / 2) - 1,  # hardened + unhardened
+        )
+
+    expected_state = await get_puzzle_hash_state()
+
+    # `create_more_puzzle_hashes`
+    # No-op
+    result = await wsm.create_more_puzzle_hashes()
+    await result.commit(wsm)
+    assert await get_puzzle_hash_state() == expected_state
+
+    # Ensure the window continues to expand
+    await wsm.puzzle_store.set_used_up_to(uint32(expected_state.used_up_to_index + 1))
+    result = await wsm.create_more_puzzle_hashes()
+    await result.commit(wsm)
+    expected_state = PuzzleHashState(expected_state.highest_index + 1, expected_state.used_up_to_index + 1)
+    assert await get_puzzle_hash_state() == expected_state
+
+    # Explicitly make 1 extra
+    result = await wsm.create_more_puzzle_hashes(num_additional_phs=wsm.initial_num_public_keys + 1)
+    await result.commit(wsm)
+    expected_state = PuzzleHashState(expected_state.highest_index + 1, expected_state.used_up_to_index)
+    assert await get_puzzle_hash_state() == expected_state
+
+    # Make sure window doesn't expand on next use
+    await wsm.puzzle_store.set_used_up_to(uint32(expected_state.used_up_to_index + 1))
+    result = await wsm.create_more_puzzle_hashes()
+    await result.commit(wsm)
+    expected_state = PuzzleHashState(expected_state.highest_index, expected_state.used_up_to_index + 1)
+    assert await get_puzzle_hash_state() == expected_state
+
+    # Make sure `up_to_index` works
+    result = await wsm.create_more_puzzle_hashes(
+        up_to_index=uint32(expected_state.highest_index + 100), mark_existing_as_used=False
+    )
+    await result.commit(wsm)
+    expected_state = PuzzleHashState(
+        expected_state.highest_index + 100 + wsm.initial_num_public_keys, expected_state.used_up_to_index
+    )
+    assert await get_puzzle_hash_state() == expected_state
+
+    # Make sure `mark_existing_as_used` works
+    result = await wsm.create_more_puzzle_hashes(
+        up_to_index=uint32(expected_state.highest_index + 1), mark_existing_as_used=True
+    )
+    await result.commit(wsm)
+    expected_state = PuzzleHashState(
+        expected_state.highest_index + 1 + wsm.initial_num_public_keys, expected_state.highest_index
+    )
+    assert await get_puzzle_hash_state() == expected_state
+
+    # Test basic transactionality
+    result = await wsm.create_more_puzzle_hashes(
+        up_to_index=uint32(expected_state.highest_index + 1), mark_existing_as_used=False
+    )
+    result = await wsm.create_more_puzzle_hashes(
+        num_additional_phs=(expected_state.highest_index - expected_state.used_up_to_index)
+        + wsm.initial_num_public_keys
+        + 1,
+        mark_existing_as_used=False,
+        previous_result=result,
+    )
+    await result.commit(wsm)
+    expected_state = PuzzleHashState(
+        expected_state.highest_index + 1 + wsm.initial_num_public_keys + 1, expected_state.used_up_to_index
+    )
+    assert await get_puzzle_hash_state() == expected_state
+
+    # Test error using two different "config"s
+    result = await wsm.create_more_puzzle_hashes(mark_existing_as_used=False)
+    with pytest.raises(ValueError, match="different configuration"):
+        await wsm.create_more_puzzle_hashes(mark_existing_as_used=True, previous_result=result)
+
+    # Test generation with no local data
+    await wsm.puzzle_store.delete_wallet(wsm.main_wallet.id())
+    result = await wsm.create_more_puzzle_hashes()
+    await result.commit(wsm)
+    expected_state = PuzzleHashState(
+        wsm.initial_num_public_keys, -1
+    )  # -1 being no puzzle hashes used, not even at index 0
+    assert await get_puzzle_hash_state() == expected_state
+
+    # Test `from_zero` fills in gaps
+    async with wsm.puzzle_store.db_wrapper.writer() as conn:
+        await conn.execute(
+            "DELETE FROM derivation_paths WHERE derivation_index=?",
+            (0,),
+        )
+    assert await get_puzzle_hash_state() == expected_state
+    assert (
+        len(list(await wsm.puzzle_store.get_all_puzzle_hashes())) == (expected_state.highest_index) * 2
+    )  # 0 inclusive
+    result = await wsm.create_more_puzzle_hashes(
+        from_zero=True, mark_existing_as_used=False, up_to_index=uint32(expected_state.highest_index)
+    )
+    await result.commit(wsm)
+    expected_state = PuzzleHashState(expected_state.highest_index + wsm.initial_num_public_keys, -1)
+    assert await get_puzzle_hash_state() == expected_state
+    assert len(list(await wsm.puzzle_store.get_all_puzzle_hashes())) == (expected_state.highest_index + 1) * 2
+
+    # `get_unused_derivation_record`
+    # Assert index increases
+    assert expected_state.highest_index > expected_state.used_up_to_index
+    await wsm.get_unused_derivation_record(wsm.main_wallet.id())
+    expected_state = PuzzleHashState(expected_state.highest_index, expected_state.used_up_to_index + 1)
+    assert await get_puzzle_hash_state() == expected_state
+
+    # Assert more puzzle hashes get made
+    await wsm.puzzle_store.set_used_up_to(uint32(expected_state.highest_index))
+    await wsm.get_unused_derivation_record(wsm.main_wallet.id())
+    expected_state = PuzzleHashState(
+        expected_state.highest_index + wsm.initial_num_public_keys + 1, expected_state.highest_index + 1
+    )
+    assert await get_puzzle_hash_state() == expected_state
+
+    # Test transactionality
+    previous_result = None
+    for _ in range(wsm.initial_num_public_keys):  # all currently unused
+        previous_result = await wsm._get_unused_derivation_record(wsm.main_wallet.id(), previous_result=previous_result)
+    assert previous_result is not None
+    await previous_result.commit(wsm)
+    expected_state = PuzzleHashState(
+        expected_state.highest_index + wsm.initial_num_public_keys, expected_state.highest_index
+    )
+    assert await get_puzzle_hash_state() == expected_state
+
+    # `extend_derivation_index`
+    # Check malformed request
+    rpc_client = wallet_environments.environments[0].rpc_client
+    with pytest.raises(ValueError):
+        await rpc_client.fetch("extend_derivation_index", {})
+
+    # Test no existing derivation paths
+    async with wsm.puzzle_store.db_wrapper.writer() as conn:
+        await conn.execute(
+            "DELETE FROM derivation_paths WHERE derivation_index=?",
+            (0,),
+        )
+    with pytest.raises(ValueError):
+        await rpc_client.extend_derivation_index(0)
+
+    # Reset to a normal state
+    await wsm.puzzle_store.delete_wallet(wsm.main_wallet.id())
+    result = await wsm.create_more_puzzle_hashes()
+    await result.commit(wsm)
+    expected_state = PuzzleHashState(wsm.initial_num_public_keys, -1)
+    assert await get_puzzle_hash_state() == expected_state
+
+    # Test an index already created
+    with pytest.raises(ValueError):
+        await rpc_client.extend_derivation_index(0)
+
+    # Test an index too far in the future
+    with pytest.raises(ValueError):
+        await rpc_client.extend_derivation_index(MAX_DERIVATION_INDEX_DELTA + expected_state.highest_index + 1)
+
+    # Test the actual functionality
+    assert await rpc_client.extend_derivation_index(expected_state.highest_index + 5) == str(
+        expected_state.highest_index + 5
+    )
+    expected_state = PuzzleHashState(expected_state.highest_index + 5, expected_state.used_up_to_index)
+    assert await get_puzzle_hash_state() == expected_state

chia/_tests/wallet/test_wallet_test_framework.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import pytest
+from chia_rs import BlockRecord
 
 from chia._tests.environments.wallet import (
     BalanceCheckingError,
@@ -8,7 +9,6 @@ from chia._tests.environments.wallet import (
     WalletStateTransition,
     WalletTestFramework,
 )
-from chia.consensus.block_record import BlockRecord
 from chia.wallet.cat_wallet.cat_wallet import CATWallet
 
 

chia/_tests/wallet/vc_wallet/test_vc_lifecycle.py

@@ -4,14 +4,14 @@ import itertools
 from typing import Optional
 
 import pytest
-from chia_rs import G2Element
+from chia_rs import CoinSpend, G2Element
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64
 
 from chia._tests.util.spend_sim import CostLogger, sim_and_client
 from chia.types.blockchain_format.coin import Coin
-from chia.types.blockchain_format.program import Program
-from chia.types.coin_spend import CoinSpend, make_spend
+from chia.types.blockchain_format.program import Program, run
+from chia.types.coin_spend import make_spend
 from chia.types.mempool_inclusion_status import MempoolInclusionStatus
 from chia.util.errors import Err
 from chia.util.hash import std_hash
@@ -301,10 +301,10 @@ async def test_did_tp(cost_logger: CostLogger) -> None:
 
         remark_condition: Program = next(
             condition
-            for condition in successful_spend.coin_spends[0]
-            .puzzle_reveal.to_program()
-            .run(successful_spend.coin_spends[0].solution.to_program())
-            .as_iter()
+            for condition in run(
+                successful_spend.coin_spends[0].puzzle_reveal,
+                Program.from_serialized(successful_spend.coin_spends[0].solution),
+            ).as_iter()
             if condition.first() == Program.to(1)
         )
         assert remark_condition == Program.to([1, (MOCK_LAUNCHER_ID, new_metadata), new_tp_hash])
@@ -399,7 +399,7 @@ async def test_revocation_layer(cost_logger: CostLogger) -> None:
 @pytest.mark.parametrize("num_proofs", range(1, 6))
 async def test_proofs_checker(cost_logger: CostLogger, num_proofs: int) -> None:
     async with sim_and_client() as (sim, client):
-        flags: list[str] = [str(i) for i in range(0, num_proofs)]
+        flags: list[str] = [str(i) for i in range(num_proofs)]
         proofs_checker: ProofsChecker = ProofsChecker(flags)
 
         # (mod (PROOFS_CHECKER proofs) (if (a PROOFS_CHECKER (list proofs)) () (x)))

chia/_tests/wallet/vc_wallet/test_vc_wallet.py

@@ -12,8 +12,6 @@ from typing_extensions import Literal
 
 from chia._tests.environments.wallet import WalletEnvironment, WalletStateTransition, WalletTestFramework
 from chia._tests.util.time_out_assert import time_out_assert_not_none
-from chia.rpc.wallet_request_types import VCAddProofs, VCGet, VCGetList, VCGetProofsForRoot, VCMint, VCRevoke, VCSpend
-from chia.rpc.wallet_rpc_client import WalletRpcClient
 from chia.simulator.full_node_simulator import FullNodeSimulator
 from chia.types.blockchain_format.coin import coin_as_list
 from chia.types.blockchain_format.program import Program
@@ -25,13 +23,23 @@ from chia.wallet.cat_wallet.cat_wallet import CATWallet
 from chia.wallet.did_wallet.did_wallet import DIDWallet
 from chia.wallet.util.query_filter import TransactionTypeFilter
 from chia.wallet.util.transaction_type import TransactionType
-from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG
+from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG, TXConfig
 from chia.wallet.util.wallet_types import WalletType
 from chia.wallet.vc_wallet.cr_cat_drivers import ProofsChecker, construct_cr_layer
 from chia.wallet.vc_wallet.cr_cat_wallet import CRCATWallet
 from chia.wallet.vc_wallet.vc_store import VCProofs, VCRecord
 from chia.wallet.wallet import Wallet
 from chia.wallet.wallet_node import WalletNode
+from chia.wallet.wallet_request_types import (
+    VCAddProofs,
+    VCGet,
+    VCGetList,
+    VCGetProofsForRoot,
+    VCMint,
+    VCRevoke,
+    VCSpend,
+)
+from chia.wallet.wallet_rpc_client import WalletRpcClient
 from chia.wallet.wallet_spend_bundle import WalletSpendBundle
 
 
@@ -41,11 +49,13 @@ async def mint_cr_cat(
     wallet_node_0: WalletNode,
     client_0: WalletRpcClient,
     full_node_api: FullNodeSimulator,
+    tx_config: TXConfig,
     authorized_providers: list[bytes32] = [],
     tail: Program = Program.to(None),
     proofs_checker: ProofsChecker = ProofsChecker(["foo", "bar"]),
 ) -> None:
-    our_puzzle: Program = await wallet_0.get_new_puzzle()
+    async with wallet_0.wallet_state_manager.new_action_scope(tx_config, push=True) as action_scope:
+        our_puzzle = await action_scope.get_puzzle(wallet_0.wallet_state_manager)
     cat_puzzle: Program = construct_cat_puzzle(
         CAT_MOD,
         tail.get_tree_hash(),
@@ -62,7 +72,7 @@ async def mint_cr_cat(
                     "amount": CAT_AMOUNT_0,
                 }
             ],
-            DEFAULT_TX_CONFIG,
+            tx_config,
             wallet_id=1,
         )
     ).signed_tx
@@ -161,11 +171,13 @@ async def test_vc_lifecycle(wallet_environments: WalletTestFramework) -> None:
         )
 
     # Mint a VC
+    async with wallet_0.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        ph = await action_scope.get_puzzle_hash(wallet_0.wallet_state_manager)
     vc_record = (
         await client_0.vc_mint(
             VCMint(
                 did_id=encode_puzzle_hash(did_id, "did"),
-                target_address=encode_puzzle_hash(await wallet_0.get_new_puzzlehash(), "txch"),
+                target_address=encode_puzzle_hash(ph, "txch"),
                 fee=uint64(1_750_000_000_000),
                 push=True,
             ),
@@ -311,7 +323,7 @@ async def test_vc_lifecycle(wallet_environments: WalletTestFramework) -> None:
     assert get_list_reponse.proof_dict[proof_root] == proofs.key_value_pairs
 
     # Mint CR-CAT
-    await mint_cr_cat(1, wallet_0, wallet_node_0, client_0, full_node_api, [did_id])
+    await mint_cr_cat(1, wallet_0, wallet_node_0, client_0, full_node_api, wallet_environments.tx_config, [did_id])
     await wallet_environments.process_pending_states(
         [
             WalletStateTransition(
@@ -360,7 +372,8 @@ async def test_vc_lifecycle(wallet_environments: WalletTestFramework) -> None:
         "flags_needed": cr_cat_wallet_0.info.proofs_checker.flags,
     } == (await client_0.get_wallets(wallet_type=cr_cat_wallet_0.type()))[0]
     assert await wallet_node_0.wallet_state_manager.get_wallet_for_asset_id(cr_cat_wallet_0.get_asset_id()) is not None
-    wallet_1_ph = await wallet_1.get_new_puzzlehash()
+    async with wallet_1.wallet_state_manager.new_action_scope(wallet_environments.tx_config, push=True) as action_scope:
+        wallet_1_ph = await action_scope.get_puzzle_hash(wallet_1.wallet_state_manager)
     wallet_1_addr = encode_puzzle_hash(wallet_1_ph, "txch")
     txs = (
         await client_0.cat_spend(
@@ -446,8 +459,10 @@ async def test_vc_lifecycle(wallet_environments: WalletTestFramework) -> None:
     assert len(pending_tx) == 1
 
     # Send the VC to wallet_1 to use for the CR-CATs
+    async with wallet_1.wallet_state_manager.new_action_scope(wallet_environments.tx_config, push=True) as action_scope:
+        ph = await action_scope.get_puzzle_hash(wallet_1.wallet_state_manager)
     await client_0.vc_spend(
-        VCSpend(vc_id=vc_record.vc.launcher_id, new_puzhash=await wallet_1.get_new_puzzlehash(), push=True),
+        VCSpend(vc_id=vc_record.vc.launcher_id, new_puzhash=ph, push=True),
         wallet_environments.tx_config,
     )
     await wallet_environments.process_pending_states(
@@ -682,11 +697,13 @@ async def test_self_revoke(wallet_environments: WalletTestFramework) -> None:
         )
     did_id: bytes32 = bytes32.from_hexstr(did_wallet.get_my_DID())
 
+    async with wallet_0.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+        ph = await action_scope.get_puzzle_hash(wallet_0.wallet_state_manager)
     vc_record = (
         await client_0.vc_mint(
             VCMint(
                 did_id=encode_puzzle_hash(did_id, "did"),
-                target_address=encode_puzzle_hash(await wallet_0.get_new_puzzlehash(), "txch"),
+                target_address=encode_puzzle_hash(ph, "txch"),
                 fee=uint64(200),
                 push=True,
             ),
@@ -720,7 +737,7 @@ async def test_self_revoke(wallet_environments: WalletTestFramework) -> None:
         ) as action_scope:
             await (await wallet_node_0.wallet_state_manager.get_or_create_vc_wallet()).generate_signed_transaction(
                 [uint64(1)],
-                [await wallet_0.get_puzzle_hash(new=not action_scope.config.tx_config.reuse_puzhash)],
+                [await action_scope.get_puzzle_hash(wallet_node_0.wallet_state_manager)],
                 action_scope,
                 vc_id=new_vc_record.vc.launcher_id,
                 new_proof_hash=bytes32.zeros,
@@ -815,7 +832,7 @@ async def test_cat_wallet_conversion(
     )
 
     did_id = bytes32.zeros
-    await mint_cr_cat(num_blocks, wallet_0, wallet_node_0, client_0, full_node_api, [did_id])
+    await mint_cr_cat(num_blocks, wallet_0, wallet_node_0, client_0, full_node_api, DEFAULT_TX_CONFIG, [did_id])
     await full_node_api.farm_blocks_to_wallet(count=num_blocks, wallet=wallet_0)
     await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node_0, timeout=20)
 

chia/_tests/wallet/wallet_block_tools.py

@@ -4,23 +4,27 @@ import time
 from typing import Any, Optional
 
 from chia_rs import (
+    BlockRecord,
     ConsensusConstants,
     Foliage,
     FoliageBlockData,
     FoliageTransactionBlock,
+    FullBlock,
     G1Element,
     G2Element,
     PoolTarget,
+    ProofOfSpace,
     RewardChainBlock,
     RewardChainBlockUnfinished,
+    SpendBundle,
     TransactionsInfo,
+    UnfinishedBlock,
     compute_merkle_set_root,
 )
 from chia_rs.sized_bytes import bytes32, bytes100
 from chia_rs.sized_ints import uint8, uint32, uint64, uint128
 from chiabip158 import PyBIP158
 
-from chia.consensus.block_record import BlockRecord
 from chia.consensus.block_rewards import calculate_base_farmer_reward, calculate_pool_reward
 from chia.consensus.coinbase import create_farmer_coin, create_pool_coin
 from chia.consensus.full_block_to_block_record import block_to_block_record
@@ -28,12 +32,8 @@ from chia.full_node.bundle_tools import simple_solution_generator
 from chia.simulator.block_tools import BlockTools, compute_additions_unchecked
 from chia.types.blockchain_format.classgroup import ClassgroupElement
 from chia.types.blockchain_format.coin import Coin, hash_coin_ids
-from chia.types.blockchain_format.proof_of_space import ProofOfSpace
 from chia.types.blockchain_format.vdf import VDFInfo, VDFProof
-from chia.types.full_block import FullBlock
 from chia.types.generator_types import BlockGenerator
-from chia.types.spend_bundle import SpendBundle
-from chia.types.unfinished_block import UnfinishedBlock
 from chia.util.block_cache import BlockCache
 from chia.util.hash import std_hash
 
@@ -94,7 +94,7 @@ class WalletBlockTools(BlockTools):
             latest_block = None
             last_timestamp = uint64((int(time.time()) if genesis_timestamp is None else genesis_timestamp) - 20)
 
-        for _ in range(0, num_blocks):
+        for _ in range(num_blocks):
             additions = []
             removals = []
             block_generator: Optional[BlockGenerator] = None

chia/_tests/weight_proof/test_weight_proof.py

@@ -1,24 +1,16 @@
 from __future__ import annotations
 
-from typing import Optional
-
 import pytest
-from chia_rs import ConsensusConstants
+from chia_rs import BlockRecord, ConsensusConstants, FullBlock, HeaderBlock, SubEpochSummary
 from chia_rs.sized_bytes import bytes32
-from chia_rs.sized_ints import uint8, uint32, uint64
+from chia_rs.sized_ints import uint32
 
 from chia._tests.util.blockchain_mock import BlockchainMock
-from chia.consensus.block_record import BlockRecord
-from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.consensus.full_block_to_block_record import block_to_block_record
-from chia.consensus.pot_iterations import calculate_iterations_quality
+from chia.consensus.generator_tools import get_block_header
+from chia.consensus.pot_iterations import validate_pospace_and_get_required_iters
 from chia.full_node.weight_proof import WeightProofHandler, _map_sub_epoch_summaries, _validate_summaries_weight
 from chia.simulator.block_tools import BlockTools
-from chia.types.blockchain_format.proof_of_space import calculate_prefix_bits, verify_and_get_quality_string
-from chia.types.blockchain_format.sub_epoch_summary import SubEpochSummary
-from chia.types.full_block import FullBlock
-from chia.types.header_block import HeaderBlock
-from chia.util.generator_tools import get_block_header
 
 
 async def load_blocks_dont_validate(
@@ -48,22 +40,17 @@ async def load_blocks_dont_validate(
         else:
             cc_sp = block.reward_chain_block.challenge_chain_sp_vdf.output.get_hash()
 
-        quality_string: Optional[bytes32] = verify_and_get_quality_string(
-            block.reward_chain_block.proof_of_space,
+        required_iters = validate_pospace_and_get_required_iters(
             constants,
+            block.reward_chain_block.proof_of_space,
             block.reward_chain_block.pos_ss_cc_challenge_hash,
             cc_sp,
-            height=block.height,
-        )
-        assert quality_string is not None
-
-        required_iters: uint64 = calculate_iterations_quality(
-            constants.DIFFICULTY_CONSTANT_FACTOR,
-            quality_string,
-            block.reward_chain_block.proof_of_space.size,
+            block.height,
             difficulty,
-            cc_sp,
+            sub_slot_iters,
+            uint32(0),  # prev_tx_block(blocks, prev_b), todo need to get height of prev tx block somehow here
         )
+        assert required_iters is not None
 
         sub_block = block_to_block_record(
             constants,
@@ -501,28 +488,3 @@ class TestWeightProof:
         valid, fork_point, _ = await wpf.validate_weight_proof(new_wp)
         assert valid
         assert fork_point != 0
-
-
-@pytest.mark.parametrize("height,expected", [(0, 3), (5496000, 2), (10542000, 1), (15592000, 0), (20643000, 0)])
-def test_calculate_prefix_bits_clamp_zero(height: uint32, expected: int) -> None:
-    constants = DEFAULT_CONSTANTS.replace(NUMBER_ZERO_BITS_PLOT_FILTER=uint8(3))
-    assert calculate_prefix_bits(constants, height) == expected
-
-
-@pytest.mark.parametrize(
-    argnames=["height", "expected"],
-    argvalues=[
-        (0, 9),
-        (5495999, 9),
-        (5496000, 8),
-        (10541999, 8),
-        (10542000, 7),
-        (15591999, 7),
-        (15592000, 6),
-        (20642999, 6),
-        (20643000, 5),
-    ],
-)
-def test_calculate_prefix_bits_default(height: uint32, expected: int) -> None:
-    constants = DEFAULT_CONSTANTS
-    assert calculate_prefix_bits(constants, height) == expected

chia/apis.py

@@ -4,8 +4,8 @@ from chia.farmer.farmer_api import FarmerAPI
 from chia.full_node.full_node_api import FullNodeAPI
 from chia.harvester.harvester_api import HarvesterAPI
 from chia.introducer.introducer_api import IntroducerAPI
+from chia.protocols.outbound_message import NodeType
 from chia.server.api_protocol import ApiProtocol
-from chia.server.outbound_message import NodeType
 from chia.timelord.timelord_api import TimelordAPI
 from chia.wallet.wallet_node_api import WalletNodeAPI
 

chia/cmds/beta.py

@@ -138,7 +138,7 @@ def prepare_submission_cmd(ctx: click.Context) -> None:
     user_input = input("Select the version you want to prepare for submission: ")
     try:
         if int(user_input) <= 0:
-            raise IndexError()
+            raise IndexError
         prepare_result = available_results[int(user_input) - 1]
     except IndexError:
         raise click.ClickException(f"Invalid choice: {user_input}")

chia/cmds/chia.py

@@ -12,7 +12,7 @@ from chia.cmds.completion import completion
 from chia.cmds.configure import configure_cmd
 from chia.cmds.data import data_cmd
 from chia.cmds.db import db_cmd
-from chia.cmds.dev import dev_cmd
+from chia.cmds.dev.main import dev_cmd
 from chia.cmds.farm import farm_cmd
 from chia.cmds.init import init_cmd
 from chia.cmds.keys import keys_cmd
@@ -27,10 +27,10 @@ from chia.cmds.show import show_cmd
 from chia.cmds.start import start_cmd
 from chia.cmds.stop import stop_cmd
 from chia.cmds.wallet import wallet_cmd
+from chia.ssl.ssl_check import check_ssl
 from chia.util.default_root import DEFAULT_KEYS_ROOT_PATH, resolve_root_path
 from chia.util.errors import KeychainCurrentPassphraseIsInvalid
 from chia.util.keychain import Keychain, set_keys_root_path
-from chia.util.ssl_check import check_ssl
 
 CONTEXT_SETTINGS = {
     "help_option_names": ["-h", "--help"],
@@ -53,24 +53,24 @@ CONTEXT_SETTINGS = {
 @click.option(
     "--keys-root-path", default=DEFAULT_KEYS_ROOT_PATH, help="Keyring file root", type=click.Path(), show_default=True
 )
-@click.option("--passphrase-file", type=click.File("r"), help="File or descriptor to read the keyring passphrase from")
+@click.option("--passphrase-file", type=click.File("r"), help="File to read the keyring passphrase from")
 @click.pass_context
 def cli(
     ctx: click.Context,
     root_path: str,
-    keys_root_path: Optional[str] = None,
+    keys_root_path: str,
     passphrase_file: Optional[TextIOWrapper] = None,
 ) -> None:
     from pathlib import Path
 
     context = ChiaCliContext.set_default(ctx=ctx)
     context.root_path = Path(root_path)
+    context.keys_root_path = Path(keys_root_path)
 
-    # keys_root_path and passphrase_file will be None if the passphrase options have been
-    # scrubbed from the CLI options
-    if keys_root_path is not None:
-        set_keys_root_path(Path(keys_root_path))
+    set_keys_root_path(Path(keys_root_path))
 
+    # passphrase_file will be None if the passphrase options have been
+    # scrubbed from the CLI options
     if passphrase_file is not None:
         import sys
 
@@ -81,7 +81,7 @@ def cli(
             if Keychain.master_passphrase_is_valid(passphrase):
                 cache_passphrase(passphrase)
             else:
-                raise KeychainCurrentPassphraseIsInvalid()
+                raise KeychainCurrentPassphraseIsInvalid
         except KeychainCurrentPassphraseIsInvalid:
             if Path(passphrase_file.name).is_file():
                 print(f'Invalid passphrase found in "{passphrase_file.name}"')