chia-blockchain 2.5.0rc2__py3-none-any.whl → 2.5.1rc2__py3-none-any.whl

chia/wallet/wallet_node_api.py

@@ -1,19 +1,26 @@
 from __future__ import annotations
 
 import logging
+from typing import TYPE_CHECKING, ClassVar, cast
 
 from chia.protocols import full_node_protocol, introducer_protocol, wallet_protocol
+from chia.server.api_protocol import ApiMetadata
 from chia.server.outbound_message import NodeType
 from chia.server.ws_connection import WSChiaConnection
 from chia.types.mempool_inclusion_status import MempoolInclusionStatus
-from chia.util.api_decorators import api_request
 from chia.util.errors import Err
 from chia.wallet.wallet_node import WalletNode
 
 
 class WalletNodeAPI:
+    if TYPE_CHECKING:
+        from chia.server.api_protocol import ApiProtocol
+
+        _protocol_check: ClassVar[ApiProtocol] = cast("WalletNodeAPI", None)
+
     log: logging.Logger
     wallet_node: WalletNode
+    metadata: ClassVar[ApiMetadata] = ApiMetadata()
 
     def __init__(self, wallet_node) -> None:
         self.log = logging.getLogger(__name__)
@@ -22,7 +29,7 @@ class WalletNodeAPI:
     def ready(self) -> bool:
         return self.wallet_node.logged_in
 
-    @api_request(peer_required=True)
+    @metadata.request(peer_required=True)
     async def respond_removals(self, response: wallet_protocol.RespondRemovals, peer: WSChiaConnection):
         pass
 
@@ -32,14 +39,14 @@ class WalletNodeAPI:
         """
         pass
 
-    @api_request()
+    @metadata.request()
     async def reject_additions_request(self, response: wallet_protocol.RejectAdditionsRequest):
         """
         The full node has rejected our request for additions.
         """
         pass
 
-    @api_request(peer_required=True, execute_task=True)
+    @metadata.request(peer_required=True, execute_task=True)
     async def new_peak_wallet(self, peak: wallet_protocol.NewPeakWallet, peer: WSChiaConnection):
         """
         The full node sent as a new peak
@@ -69,26 +76,26 @@ class WalletNodeAPI:
 
         await self.wallet_node.new_peak_queue.new_peak_wallet(peak, peer)
 
-    @api_request()
+    @metadata.request()
     async def reject_header_request(self, response: wallet_protocol.RejectHeaderRequest):
         """
         The full node has rejected our request for a header.
         """
         pass
 
-    @api_request()
+    @metadata.request()
     async def respond_block_header(self, response: wallet_protocol.RespondBlockHeader):
         pass
 
-    @api_request(peer_required=True)
+    @metadata.request(peer_required=True)
     async def respond_additions(self, response: wallet_protocol.RespondAdditions, peer: WSChiaConnection):
         pass
 
-    @api_request()
+    @metadata.request()
     async def respond_proof_of_weight(self, response: full_node_protocol.RespondProofOfWeight):
         pass
 
-    @api_request(peer_required=True)
+    @metadata.request(peer_required=True)
     async def transaction_ack(self, ack: wallet_protocol.TransactionAck, peer: WSChiaConnection):
         """
         This is an ack for our previous SendTransaction call. This removes the transaction from
@@ -128,7 +135,7 @@ class WalletNodeAPI:
             else:
                 await wallet_state_manager.remove_from_queue(ack.txid, name, status, None)
 
-    @api_request(peer_required=True)
+    @metadata.request(peer_required=True)
     async def respond_peers_introducer(
         self, request: introducer_protocol.RespondPeersIntroducer, peer: WSChiaConnection
     ):
@@ -138,7 +145,7 @@ class WalletNodeAPI:
         if peer is not None and peer.connection_type is NodeType.INTRODUCER:
             await peer.close()
 
-    @api_request(peer_required=True)
+    @metadata.request(peer_required=True)
     async def respond_peers(self, request: full_node_protocol.RespondPeers, peer: WSChiaConnection):
         if self.wallet_node.wallet_peers is None:
             return None
@@ -148,54 +155,53 @@ class WalletNodeAPI:
 
         return None
 
-    @api_request()
+    @metadata.request()
     async def respond_puzzle_solution(self, request: wallet_protocol.RespondPuzzleSolution):
         self.log.error("Unexpected message `respond_puzzle_solution`. Peer might be slow to respond")
-        return None
 
-    @api_request()
+    @metadata.request()
     async def reject_puzzle_solution(self, request: wallet_protocol.RejectPuzzleSolution):
         self.log.warning(f"Reject puzzle solution: {request}")
 
-    @api_request()
+    @metadata.request()
     async def respond_header_blocks(self, request: wallet_protocol.RespondHeaderBlocks):
         pass
 
-    @api_request()
+    @metadata.request()
     async def respond_block_headers(self, request: wallet_protocol.RespondBlockHeaders):
         pass
 
-    @api_request()
+    @metadata.request()
     async def reject_header_blocks(self, request: wallet_protocol.RejectHeaderBlocks):
         self.log.warning(f"Reject header blocks: {request}")
 
-    @api_request()
+    @metadata.request()
     async def reject_block_headers(self, request: wallet_protocol.RejectBlockHeaders):
         pass
 
-    @api_request(peer_required=True, execute_task=True)
+    @metadata.request(peer_required=True, execute_task=True)
     async def coin_state_update(self, request: wallet_protocol.CoinStateUpdate, peer: WSChiaConnection):
         await self.wallet_node.new_peak_queue.full_node_state_updated(request, peer)
 
     # TODO: Review this hinting issue around this rust type not being a Streamable
     #       subclass, as you might expect it wouldn't be.  Maybe we can get the
-    #       protocol working right back at the api_request definition.
-    @api_request()  # type: ignore[type-var]
-    async def respond_to_ph_update(self, request: wallet_protocol.RespondToPhUpdates):
+    #       protocol working right back at the api.request definition.
+    @metadata.request()  # type: ignore[type-var]
+    async def respond_to_ph_updates(self, request: wallet_protocol.RespondToPhUpdates):
         pass
 
-    @api_request()
-    async def respond_to_coin_update(self, request: wallet_protocol.RespondToCoinUpdates):
+    @metadata.request()
+    async def respond_to_coin_updates(self, request: wallet_protocol.RespondToCoinUpdates):
         pass
 
-    @api_request()
+    @metadata.request()
     async def respond_children(self, request: wallet_protocol.RespondChildren):
         pass
 
-    @api_request()
+    @metadata.request()
     async def respond_ses_hashes(self, request: wallet_protocol.RespondSESInfo):
         pass
 
-    @api_request()
+    @metadata.request()
     async def respond_blocks(self, request: full_node_protocol.RespondBlocks) -> None:
         pass

chia/wallet/wallet_pool_store.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import logging
-from typing import List, Tuple
 
 from chia.types.coin_spend import CoinSpend
 from chia.util.db_wrapper import DBWrapper2
@@ -89,7 +88,7 @@ class WalletPoolStore:
             )
             await cursor.close()
 
-    async def get_spends_for_wallet(self, wallet_id: int) -> List[Tuple[uint32, CoinSpend]]:
+    async def get_spends_for_wallet(self, wallet_id: int) -> list[tuple[uint32, CoinSpend]]:
         """
         Retrieves all entries for a wallet ID.
         """

chia/wallet/wallet_protocol.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, List, Optional, Set, Tuple, TypeVar
+from typing import TYPE_CHECKING, Optional, TypeVar
 
 from chia_rs import G1Element
 from typing_extensions import NotRequired, Protocol, TypedDict
@@ -20,32 +20,34 @@ from chia.wallet.wallet_spend_bundle import WalletSpendBundle
 if TYPE_CHECKING:
     from chia.wallet.wallet_state_manager import WalletStateManager
 
-T = TypeVar("T", contravariant=True)
+T_contra = TypeVar("T_contra", contravariant=True)
 
 
-class WalletProtocol(Protocol[T]):
+class WalletProtocol(Protocol[T_contra]):
     @classmethod
     def type(cls) -> WalletType: ...
 
     def id(self) -> uint32: ...
 
-    async def coin_added(self, coin: Coin, height: uint32, peer: WSChiaConnection, coin_data: Optional[T]) -> None: ...
+    async def coin_added(
+        self, coin: Coin, height: uint32, peer: WSChiaConnection, coin_data: Optional[T_contra]
+    ) -> None: ...
 
     async def select_coins(
         self,
         amount: uint64,
         action_scope: WalletActionScope,
-    ) -> Set[Coin]: ...
+    ) -> set[Coin]: ...
 
-    async def get_confirmed_balance(self, record_list: Optional[Set[WalletCoinRecord]] = None) -> uint128: ...
+    async def get_confirmed_balance(self, record_list: Optional[set[WalletCoinRecord]] = None) -> uint128: ...
 
-    async def get_unconfirmed_balance(self, unspent_records: Optional[Set[WalletCoinRecord]] = None) -> uint128: ...
+    async def get_unconfirmed_balance(self, unspent_records: Optional[set[WalletCoinRecord]] = None) -> uint128: ...
 
-    async def get_spendable_balance(self, unspent_records: Optional[Set[WalletCoinRecord]] = None) -> uint128: ...
+    async def get_spendable_balance(self, unspent_records: Optional[set[WalletCoinRecord]] = None) -> uint128: ...
 
     async def get_pending_change_balance(self) -> uint64: ...
 
-    async def get_max_send_amount(self, records: Optional[Set[WalletCoinRecord]] = None) -> uint128: ...
+    async def get_max_send_amount(self, records: Optional[set[WalletCoinRecord]] = None) -> uint128: ...
 
     # not all wallet supports this. To signal support, make
     # require_derivation_paths() return true
@@ -58,9 +60,7 @@ class WalletProtocol(Protocol[T]):
     async def match_hinted_coin(self, coin: Coin, hint: bytes32) -> bool: ...
 
     wallet_info: WalletInfo
-    # WalletStateManager is only imported for type hinting thus leaving pylint
-    # unable to process this
-    wallet_state_manager: WalletStateManager  # pylint: disable=used-before-assignment
+    wallet_state_manager: WalletStateManager
 
 
 class GSTOptionalArgs(TypedDict):
@@ -71,14 +71,14 @@ class GSTOptionalArgs(TypedDict):
     add_pending_singleton: NotRequired[bool]
     announce_new_state: NotRequired[bool]
     # CATWallet
-    cat_discrepancy: NotRequired[Optional[Tuple[int, Program, Program]]]
+    cat_discrepancy: NotRequired[Optional[tuple[int, Program, Program]]]
     # NFTWallet
     nft_coin: NotRequired[Optional[NFTCoinInfo]]
     new_owner: NotRequired[Optional[bytes]]
     new_did_inner_hash: NotRequired[Optional[bytes]]
     trade_prices_list: NotRequired[Optional[Program]]
-    additional_bundles: NotRequired[List[WalletSpendBundle]]
-    metadata_update: NotRequired[Optional[Tuple[str, str]]]
+    additional_bundles: NotRequired[list[WalletSpendBundle]]
+    metadata_update: NotRequired[Optional[tuple[str, str]]]
     # CR-CAT Wallet
     add_authorizations_to_cr_cats: NotRequired[bool]
     # VCWallet

chia/wallet/wallet_puzzle_store.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import logging
-from typing import Dict, List, Optional, Set
+from typing import Optional
 
 from chia_rs import G1Element
 
@@ -27,7 +27,7 @@ class WalletPuzzleStore:
     db_wrapper: DBWrapper2
     wallet_identifier_cache: LRUCache
     # maps wallet_id -> last_derivation_index
-    last_wallet_derivation_index: Dict[uint32, uint32]
+    last_wallet_derivation_index: dict[uint32, uint32]
     last_derivation_index: Optional[uint32]
 
     @classmethod
@@ -68,7 +68,7 @@ class WalletPuzzleStore:
         self.last_wallet_derivation_index = {}
         return self
 
-    async def add_derivation_paths(self, records: List[DerivationRecord]) -> None:
+    async def add_derivation_paths(self, records: list[DerivationRecord]) -> None:
         """
         Insert many derivation paths into the database.
         """
@@ -267,7 +267,7 @@ class WalletPuzzleStore:
 
         return None
 
-    async def get_all_puzzle_hashes(self, wallet_id: Optional[int] = None) -> Set[bytes32]:
+    async def get_all_puzzle_hashes(self, wallet_id: Optional[int] = None) -> set[bytes32]:
         """
         Return a set containing all puzzle_hashes we generated.
         """
@@ -343,6 +343,22 @@ class WalletPuzzleStore:
 
         return None
 
+    async def get_unused_derivation_path_for_wallet(self, wallet_id: uint32) -> Optional[uint32]:
+        """
+        Returns the first unused derivation path by derivation_index.
+        """
+        async with self.db_wrapper.reader_no_transaction() as conn:
+            row = await execute_fetchone(
+                conn,
+                "SELECT MIN(derivation_index) FROM derivation_paths WHERE wallet_id=? AND used=0 AND hardened=0;",
+                (wallet_id,),
+            )
+
+        if row is not None and row[0] is not None:
+            return uint32(row[0])
+
+        return None
+
     async def delete_wallet(self, wallet_id: uint32) -> None:
         async with self.db_wrapper.writer_maybe_transaction() as conn:
             # First fetch all puzzle hashes since we need them to drop them from the cache
@@ -363,3 +379,18 @@ class WalletPuzzleStore:
         except KeyError:
             pass
         self.last_derivation_index = None
+
+    async def get_unused_count(self, wallet_id: uint32) -> int:
+        """
+        Returns a count of unused derivation indexes
+        """
+
+        async with self.db_wrapper.reader_no_transaction() as conn:
+            row = await execute_fetchone(
+                conn,
+                "SELECT COUNT(*) FROM derivation_paths WHERE wallet_id=? AND used=1",
+                (wallet_id,),
+            )
+            row_count = 0 if row is None else row[0]
+
+        return row_count

chia/wallet/wallet_retry_store.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import List, Optional, Tuple
+from typing import Optional
 
 from chia_rs import CoinState
 
@@ -30,7 +30,7 @@ class WalletRetryStore:
 
         return self
 
-    async def get_all_states_to_retry(self) -> List[Tuple[CoinState, bytes32, uint32]]:
+    async def get_all_states_to_retry(self) -> list[tuple[CoinState, bytes32, uint32]]:
         """
         Return all states that were failed to sync
         """

chia/wallet/wallet_singleton_store.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import json
 import logging
 from sqlite3 import Row
-from typing import List, Optional, Type, TypeVar, Union
+from typing import Optional, TypeVar, Union
 
 from clvm.casts import int_from_bytes
 
@@ -28,7 +28,7 @@ class WalletSingletonStore:
     db_wrapper: DBWrapper2
 
     @classmethod
-    async def create(cls: Type[_T_WalletSingletonStore], wrapper: DBWrapper2) -> _T_WalletSingletonStore:
+    async def create(cls: type[_T_WalletSingletonStore], wrapper: DBWrapper2) -> _T_WalletSingletonStore:
         self = cls()
         self.db_wrapper = wrapper
 
@@ -102,7 +102,9 @@ class WalletSingletonStore:
             coin_state.puzzle_reveal, coin_state.solution, DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM
         )
 
-        cc_cond = [cond for cond in conditions[ConditionOpcode.CREATE_COIN] if int_from_bytes(cond.vars[1]) % 2 == 1][0]
+        cc_cond = next(
+            cond for cond in conditions[ConditionOpcode.CREATE_COIN] if int_from_bytes(cond.vars[1]) % 2 == 1
+        )
 
         coin = Coin(coin_state.coin.name(), cc_cond.vars[0], uint64(int_from_bytes(cc_cond.vars[1])))
         inner_puz = get_inner_puzzle_from_singleton(coin_state.puzzle_reveal)
@@ -125,7 +127,6 @@ class WalletSingletonStore:
         current_records = await self.get_records_by_coin_id(coin_state.coin.name())
         if len(current_records) > 0:
             await self.delete_singleton_by_coin_id(coin_state.coin.name(), block_height)
-        return
 
     def _to_singleton_record(self, row: Row) -> SingletonRecord:
         return SingletonRecord(
@@ -183,7 +184,7 @@ class WalletSingletonStore:
             )
             return c.rowcount > 0
 
-    async def get_records_by_wallet_id(self, wallet_id: int) -> List[SingletonRecord]:
+    async def get_records_by_wallet_id(self, wallet_id: int) -> list[SingletonRecord]:
         """
         Retrieves all entries for a wallet ID.
         """
@@ -195,7 +196,7 @@ class WalletSingletonStore:
             )
         return [self._to_singleton_record(row) for row in rows]
 
-    async def get_records_by_coin_id(self, coin_id: bytes32) -> List[SingletonRecord]:
+    async def get_records_by_coin_id(self, coin_id: bytes32) -> list[SingletonRecord]:
         """
         Retrieves all entries for a coin ID.
         """
@@ -207,7 +208,7 @@ class WalletSingletonStore:
             )
         return [self._to_singleton_record(row) for row in rows]
 
-    async def get_records_by_singleton_id(self, singleton_id: bytes32) -> List[SingletonRecord]:
+    async def get_records_by_singleton_id(self, singleton_id: bytes32) -> list[SingletonRecord]:
         """
         Retrieves all entries for a singleton ID.
         """
@@ -234,7 +235,7 @@ class WalletSingletonStore:
 
     async def count(self, wallet_id: Optional[uint32] = None) -> int:
         sql = "SELECT COUNT(singleton_id) FROM singletons WHERE removed_height=0"
-        params: List[uint32] = []
+        params: list[uint32] = []
         if wallet_id is not None:
             sql += " AND wallet_id=?"
             params.append(wallet_id)
@@ -246,7 +247,7 @@ class WalletSingletonStore:
 
     async def is_empty(self, wallet_id: Optional[uint32] = None) -> bool:
         sql = "SELECT 1 FROM singletons WHERE removed_height=0"
-        params: List[Union[uint32, bytes32]] = []
+        params: list[Union[uint32, bytes32]] = []
         if wallet_id is not None:
             sql += " AND wallet_id=?"
             params.append(wallet_id)

chia/wallet/wallet_spend_bundle.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Dict, List, Tuple
+from collections.abc import Sequence
 
 from chia_rs import AugSchemeMPL, G2Element
 
@@ -11,26 +11,10 @@ from chia.wallet.util.debug_spend_bundle import debug_spend_bundle
 
 
 class WalletSpendBundle(SpendBundle):
-
-    @classmethod
-    def from_bytes(cls, bytes: bytes) -> WalletSpendBundle:
-        sb = SpendBundle.from_bytes(bytes)
-        return cls(sb.coin_spends, sb.aggregated_signature)
-
-    @classmethod
-    def parse_rust(cls, blob: bytes, flag: bool = False) -> Tuple[WalletSpendBundle, int]:
-        bundle, advance = super(WalletSpendBundle, WalletSpendBundle).parse_rust(blob)
-        return cls(bundle.coin_spends, bundle.aggregated_signature), advance
-
-    @classmethod
-    def from_json_dict(cls, json_dict: Dict[str, Any]) -> WalletSpendBundle:
-        sb = SpendBundle.from_json_dict(json_dict)
-        return cls(sb.coin_spends, sb.aggregated_signature)
-
     @classmethod
-    def aggregate(cls, spend_bundles: List[T_SpendBundle]) -> WalletSpendBundle:
-        coin_spends: List[CoinSpend] = []
-        sigs: List[G2Element] = []
+    def aggregate(cls, spend_bundles: Sequence[T_SpendBundle]) -> WalletSpendBundle:
+        coin_spends: list[CoinSpend] = []
+        sigs: list[G2Element] = []
         for bundle in spend_bundles:
             coin_spends += bundle.coin_spends
             sigs.append(bundle.aggregated_signature)