chia-blockchain 2.5.2rc1__py3-none-any.whl → 2.5.3rc1__py3-none-any.whl

chia/rpc/wallet_rpc_client.py

@@ -3,8 +3,12 @@ from __future__ import annotations
 from collections.abc import Sequence
 from typing import Any, Optional, Union, cast
 
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint16, uint32, uint64
+
 from chia.data_layer.data_layer_util import DLProof, VerifyProofResponse
-from chia.data_layer.data_layer_wallet import Mirror, SingletonRecord
+from chia.data_layer.data_layer_wallet import Mirror
+from chia.data_layer.singleton_record import SingletonRecord
 from chia.pools.pool_wallet_info import PoolWalletInfo
 from chia.rpc.rpc_client import RpcClient
 from chia.rpc.wallet_request_types import (
@@ -19,16 +23,8 @@ from chia.rpc.wallet_request_types import (
     CheckDeleteKeyResponse,
     CombineCoins,
     CombineCoinsResponse,
-    CreateNewDAOWalletResponse,
     CreateOfferForIDsResponse,
     CreateSignedTransactionsResponse,
-    DAOAddFundsToTreasuryResponse,
-    DAOCloseProposalResponse,
-    DAOCreateProposalResponse,
-    DAOExitLockupResponse,
-    DAOFreeCoinsFromFinishedProposalsResponse,
-    DAOSendToLockupResponse,
-    DAOVoteOnProposalResponse,
     DeleteKey,
     DIDGetCurrentCoinInfo,
     DIDGetCurrentCoinInfoResponse,
@@ -103,9 +99,7 @@ from chia.rpc.wallet_request_types import (
 )
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
-from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.coin_record import CoinRecord
-from chia.util.ints import uint16, uint32, uint64
 from chia.wallet.conditions import Condition, ConditionValidTimes, conditions_to_json_dicts
 from chia.wallet.puzzles.clawback.metadata import AutoClaimSettings
 from chia.wallet.trade_record import TradeRecord
@@ -1426,248 +1420,6 @@ class WalletRpcClient(RpcClient):
             await self.fetch("get_transaction_memo", {**request.to_json_dict()})
         )
 
-    # DAOs
-    async def create_new_dao_wallet(
-        self,
-        mode: str,
-        tx_config: TXConfig,
-        dao_rules: Optional[dict[str, uint64]] = None,
-        amount_of_cats: Optional[uint64] = None,
-        treasury_id: Optional[bytes32] = None,
-        filter_amount: uint64 = uint64(1),
-        name: Optional[str] = None,
-        fee: uint64 = uint64(0),
-        fee_for_cat: uint64 = uint64(0),
-        extra_conditions: tuple[Condition, ...] = tuple(),
-        push: bool = True,
-        timelock_info: ConditionValidTimes = ConditionValidTimes(),
-    ) -> CreateNewDAOWalletResponse:
-        request: dict[str, Any] = {
-            "wallet_type": "dao_wallet",
-            "mode": mode,
-            "treasury_id": treasury_id.hex() if treasury_id is not None else treasury_id,
-            "dao_rules": dao_rules,
-            "amount_of_cats": amount_of_cats,
-            "filter_amount": filter_amount,
-            "name": name,
-            "fee": fee,
-            "fee_for_cat": fee_for_cat,
-            "extra_conditions": list(extra_conditions),
-            "push": push,
-            **tx_config.to_json_dict(),
-            **timelock_info.to_json_dict(),
-        }
-        response = await self.fetch("create_new_wallet", request)
-        return json_deserialize_with_clvm_streamable(response, CreateNewDAOWalletResponse)
-
-    async def dao_get_treasury_id(self, wallet_id: int) -> dict[str, Any]:
-        request = {"wallet_id": wallet_id}
-        response = await self.fetch("dao_get_treasury_id", request)
-        return response
-
-    async def dao_get_rules(self, wallet_id: int) -> dict[str, Any]:
-        request = {"wallet_id": wallet_id}
-        response = await self.fetch("dao_get_rules", request)
-        return response
-
-    async def dao_create_proposal(
-        self,
-        wallet_id: int,
-        proposal_type: str,
-        tx_config: TXConfig,
-        additions: Optional[list[dict[str, Any]]] = None,
-        amount: Optional[uint64] = None,
-        inner_address: Optional[str] = None,
-        asset_id: Optional[str] = None,
-        cat_target_address: Optional[str] = None,
-        vote_amount: Optional[int] = None,
-        new_dao_rules: Optional[dict[str, Optional[uint64]]] = None,
-        fee: uint64 = uint64(0),
-        extra_conditions: tuple[Condition, ...] = tuple(),
-        push: bool = True,
-        timelock_info: ConditionValidTimes = ConditionValidTimes(),
-    ) -> DAOCreateProposalResponse:
-        request: dict[str, Any] = {
-            "wallet_id": wallet_id,
-            "proposal_type": proposal_type,
-            "additions": additions,
-            "amount": amount,
-            "inner_address": inner_address,
-            "asset_id": asset_id,
-            "cat_target_address": cat_target_address,
-            "vote_amount": vote_amount,
-            "new_dao_rules": new_dao_rules,
-            "fee": fee,
-            "extra_conditions": list(extra_conditions),
-            **tx_config.to_json_dict(),
-            **timelock_info.to_json_dict(),
-        }
-
-        response = await self.fetch("dao_create_proposal", request)
-        return json_deserialize_with_clvm_streamable(response, DAOCreateProposalResponse)
-
-    async def dao_get_proposal_state(self, wallet_id: int, proposal_id: str) -> dict[str, Any]:
-        request = {"wallet_id": wallet_id, "proposal_id": proposal_id}
-        response = await self.fetch("dao_get_proposal_state", request)
-        return response
-
-    async def dao_parse_proposal(self, wallet_id: int, proposal_id: str) -> dict[str, Any]:
-        request = {"wallet_id": wallet_id, "proposal_id": proposal_id}
-        response = await self.fetch("dao_parse_proposal", request)
-        return response
-
-    async def dao_vote_on_proposal(
-        self,
-        wallet_id: int,
-        proposal_id: str,
-        vote_amount: uint64,
-        tx_config: TXConfig,
-        is_yes_vote: bool = True,
-        fee: uint64 = uint64(0),
-        extra_conditions: tuple[Condition, ...] = tuple(),
-        push: bool = True,
-        timelock_info: ConditionValidTimes = ConditionValidTimes(),
-    ) -> DAOVoteOnProposalResponse:
-        request: dict[str, Any] = {
-            "wallet_id": wallet_id,
-            "proposal_id": proposal_id,
-            "vote_amount": vote_amount,
-            "is_yes_vote": is_yes_vote,
-            "fee": fee,
-            "extra_conditions": list(extra_conditions),
-            "push": push,
-            **tx_config.to_json_dict(),
-            **timelock_info.to_json_dict(),
-        }
-        response = await self.fetch("dao_vote_on_proposal", request)
-        return json_deserialize_with_clvm_streamable(response, DAOVoteOnProposalResponse)
-
-    async def dao_get_proposals(self, wallet_id: int, include_closed: bool = True) -> dict[str, Any]:
-        request = {"wallet_id": wallet_id, "include_closed": include_closed}
-        response = await self.fetch("dao_get_proposals", request)
-        return response
-
-    async def dao_close_proposal(
-        self,
-        wallet_id: int,
-        proposal_id: str,
-        tx_config: TXConfig,
-        self_destruct: Optional[bool] = None,
-        fee: uint64 = uint64(0),
-        extra_conditions: tuple[Condition, ...] = tuple(),
-        push: bool = True,
-        timelock_info: ConditionValidTimes = ConditionValidTimes(),
-    ) -> DAOCloseProposalResponse:
-        request: dict[str, Any] = {
-            "wallet_id": wallet_id,
-            "proposal_id": proposal_id,
-            "self_destruct": self_destruct,
-            "fee": fee,
-            "extra_conditions": list(extra_conditions),
-            "push": push,
-            **tx_config.to_json_dict(),
-            **timelock_info.to_json_dict(),
-        }
-        response = await self.fetch("dao_close_proposal", request)
-        return json_deserialize_with_clvm_streamable(response, DAOCloseProposalResponse)
-
-    async def dao_free_coins_from_finished_proposals(
-        self,
-        wallet_id: int,
-        tx_config: TXConfig,
-        fee: uint64 = uint64(0),
-        extra_conditions: tuple[Condition, ...] = tuple(),
-        push: bool = True,
-        timelock_info: ConditionValidTimes = ConditionValidTimes(),
-    ) -> DAOFreeCoinsFromFinishedProposalsResponse:
-        request: dict[str, Any] = {
-            "wallet_id": wallet_id,
-            "fee": fee,
-            "extra_conditions": list(extra_conditions),
-            **tx_config.to_json_dict(),
-            **timelock_info.to_json_dict(),
-        }
-        response = await self.fetch("dao_free_coins_from_finished_proposals", request)
-        return json_deserialize_with_clvm_streamable(response, DAOFreeCoinsFromFinishedProposalsResponse)
-
-    async def dao_get_treasury_balance(self, wallet_id: int) -> dict[str, Any]:
-        request = {"wallet_id": wallet_id}
-        response = await self.fetch("dao_get_treasury_balance", request)
-        return response
-
-    async def dao_add_funds_to_treasury(
-        self,
-        wallet_id: int,
-        funding_wallet_id: int,
-        amount: uint64,
-        tx_config: TXConfig,
-        fee: uint64 = uint64(0),
-        extra_conditions: tuple[Condition, ...] = tuple(),
-        push: bool = True,
-        timelock_info: ConditionValidTimes = ConditionValidTimes(),
-    ) -> DAOAddFundsToTreasuryResponse:
-        request: dict[str, Any] = {
-            "wallet_id": wallet_id,
-            "funding_wallet_id": funding_wallet_id,
-            "amount": amount,
-            "fee": fee,
-            "extra_conditions": list(extra_conditions),
-            "push": push,
-            **tx_config.to_json_dict(),
-            **timelock_info.to_json_dict(),
-        }
-        response = await self.fetch("dao_add_funds_to_treasury", request)
-        return json_deserialize_with_clvm_streamable(response, DAOAddFundsToTreasuryResponse)
-
-    async def dao_send_to_lockup(
-        self,
-        wallet_id: int,
-        amount: uint64,
-        tx_config: TXConfig,
-        fee: uint64 = uint64(0),
-        extra_conditions: tuple[Condition, ...] = tuple(),
-        push: bool = True,
-        timelock_info: ConditionValidTimes = ConditionValidTimes(),
-    ) -> DAOSendToLockupResponse:
-        request: dict[str, Any] = {
-            "wallet_id": wallet_id,
-            "amount": amount,
-            "fee": fee,
-            "extra_conditions": list(extra_conditions),
-            "push": push,
-            **tx_config.to_json_dict(),
-            **timelock_info.to_json_dict(),
-        }
-        response = await self.fetch("dao_send_to_lockup", request)
-        return json_deserialize_with_clvm_streamable(response, DAOSendToLockupResponse)
-
-    async def dao_exit_lockup(
-        self,
-        wallet_id: int,
-        tx_config: TXConfig,
-        coins: Optional[list[dict[str, Any]]] = None,
-        fee: uint64 = uint64(0),
-        extra_conditions: tuple[Condition, ...] = tuple(),
-        push: bool = True,
-        timelock_info: ConditionValidTimes = ConditionValidTimes(),
-    ) -> DAOExitLockupResponse:
-        request: dict[str, Any] = {
-            "wallet_id": wallet_id,
-            "coins": coins,
-            "fee": fee,
-            "extra_conditions": list(extra_conditions),
-            "push": push,
-            **tx_config.to_json_dict(),
-            **timelock_info.to_json_dict(),
-        }
-        response = await self.fetch("dao_exit_lockup", request)
-        return json_deserialize_with_clvm_streamable(response, DAOExitLockupResponse)
-
-    async def dao_adjust_filter_level(self, wallet_id: int, filter_level: int) -> dict[str, Any]:
-        request = {"wallet_id": wallet_id, "filter_level": filter_level}
-        response = await self.fetch("dao_adjust_filter_level", request)
-        return response
-
     async def vc_mint(
         self,
         request: VCMint,

chia/seeder/crawl_store.py

@@ -8,9 +8,9 @@ from dataclasses import dataclass, field, replace
 from datetime import datetime, timedelta
 
 import aiosqlite
+from chia_rs.sized_ints import uint32, uint64
 
 from chia.seeder.peer_record import PeerRecord, PeerReliability
-from chia.util.ints import uint32, uint64
 
 log = logging.getLogger(__name__)
 

chia/seeder/crawler.py

@@ -13,8 +13,9 @@ from pathlib import Path
 from typing import TYPE_CHECKING, Any, Callable, ClassVar, Optional, cast
 
 import aiosqlite
+from chia_rs import ConsensusConstants
+from chia_rs.sized_ints import uint32, uint64
 
-from chia.consensus.constants import ConsensusConstants
 from chia.full_node.full_node_api import FullNodeAPI
 from chia.protocols import full_node_protocol
 from chia.protocols.full_node_protocol import RespondPeers
@@ -26,7 +27,6 @@ from chia.server.server import ChiaServer
 from chia.server.ws_connection import WSChiaConnection
 from chia.types.peer_info import PeerInfo
 from chia.util.chia_version import chia_short_version
-from chia.util.ints import uint32, uint64
 from chia.util.network import resolve
 from chia.util.path import path_from_root
 from chia.util.task_referencer import create_referenced_task

chia/seeder/peer_record.py

@@ -4,7 +4,8 @@ import math
 import time
 from dataclasses import dataclass
 
-from chia.util.ints import uint32, uint64
+from chia_rs.sized_ints import uint32, uint64
+
 from chia.util.streamable import Streamable, streamable
 
 

chia/seeder/start_crawler.py

@@ -6,8 +6,10 @@ import sys
 from multiprocessing import freeze_support
 from typing import Any, Optional
 
+from chia_rs import ConsensusConstants
+
 from chia.apis import ApiProtocolRegistry
-from chia.consensus.constants import ConsensusConstants, replace_str_to_bytes
+from chia.consensus.constants import replace_str_to_bytes
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.rpc.crawler_rpc_api import CrawlerRpcApi
 from chia.seeder.crawler import Crawler

chia/server/address_manager.py

@@ -8,9 +8,10 @@ from random import choice, randrange
 from secrets import randbits
 from typing import Optional
 
+from chia_rs.sized_ints import uint16, uint64
+
 from chia.types.peer_info import PeerInfo, TimestampedPeerInfo
 from chia.util.hash import std_hash
-from chia.util.ints import uint16, uint64
 
 TRIED_BUCKETS_PER_GROUP = 8
 NEW_BUCKETS_PER_SOURCE_GROUP = 64

chia/server/address_manager_store.py

@@ -8,6 +8,7 @@ from timeit import default_timer as timer
 from typing import Any, Optional
 
 import aiofiles
+from chia_rs.sized_ints import uint64
 
 from chia.server.address_manager import (
     BUCKET_SIZE,
@@ -17,7 +18,6 @@ from chia.server.address_manager import (
     ExtendedPeerInfo,
 )
 from chia.util.files import write_file_async
-from chia.util.ints import uint64
 from chia.util.streamable import Streamable, streamable
 
 log = logging.getLogger(__name__)

chia/server/capabilities.py

@@ -2,8 +2,9 @@ from __future__ import annotations
 
 from collections.abc import Iterable
 
+from chia_rs.sized_ints import uint16
+
 from chia.protocols.shared_protocol import Capability
-from chia.util.ints import uint16
 
 
 def known_active_capabilities(values: Iterable[tuple[uint16, str]]) -> list[Capability]:

chia/server/introducer_peers.py

@@ -5,8 +5,9 @@ import time
 from dataclasses import dataclass
 from typing import Optional
 
+from chia_rs.sized_ints import uint16, uint64
+
 from chia.types.peer_info import PeerInfo
-from chia.util.ints import uint16, uint64
 
 
 @dataclass(frozen=False)

chia/server/node_discovery.py

@@ -12,6 +12,7 @@ from secrets import randbits
 from typing import Any, Optional
 
 import dns.asyncresolver
+from chia_rs.sized_ints import uint16, uint64
 
 from chia.protocols.full_node_protocol import RequestPeers, RespondPeers
 from chia.protocols.introducer_protocol import RequestPeersIntroducer
@@ -23,7 +24,6 @@ from chia.server.server import ChiaServer
 from chia.server.ws_connection import WSChiaConnection
 from chia.types.peer_info import PeerInfo, TimestampedPeerInfo, UnresolvedPeerInfo
 from chia.util.hash import std_hash
-from chia.util.ints import uint16, uint64
 from chia.util.ip_address import IPAddress
 from chia.util.network import resolve
 from chia.util.safe_cancel_task import cancel_task_safe

chia/server/outbound_message.py

@@ -4,8 +4,9 @@ from dataclasses import dataclass
 from enum import IntEnum
 from typing import Optional, SupportsBytes, Union
 
+from chia_rs.sized_ints import uint8, uint16
+
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
-from chia.util.ints import uint8, uint16
 from chia.util.streamable import Streamable, streamable
 
 

chia/server/server.py

@@ -20,6 +20,8 @@ from aiohttp import (
     client_exceptions,
     web,
 )
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint16
 from cryptography import x509
 from cryptography.hazmat.backends import default_backend
 from cryptography.hazmat.primitives import hashes, serialization
@@ -33,10 +35,8 @@ from chia.server.introducer_peers import IntroducerPeers
 from chia.server.outbound_message import Message, NodeType
 from chia.server.ssl_context import private_ssl_paths, public_ssl_paths
 from chia.server.ws_connection import ConnectionCallback, WSChiaConnection
-from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.peer_info import PeerInfo
 from chia.util.errors import Err, ProtocolError
-from chia.util.ints import uint16
 from chia.util.network import WebServer, is_in_network, is_localhost, is_trusted_peer
 from chia.util.ssl_check import verify_ssl_certs_and_keys
 from chia.util.streamable import Streamable

chia/server/start_data_layer.py

@@ -6,6 +6,8 @@ import pathlib
 import sys
 from typing import Any, Optional, cast
 
+from chia_rs.sized_ints import uint16
+
 from chia.apis import ApiProtocolRegistry
 from chia.data_layer.data_layer import DataLayer
 from chia.data_layer.data_layer_api import DataLayerAPI
@@ -21,7 +23,6 @@ from chia.types.aliases import DataLayerService, WalletService
 from chia.util.chia_logging import initialize_logging
 from chia.util.config import load_config, load_config_cli
 from chia.util.default_root import resolve_root_path
-from chia.util.ints import uint16
 from chia.util.task_timing import maybe_manage_task_instrumentation
 
 # See: https://bugs.python.org/issue29288

chia/server/start_farmer.py

@@ -5,8 +5,10 @@ import pathlib
 import sys
 from typing import Any, Optional
 
+from chia_rs import ConsensusConstants
+
 from chia.apis import ApiProtocolRegistry
-from chia.consensus.constants import ConsensusConstants, replace_str_to_bytes
+from chia.consensus.constants import replace_str_to_bytes
 from chia.consensus.default_constants import DEFAULT_CONSTANTS, update_testnet_overrides
 from chia.farmer.farmer import Farmer
 from chia.farmer.farmer_api import FarmerAPI

chia/server/start_full_node.py

@@ -6,8 +6,11 @@ import sys
 from multiprocessing import freeze_support
 from typing import Any, Optional
 
+from chia_rs import ConsensusConstants
+from chia_rs.sized_ints import uint16
+
 from chia.apis import ApiProtocolRegistry
-from chia.consensus.constants import ConsensusConstants, replace_str_to_bytes
+from chia.consensus.constants import replace_str_to_bytes
 from chia.consensus.default_constants import DEFAULT_CONSTANTS, update_testnet_overrides
 from chia.full_node.full_node import FullNode
 from chia.full_node.full_node_api import FullNodeAPI
@@ -19,7 +22,6 @@ from chia.types.aliases import FullNodeService
 from chia.util.chia_logging import initialize_service_logging
 from chia.util.config import get_unresolved_peer_infos, load_config, load_config_cli
 from chia.util.default_root import resolve_root_path
-from chia.util.ints import uint16
 from chia.util.task_timing import maybe_manage_task_instrumentation
 
 # See: https://bugs.python.org/issue29288

chia/server/start_harvester.py

@@ -5,8 +5,10 @@ import pathlib
 import sys
 from typing import Any, Optional
 
+from chia_rs import ConsensusConstants
+
 from chia.apis import ApiProtocolRegistry
-from chia.consensus.constants import ConsensusConstants, replace_str_to_bytes
+from chia.consensus.constants import replace_str_to_bytes
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.harvester.harvester import Harvester
 from chia.harvester.harvester_api import HarvesterAPI

chia/server/start_introducer.py

@@ -36,7 +36,18 @@ def create_introducer_service(
     if advertised_port is None:
         advertised_port = service_config["port"]
 
-    node = Introducer(service_config["max_peers_to_send"], service_config["recent_peer_threshold"])
+    try:
+        default_port = service_config["network_overrides"]["config"][network_id]["default_full_node_port"]
+    except KeyError:
+        raise Exception(f"Specify default_full_node_port for network {network_id}")
+
+    dns_servers = service_config.get("dns_servers", [])
+    if dns_servers == [] and network_id == "mainnet":
+        dns_servers.append("dns-introducer.chia.net")
+
+    node = Introducer(
+        service_config["max_peers_to_send"], service_config["recent_peer_threshold"], default_port, dns_servers
+    )
     peer_api = IntroducerAPI(node)
 
     return Service(

chia/server/start_service.py

@@ -11,6 +11,8 @@ from pathlib import Path
 from types import FrameType
 from typing import Any, Callable, Generic, Optional, TypeVar, cast
 
+from chia_rs.sized_ints import uint16
+
 from chia.daemon.server import service_launch_lock_path
 from chia.protocols.shared_protocol import default_capabilities
 from chia.rpc.rpc_server import RpcApiProtocol, RpcServer, RpcServiceProtocol, start_rpc_server
@@ -24,7 +26,6 @@ from chia.server.upnp import UPnP
 from chia.server.ws_connection import WSChiaConnection
 from chia.types.peer_info import PeerInfo, UnresolvedPeerInfo
 from chia.util.chia_version import chia_short_version
-from chia.util.ints import uint16
 from chia.util.lock import Lockfile, LockfileError
 from chia.util.log_exceptions import log_exceptions
 from chia.util.network import resolve

chia/server/start_timelord.py

@@ -5,8 +5,10 @@ import pathlib
 import sys
 from typing import Any, Optional
 
+from chia_rs import ConsensusConstants
+
 from chia.apis import ApiProtocolRegistry
-from chia.consensus.constants import ConsensusConstants, replace_str_to_bytes
+from chia.consensus.constants import replace_str_to_bytes
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.rpc.timelord_rpc_api import TimelordRpcApi
 from chia.server.outbound_message import NodeType

chia/server/start_wallet.py

@@ -6,8 +6,10 @@ import sys
 from multiprocessing import freeze_support
 from typing import Any, Optional
 
+from chia_rs import ConsensusConstants
+
 from chia.apis import ApiProtocolRegistry
-from chia.consensus.constants import ConsensusConstants, replace_str_to_bytes
+from chia.consensus.constants import replace_str_to_bytes
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.rpc.wallet_rpc_api import WalletRpcApi
 from chia.server.outbound_message import NodeType

chia/server/upnp.py

@@ -16,8 +16,7 @@ try:
     import miniupnpc
 except ImportError:
     log.info(
-        "importing miniupnpc failed."
-        " This is not required to run chia, it allows incoming connections from other peers."
+        "importing miniupnpc failed. This is not required to run chia, it allows incoming connections from other peers."
     )
     miniupnpc = None
 

chia/server/ws_connection.py

@@ -12,6 +12,8 @@ from typing import Any, Callable, Optional, Union
 from aiohttp import ClientSession, WebSocketError, WSCloseCode, WSMessage, WSMsgType
 from aiohttp.client import ClientWebSocketResponse
 from aiohttp.web import WebSocketResponse
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import int16, uint8, uint16
 from packaging.version import Version
 from typing_extensions import Protocol, final
 
@@ -29,10 +31,8 @@ from chia.server.api_protocol import ApiMetadata, ApiProtocol
 from chia.server.capabilities import known_active_capabilities
 from chia.server.outbound_message import Message, NodeType, make_msg
 from chia.server.rate_limits import RateLimiter
-from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.peer_info import PeerInfo
 from chia.util.errors import ApiError, ConsensusError, Err, ProtocolError, TimestampError
-from chia.util.ints import int16, uint8, uint16
 from chia.util.log_exceptions import log_exceptions
 
 # Each message is prepended with LENGTH_BYTES bytes specifying the length
@@ -463,8 +463,7 @@ class WSChiaConnection:
 
             response: Optional[Message] = await asyncio.wait_for(wrapped_coroutine(), timeout=timeout)
             self.log.debug(
-                f"Time taken to process {message_type} from {self.peer_node_id} is "
-                f"{time.time() - start_time} seconds"
+                f"Time taken to process {message_type} from {self.peer_node_id} is {time.time() - start_time} seconds"
             )
 
             if response is not None:

chia/simulator/add_blocks_in_batches.py

@@ -2,14 +2,16 @@ from __future__ import annotations
 
 from typing import Optional
 
+from chia_rs.sized_ints import uint32
+
 from chia.consensus.block_body_validation import ForkInfo
 from chia.consensus.difficulty_adjustment import get_next_sub_slot_iters_and_difficulty
 from chia.full_node.full_node import FullNode, PeakPostProcessingResult
 from chia.types.full_block import FullBlock
 from chia.types.peer_info import PeerInfo
 from chia.types.validation_state import ValidationState
+from chia.util.augmented_chain import AugmentedBlockchain
 from chia.util.batches import to_batches
-from chia.util.ints import uint32
 
 
 async def add_blocks_in_batches(
@@ -34,14 +36,14 @@ async def add_blocks_in_batches(
     fork_info = ForkInfo(fork_height, blocks[0].height - 1, peak_hash)
 
     vs = ValidationState(ssi, diff, None)
-
+    blockchain = AugmentedBlockchain(full_node.blockchain)
     for block_batch in to_batches(blocks, 64):
         b = block_batch.entries[0]
         if (b.height % 128) == 0:
             print(f"main chain: {b.height:4} weight: {b.weight}")
         # vs is updated by the call to add_block_batch()
         success, state_change_summary = await full_node.add_block_batch(
-            block_batch.entries, PeerInfo("0.0.0.0", 0), fork_info, vs
+            block_batch.entries, PeerInfo("0.0.0.0", 0), fork_info, vs, blockchain
         )
         assert success is True
         if state_change_summary is not None: