chia-blockchain 2.5.6rc2__py3-none-any.whl → 2.5.7rc2__py3-none-any.whl

chia/_tests/core/server/test_server.py

@@ -14,6 +14,7 @@ from chia._tests.connection_utils import connect_and_get_peer
 from chia._tests.util.setup_nodes import SimulatorsAndWalletsServices
 from chia._tests.util.time_out_assert import time_out_assert
 from chia.full_node.full_node_api import FullNodeAPI
+from chia.full_node.start_full_node import create_full_node_service
 from chia.protocols.full_node_protocol import RejectBlock, RequestBlock, RequestTransaction
 from chia.protocols.outbound_message import NodeType, make_msg
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
@@ -21,12 +22,11 @@ from chia.protocols.shared_protocol import Error, protocol_version
 from chia.protocols.wallet_protocol import RejectHeaderRequest
 from chia.server.api_protocol import ApiMetadata
 from chia.server.server import ChiaServer
-from chia.server.start_full_node import create_full_node_service
-from chia.server.start_wallet import create_wallet_service
 from chia.server.ws_connection import WSChiaConnection, error_response_version
 from chia.simulator.block_tools import BlockTools
 from chia.types.peer_info import PeerInfo
 from chia.util.errors import ApiError, Err
+from chia.wallet.start_wallet import create_wallet_service
 
 
 @dataclass

chia/_tests/core/services/test_services.py

@@ -86,15 +86,15 @@ async def test_daemon_terminates(signal_number: signal.Signals, chia_root: ChiaR
 @pytest.mark.parametrize(
     argnames=["create_service", "module_path", "service_config_name"],
     argvalues=[
-        [DataLayerRpcClient.create_as_context, "chia.server.start_data_layer", "data_layer"],
-        [FarmerRpcClient.create_as_context, "chia.server.start_farmer", "farmer"],
-        [FullNodeRpcClient.create_as_context, "chia.server.start_full_node", "full_node"],
-        [HarvesterRpcClient.create_as_context, "chia.server.start_harvester", "harvester"],
-        [WalletRpcClient.create_as_context, "chia.server.start_wallet", "wallet"],
-        [None, "chia.server.start_introducer", "introducer"],
+        [DataLayerRpcClient.create_as_context, "chia.data_layer.start_data_layer", "data_layer"],
+        [FarmerRpcClient.create_as_context, "chia.farmer.start_farmer", "farmer"],
+        [FullNodeRpcClient.create_as_context, "chia.full_node.start_full_node", "full_node"],
+        [HarvesterRpcClient.create_as_context, "chia.harvester.start_harvester", "harvester"],
+        [WalletRpcClient.create_as_context, "chia.wallet.start_wallet", "wallet"],
+        [None, "chia.introducer.start_introducer", "introducer"],
         # TODO: fails...  make it not do that
         # [None, "chia.seeder.start_crawler", "crawler"],
-        [None, "chia.server.start_timelord", "timelord"],
+        [None, "chia.timelord.start_timelord", "timelord"],
         pytest.param(
             None,
             "chia.timelord.timelord_launcher",

chia/_tests/core/test_cost_calculation.py

@@ -4,7 +4,8 @@ import logging
 import pathlib
 
 import pytest
-from chia_rs import G1Element
+from chia_rs import G1Element, get_flags_for_height_and_constants
+from chia_rs import get_puzzle_and_solution_for_coin2 as get_puzzle_and_solution_for_coin
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64
 from clvm_tools import binutils
@@ -16,7 +17,6 @@ from chia.consensus.condition_costs import ConditionCost
 from chia.consensus.cost_calculator import NPCResult
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.full_node.bundle_tools import simple_solution_generator
-from chia.full_node.mempool_check_conditions import get_puzzle_and_solution_for_coin
 from chia.simulator.block_tools import BlockTools, test_constants
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program, run_with_cost
@@ -89,9 +89,15 @@ async def test_basics(softfork_height: int, bt: BlockTools) -> None:
     coin_spend = spend_bundle.coin_spends[0]
     assert npc_result.conds is not None
     assert coin_spend.coin.name() == npc_result.conds.spends[0].coin_id
-    spend_info = get_puzzle_and_solution_for_coin(program, coin_spend.coin, softfork_height, bt.constants)
-    assert spend_info.puzzle == coin_spend.puzzle_reveal
-    assert spend_info.solution == coin_spend.solution
+    puzzle, solution = get_puzzle_and_solution_for_coin(
+        program.program,
+        program.generator_refs,
+        bt.constants.MAX_BLOCK_COST_CLVM,
+        coin_spend.coin,
+        get_flags_for_height_and_constants(softfork_height, bt.constants),
+    )
+    assert puzzle == coin_spend.puzzle_reveal
+    assert solution == coin_spend.solution
 
     if softfork_height >= bt.constants.HARD_FORK_HEIGHT:
         clvm_cost = 27360
@@ -170,8 +176,14 @@ async def test_mempool_mode(softfork_height: int, bt: BlockTools) -> None:
         bytes32.fromhex("14947eb0e69ee8fc8279190fc2d38cb4bbb61ba28f1a270cfd643a0e8d759576"),
         uint64(300),
     )
-    spend_info = get_puzzle_and_solution_for_coin(generator, coin, softfork_height, bt.constants)
-    assert spend_info.puzzle == puzzle.to_serialized()
+    puz, _solution = get_puzzle_and_solution_for_coin(
+        generator.program,
+        generator.generator_refs,
+        bt.constants.MAX_BLOCK_COST_CLVM,
+        coin,
+        get_flags_for_height_and_constants(0, bt.constants),
+    )
+    assert puz == puzzle.to_serialized()
 
 
 @pytest.mark.anyio
@@ -282,8 +294,11 @@ async def test_standard_tx(benchmark_runner: BenchmarkRunner) -> None:
 
 @pytest.mark.anyio
 async def test_get_puzzle_and_solution_for_coin_performance(benchmark_runner: BenchmarkRunner) -> None:
+    from chia_puzzles_py.programs import CHIALISP_DESERIALISATION
+
     from chia._tests.core.large_block import LARGE_BLOCK
-    from chia.full_node.mempool_check_conditions import DESERIALIZE_MOD
+
+    DESERIALIZE_MOD = Program.from_bytes(CHIALISP_DESERIALISATION)
 
     assert LARGE_BLOCK.transactions_generator is not None
     # first, list all spent coins in the block
@@ -309,5 +324,11 @@ async def test_get_puzzle_and_solution_for_coin_performance(benchmark_runner: Be
     with benchmark_runner.assert_runtime(seconds=8.5):
         for _ in range(3):
             for c in spent_coins:
-                spend_info = get_puzzle_and_solution_for_coin(generator, c, 0, test_constants)
-                assert spend_info.puzzle.get_tree_hash() == c.puzzle_hash
+                puz, _solution = get_puzzle_and_solution_for_coin(
+                    generator.program,
+                    generator.generator_refs,
+                    test_constants.MAX_BLOCK_COST_CLVM,
+                    c,
+                    get_flags_for_height_and_constants(0, test_constants),
+                )
+                assert puz.get_tree_hash() == c.puzzle_hash

chia/_tests/core/test_crawler.py

@@ -16,8 +16,8 @@ from chia.protocols.full_node_protocol import NewPeak
 from chia.protocols.outbound_message import make_msg
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
 from chia.protocols.wallet_protocol import RequestChildren
+from chia.seeder.crawler_service import CrawlerService
 from chia.seeder.peer_record import PeerRecord, PeerReliability
-from chia.server.aliases import CrawlerService
 from chia.types.peer_info import PeerInfo
 
 
@@ -111,7 +111,7 @@ async def test_crawler_to_db(crawler_service_no_loop: CrawlerService, one_node:
         uint64(0),
         uint32(0),
         uint64(0),
-        uint64(int(time.time())),
+        uint64(time.time()),
         uint64(0),
         "undefined",
         uint64(0),
@@ -153,8 +153,8 @@ async def test_crawler_peer_cleanup(
             uint64(0),
             uint32(0),
             uint64(0),
-            uint64(int(time.time())),
-            uint64(int((datetime.now() - timedelta(days=idx * 10)).timestamp())),
+            uint64(time.time()),
+            uint64((datetime.now() - timedelta(days=idx * 10)).timestamp()),
             "undefined",
             uint64(0),
             tls_version="unknown",

chia/_tests/core/test_db_conversion.py

@@ -10,9 +10,9 @@ from chia_rs.sized_ints import uint32, uint64
 from chia._tests.util.temp_file import TempFile
 from chia.cmds.db_upgrade_func import convert_v1_to_v2
 from chia.consensus.block_body_validation import ForkInfo
+from chia.consensus.block_height_map import BlockHeightMap
 from chia.consensus.blockchain import Blockchain
 from chia.consensus.multiprocess_validation import PreValidationResult
-from chia.full_node.block_height_map import BlockHeightMap
 from chia.full_node.block_store import BlockStore
 from chia.full_node.coin_store import CoinStore
 from chia.full_node.hint_store import HintStore
@@ -20,13 +20,6 @@ from chia.simulator.block_tools import test_constants
 from chia.util.db_wrapper import DBWrapper2
 
 
-def rand_bytes(num) -> bytes:
-    ret = bytearray(num)
-    for i in range(num):
-        ret[i] = random.getrandbits(8)
-    return bytes(ret)
-
-
 @pytest.mark.anyio
 @pytest.mark.parametrize("with_hints", [True, False])
 @pytest.mark.skip("we no longer support DB v1")
@@ -35,21 +28,21 @@ async def test_blocks(default_1000_blocks, with_hints: bool):
 
     hints: list[tuple[bytes32, bytes]] = []
     for i in range(351):
-        hints.append((bytes32(rand_bytes(32)), rand_bytes(20)))
+        hints.append((bytes32.random(), random.randbytes(20)))
 
     # the v1 schema allows duplicates in the hints table
     for i in range(10):
-        coin_id = bytes32(rand_bytes(32))
-        hint = rand_bytes(20)
+        coin_id = bytes32.random()
+        hint = random.randbytes(20)
         hints.append((coin_id, hint))
         hints.append((coin_id, hint))
 
     for i in range(2000):
-        hints.append((bytes32(rand_bytes(32)), rand_bytes(20)))
+        hints.append((bytes32.random(), random.randbytes(20)))
 
     for i in range(5):
-        coin_id = bytes32(rand_bytes(32))
-        hint = rand_bytes(20)
+        coin_id = bytes32.random()
+        hint = random.randbytes(20)
         hints.append((coin_id, hint))
         hints.append((coin_id, hint))
 

chia/_tests/core/test_db_validation.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import random
 import sqlite3
 from contextlib import closing
 from pathlib import Path
@@ -14,10 +13,10 @@ from chia_rs.sized_ints import uint32, uint64
 from chia._tests.util.temp_file import TempFile
 from chia.cmds.db_validate_func import validate_v2
 from chia.consensus.block_body_validation import ForkInfo
+from chia.consensus.block_height_map import BlockHeightMap
 from chia.consensus.blockchain import Blockchain
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.consensus.multiprocess_validation import PreValidationResult
-from chia.full_node.block_height_map import BlockHeightMap
 from chia.full_node.block_store import BlockStore
 from chia.full_node.coin_store import CoinStore
 from chia.simulator.block_tools import test_constants
@@ -25,10 +24,7 @@ from chia.util.db_wrapper import DBWrapper2
 
 
 def rand_hash() -> bytes32:
-    ret = bytearray(32)
-    for i in range(32):
-        ret[i] = random.getrandbits(8)
-    return bytes32(ret)
+    return bytes32.random()
 
 
 def make_version(conn: sqlite3.Connection, version: int) -> None:

chia/_tests/core/test_farmer_harvester_rpc.py

@@ -30,11 +30,15 @@ from chia.farmer.farmer_rpc_api import (
     plot_matches_filter,
 )
 from chia.farmer.farmer_rpc_client import FarmerRpcClient
+from chia.farmer.farmer_service import FarmerService
+from chia.harvester.harvester_service import HarvesterService
 from chia.plot_sync.receiver import Receiver, get_list_or_len
 from chia.plotting.util import add_plot_directory
 from chia.protocols import farmer_protocol
 from chia.protocols.harvester_protocol import Plot
-from chia.simulator.block_tools import get_plot_dir
+from chia.rpc.rpc_client import ResponseFailureError
+from chia.simulator.block_tools import BlockTools, get_plot_dir
+from chia.solver.solver_service import SolverService
 from chia.util.bech32m import decode_puzzle_hash, encode_puzzle_hash
 from chia.util.config import load_config, lock_and_load_config, save_config
 from chia.util.hash import std_hash
@@ -503,3 +507,32 @@ async def test_harvester_add_plot_directory(harvester_farmer_environment: Harves
     added_directories = await harvester_rpc_client.get_plot_directories()
     assert str(test_path) in added_directories
     assert str(test_path_other) in added_directories
+
+
+@pytest.mark.anyio
+async def test_farmer_connect_to_solver(
+    farmer_one_harvester_solver: tuple[list[HarvesterService], FarmerService, SolverService, BlockTools],
+) -> None:
+    _, farmer_service, solver_service, bt = farmer_one_harvester_solver
+    assert farmer_service.rpc_server is not None
+    farmer_rpc_client = await FarmerRpcClient.create(
+        bt.config["self_hostname"],
+        farmer_service.rpc_server.listen_port,
+        farmer_service.root_path,
+        farmer_service.config,
+    )
+
+    try:
+        # Test successful connection to existing solver
+        solver_host = bt.config["self_hostname"]
+        solver_port = solver_service._server.get_port()
+        result = await farmer_rpc_client.connect_to_solver(solver_host, solver_port)
+        assert result["success"] is True
+
+        # Test connection failure to non-existent solver
+        with pytest.raises(ResponseFailureError) as exc_info:
+            await farmer_rpc_client.connect_to_solver("localhost", 65000)
+        assert "Could not connect to solver" in exc_info.value.response["error"]
+    finally:
+        farmer_rpc_client.close()
+        await farmer_rpc_client.await_closed()

chia/_tests/core/test_full_node_rpc.py

@@ -88,8 +88,8 @@ async def test1(
 
         peak_block = await client.get_block(state["peak"].header_hash)
         assert peak_block == blocks[-1]
-        assert (await client.get_block(bytes32([1] * 32))) is None
-
+        with pytest.raises(ValueError, match="not found"):
+            await client.get_block(bytes32([1] * 32))
         block_record = await client.get_block_record_by_height(2)
         assert block_record is not None
         assert block_record.header_hash == blocks[2].header_hash
@@ -150,8 +150,10 @@ async def test1(
 
         assert len(await client.get_all_mempool_items()) == 0
         assert len(await client.get_all_mempool_tx_ids()) == 0
-        assert (await client.get_mempool_item_by_tx_id(spend_bundle.name())) is None
-        assert (await client.get_mempool_item_by_tx_id(spend_bundle.name(), False)) is None
+        with pytest.raises(ValueError, match="not in the mempool"):
+            await client.get_mempool_item_by_tx_id(spend_bundle.name())
+        with pytest.raises(ValueError, match="not in the mempool"):
+            await client.get_mempool_item_by_tx_id(spend_bundle.name(), False)
 
         await client.push_tx(spend_bundle)
         coin = spend_bundle.additions()[0]
@@ -168,7 +170,8 @@ async def test1(
         mempool_item = await client.get_mempool_item_by_tx_id(spend_bundle.name())
         assert mempool_item is not None
         assert WalletSpendBundle.from_json_dict(mempool_item["spend_bundle"]) == spend_bundle
-        assert (await client.get_coin_record_by_name(coin.name())) is None
+        with pytest.raises(ValueError, match="not found"):
+            await client.get_coin_record_by_name(coin.name())
 
         # Verify that the include_pending arg to get_mempool_item_by_tx_id works
         coin_to_spend_pending = included_reward_coins[1]
@@ -181,11 +184,11 @@ async def test1(
             condition_dic=condition_dic,
         )
         await client.push_tx(spend_bundle_pending)
-        # not strictly in the mempool
-        assert (await client.get_mempool_item_by_tx_id(spend_bundle_pending.name(), False)) is None
+        with pytest.raises(ValueError, match="not in the mempool"):
+            # not strictly in the mempool
+            await client.get_mempool_item_by_tx_id(spend_bundle_pending.name(), False)
         # pending entry into mempool, so include_pending fetches
         mempool_item = await client.get_mempool_item_by_tx_id(spend_bundle_pending.name(), True)
-        assert mempool_item is not None
         assert WalletSpendBundle.from_json_dict(mempool_item["spend_bundle"]) == spend_bundle_pending
 
         await full_node_api_1.farm_new_transaction_block(FarmNewBlockProtocol(ph_2))
@@ -254,7 +257,8 @@ async def test1(
         assert coin_spend_with_conditions.coin_spend.solution == SerializedProgram.fromhex(
             "ff80ffff01ffff33ffa063c767818f8b7cc8f3760ce34a09b7f34cd9ddf09d345c679b6897e7620c575cff8601977420dc0080ffff3cffa0a2366d6d8e1ce7496175528f5618a13da8401b02f2bac1eaae8f28aea9ee54798080ff8080"
         )
-        assert coin_spend_with_conditions.conditions == [
+
+        expected = [
             ConditionWithArgs(
                 ConditionOpcode(b"2"),
                 [
@@ -279,6 +283,8 @@ async def test1(
             ),
         ]
 
+        assert coin_spend_with_conditions.conditions == expected
+
         coin_spend_with_conditions = block_spends_with_conditions[2]
 
         assert coin_spend_with_conditions.coin_spend.coin == Coin(
@@ -451,17 +457,15 @@ async def test_signage_points(
         full_node_service_1.config,
     ) as client:
         # Only provide one
-        res = await client.get_recent_signage_point_or_eos(None, None)
-        assert res is None
-        res = await client.get_recent_signage_point_or_eos(std_hash(b"0"), std_hash(b"1"))
-        assert res is None
-
+        with pytest.raises(ValueError, match="sp_hash or challenge_hash must be provided"):
+            await client.get_recent_signage_point_or_eos(None, None)
+        with pytest.raises(ValueError, match="Either sp_hash or challenge_hash must be provided, not both"):
+            await client.get_recent_signage_point_or_eos(std_hash(b"0"), std_hash(b"1"))
         # Not found
-        res = await client.get_recent_signage_point_or_eos(std_hash(b"0"), None)
-        assert res is None
-        res = await client.get_recent_signage_point_or_eos(None, std_hash(b"0"))
-        assert res is None
-
+        with pytest.raises(ValueError, match="in cache"):
+            await client.get_recent_signage_point_or_eos(std_hash(b"0"), None)
+        with pytest.raises(ValueError, match="in cache"):
+            await client.get_recent_signage_point_or_eos(None, std_hash(b"0"))
         blocks = bt.get_consecutive_blocks(5)
         for block in blocks:
             await full_node_api_1.full_node.add_block(block)
@@ -491,8 +495,8 @@ async def test_signage_points(
         assert sp.rc_proof is not None
         assert sp.rc_vdf is not None
         # Don't have SP yet
-        res = await client.get_recent_signage_point_or_eos(sp.cc_vdf.output.get_hash(), None)
-        assert res is None
+        with pytest.raises(ValueError, match="Did not find sp"):
+            await client.get_recent_signage_point_or_eos(sp.cc_vdf.output.get_hash(), None)
 
         # Add the last block
         await full_node_api_1.full_node.add_block(blocks[-1])
@@ -514,9 +518,8 @@ async def test_signage_points(
         selected_eos = blocks[-1].finished_sub_slots[0]
 
         # Don't have EOS yet
-        res = await client.get_recent_signage_point_or_eos(None, selected_eos.challenge_chain.get_hash())
-        assert res is None
-
+        with pytest.raises(ValueError, match="Did not find eos"):
+            await client.get_recent_signage_point_or_eos(None, selected_eos.challenge_chain.get_hash())
         # Properly fetch an EOS
         for eos in blocks[-1].finished_sub_slots:
             await full_node_api_1.full_node.add_end_of_sub_slot(eos, peer)
@@ -545,6 +548,7 @@ async def test_signage_points(
 
         # Signage point is no longer in the blockchain
         res = await client.get_recent_signage_point_or_eos(sp.cc_vdf.output.get_hash(), None)
+        assert res is not None
         assert res["reverted"]
         assert res["signage_point"] == sp
         assert "eos" not in res

chia/_tests/core/test_merkle_set.py

@@ -279,10 +279,7 @@ async def test_merkle_right_edge() -> None:
 
 
 def rand_hash(rng: random.Random) -> bytes32:
-    ret = bytearray(32)
-    for i in range(32):
-        ret[i] = rng.getrandbits(8)
-    return bytes32(ret)
+    return bytes32.random(r=rng)
 
 
 @pytest.mark.anyio

chia/_tests/core/test_seeder.py

@@ -83,7 +83,7 @@ def database_peers() -> dict[str, PeerReliability]:
             uint64(0),
             uint32(0),
             uint64(0),
-            uint64(int(time.time())),
+            uint64(time.time()),
             uint64(0),
             "undefined",
             uint64(0),

chia/_tests/core/util/test_keychain.py

@@ -220,9 +220,9 @@ class TestKeychain:
         test_vectors_path = importlib_resources.files(chia._tests.util.__name__).joinpath("bip39_test_vectors.json")
         all_vectors = json.loads(test_vectors_path.read_text(encoding="utf-8"))
 
-        for idx, [entropy_hex, full_mnemonic, seed, short_mnemonic] in enumerate(all_vectors["english"]):
+        for idx, [entropy_hex, full_mnemonic, seed_hex, short_mnemonic] in enumerate(all_vectors["english"]):
             entropy_bytes = bytes.fromhex(entropy_hex)
-            seed = bytes.fromhex(seed)
+            seed = bytes.fromhex(seed_hex)
 
             assert mnemonic_from_short_words(short_mnemonic) == full_mnemonic
             assert bytes_from_mnemonic(short_mnemonic) == entropy_bytes

chia/_tests/core/util/test_lru_cache.py

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 import unittest
 
+import pytest
+
 from chia.util.lru_cache import LRUCache
 
 
@@ -54,3 +56,17 @@ class TestLRUCache(unittest.TestCase):
         assert len(cache.cache) == 5
         assert cache.get(b"0") is None
         assert cache.get(b"1") == 1
+
+
+@pytest.mark.parametrize(argnames="capacity", argvalues=[-10, -1, 0])
+def test_with_zero_capacity(capacity: int) -> None:
+    cache: LRUCache[bytes, int] = LRUCache(capacity=capacity)
+    cache.put(b"0", 1)
+    assert cache.get(b"0") is None
+    assert len(cache.cache) == 0
+
+
+@pytest.mark.parametrize(argnames="capacity", argvalues=[-10, -1, 0, 1, 5, 10])
+def test_get_capacity(capacity: int) -> None:
+    cache: LRUCache[object, object] = LRUCache(capacity=capacity)
+    assert cache.get_capacity() == capacity

chia/_tests/core/util/test_streamable.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import io
 import re
 from dataclasses import dataclass, field, fields
+from enum import Enum
 from typing import Any, Callable, ClassVar, Optional, get_type_hints
 
 import pytest
@@ -27,6 +28,7 @@ from chia.util.streamable import (
     function_to_parse_one_item,
     function_to_stream_one_item,
     is_type_Dict,
+    is_type_Enum,
     is_type_List,
     is_type_SpecificOptional,
     is_type_Tuple,
@@ -39,6 +41,7 @@ from chia.util.streamable import (
     parse_uint32,
     recurse_jsonify,
     streamable,
+    streamable_enum,
     streamable_from_dict,
     write_uint32,
 )
@@ -372,10 +375,29 @@ def test_not_lists() -> None:
 
 def test_basic_optional() -> None:
     assert is_type_SpecificOptional(Optional[int])
-    assert is_type_SpecificOptional(Optional[Optional[int]])
+    assert is_type_SpecificOptional(Optional[int])
     assert not is_type_SpecificOptional(list[int])
 
 
+class BasicEnum(Enum):
+    A = 1
+    B = 2
+
+
+def test_basic_enum() -> None:
+    assert is_type_Enum(BasicEnum)
+    assert not is_type_Enum(list[int])
+
+
+def test_enum_needs_proxy() -> None:
+    with pytest.raises(UnsupportedType):
+
+        @streamable
+        @dataclass(frozen=True)
+        class EnumStreamable(Streamable):
+            enum: BasicEnum
+
+
 @streamable
 @dataclass(frozen=True)
 class PostInitTestClassBasic(Streamable):
@@ -398,8 +420,8 @@ class PostInitTestClassBad(Streamable):
 class PostInitTestClassOptional(Streamable):
     a: Optional[uint8]
     b: Optional[uint8]
-    c: Optional[Optional[uint8]]
-    d: Optional[Optional[uint8]]
+    c: Optional[uint8]
+    d: Optional[uint8]
 
 
 @streamable
@@ -423,6 +445,25 @@ class PostInitTestClassDict(Streamable):
     b: dict[bytes32, dict[uint8, str]]
 
 
+@streamable_enum(uint32)
+class IntegerEnum(Enum):
+    A = 1
+    B = 2
+
+
+@streamable_enum(str)
+class StringEnum(Enum):
+    A = "foo"
+    B = "bar"
+
+
+@streamable
+@dataclass(frozen=True)
+class PostInitTestClassEnum(Streamable):
+    a: IntegerEnum
+    b: StringEnum
+
+
 @pytest.mark.parametrize(
     "test_class, args",
     [
@@ -433,6 +474,7 @@ class PostInitTestClassDict(Streamable):
         (PostInitTestClassTuple, ((1, "test"), ((200, "test_2"), b"\xba" * 32))),
         (PostInitTestClassDict, ({1: "bar"}, {bytes32.zeros: {1: "bar"}})),
         (PostInitTestClassOptional, (12, None, 13, None)),
+        (PostInitTestClassEnum, (IntegerEnum.A, StringEnum.B)),
     ],
 )
 def test_post_init_valid(test_class: type[Any], args: tuple[Any, ...]) -> None:
@@ -453,6 +495,8 @@ def test_post_init_valid(test_class: type[Any], args: tuple[Any, ...]) -> None:
             return validate_item_type(key_type, next(iter(item.keys()))) and validate_item_type(
                 value_type, next(iter(item.values()))
             )
+        if is_type_Enum(type_in):
+            return validate_item_type(type_in._streamable_proxy, type_in._streamable_proxy(item.value))  # type: ignore[attr-defined]
         return isinstance(item, type_in)
 
     test_object = test_class(*args)
@@ -497,6 +541,8 @@ def test_basic() -> None:
         f: Optional[uint32]
         g: tuple[uint32, str, bytes]
         h: dict[uint32, str]
+        i: IntegerEnum
+        j: StringEnum
 
     # we want to test invalid here, hence the ignore.
     a = TestClass(
@@ -508,6 +554,8 @@ def test_basic() -> None:
         None,
         (uint32(383), "hello", b"goodbye"),
         {uint32(1): "foo"},
+        IntegerEnum.A,
+        StringEnum.B,
     )
 
     b: bytes = bytes(a)
@@ -619,10 +667,21 @@ def test_ambiguous_deserialization_int() -> None:
         a: uint32
 
     # Does not have the required uint size
-    with pytest.raises(ValueError):
+    with pytest.raises(ValueError, match=re.escape("uint32.from_bytes() requires 4 bytes but got: 2")):
         TestClassUint.from_bytes(b"\x00\x00")
 
 
+def test_ambiguous_deserialization_int_enum() -> None:
+    @streamable
+    @dataclass(frozen=True)
+    class TestClassIntegerEnum(Streamable):
+        a: IntegerEnum
+
+    # passed bytes are incorrect size for serialization proxy
+    with pytest.raises(ValueError, match=re.escape("uint32.from_bytes() requires 4 bytes but got: 2")):
+        TestClassIntegerEnum.from_bytes(b"\x00\x00")
+
+
 def test_ambiguous_deserialization_list() -> None:
     @streamable
     @dataclass(frozen=True)
@@ -656,6 +715,28 @@ def test_ambiguous_deserialization_str() -> None:
         TestClassStr.from_bytes(bytes([0, 0, 100, 24, 52]))
 
 
+def test_ambiguous_deserialization_str_enum() -> None:
+    @streamable
+    @dataclass(frozen=True)
+    class TestClassStr(Streamable):
+        a: StringEnum
+
+    # passed bytes are incorrect size for serialization proxy
+    with pytest.raises(AssertionError):
+        TestClassStr.from_bytes(bytes([0, 0, 100, 24, 52]))
+
+
+def test_deserialization_to_invalid_enum() -> None:
+    @streamable
+    @dataclass(frozen=True)
+    class TestClassStr(Streamable):
+        a: StringEnum
+
+    # encodes the string "baz" which is not a valid value for StringEnum
+    with pytest.raises(ValueError, match=re.escape("'baz' is not a valid StringEnum")):
+        TestClassStr.from_bytes(bytes([0, 0, 0, 3, 98, 97, 122]))
+
+
 def test_ambiguous_deserialization_bytes() -> None:
     @streamable
     @dataclass(frozen=True)