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

chia/wallet/wallet.py

@@ -4,7 +4,7 @@ import logging
 import time
 from typing import TYPE_CHECKING, Any, ClassVar, Optional, cast
 
-from chia_rs import AugSchemeMPL, G1Element, G2Element, PrivateKey
+from chia_rs import AugSchemeMPL, CoinSpend, G1Element, G2Element, PrivateKey
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64, uint128
 from typing_extensions import Unpack
@@ -12,7 +12,7 @@ from typing_extensions import Unpack
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
 from chia.types.blockchain_format.serialized_program import SerializedProgram
-from chia.types.coin_spend import CoinSpend, make_spend
+from chia.types.coin_spend import make_spend
 from chia.types.signing_mode import CHIP_0002_SIGN_MESSAGE_PREFIX, SigningMode
 from chia.util.hash import std_hash
 from chia.util.streamable import Streamable
@@ -177,38 +177,6 @@ class Wallet:
         public_key = await self.wallet_state_manager.get_public_key(puzzle_hash)
         return puzzle_for_pk(G1Element.from_bytes(public_key))
 
-    async def get_new_puzzle(self) -> Program:
-        dr = await self.wallet_state_manager.get_unused_derivation_record(self.id())
-        puzzle = puzzle_for_pk(dr.pubkey)
-        return puzzle
-
-    async def get_puzzle(self, new: bool) -> Program:
-        if new:
-            return await self.get_new_puzzle()
-        else:
-            record: Optional[
-                DerivationRecord
-            ] = await self.wallet_state_manager.get_current_derivation_record_for_wallet(self.id())
-            if record is None:
-                return await self.get_new_puzzle()  # pragma: no cover
-            puzzle = puzzle_for_pk(record.pubkey)
-            return puzzle
-
-    async def get_puzzle_hash(self, new: bool) -> bytes32:
-        if new:
-            return await self.get_new_puzzlehash()
-        else:
-            record: Optional[
-                DerivationRecord
-            ] = await self.wallet_state_manager.get_current_derivation_record_for_wallet(self.id())
-            if record is None:
-                return await self.get_new_puzzlehash()
-            return record.puzzle_hash
-
-    async def get_new_puzzlehash(self) -> bytes32:
-        puzhash = (await self.wallet_state_manager.get_unused_derivation_record(self.id())).puzzle_hash
-        return puzhash
-
     def make_solution(
         self,
         primaries: list[CreateCoin],
@@ -272,6 +240,8 @@ class Wallet:
         negative_change_allowed: bool = False,
         puzzle_decorator_override: Optional[list[dict[str, Any]]] = None,
         extra_conditions: tuple[Condition, ...] = tuple(),
+        reserve_fee: Optional[uint64] = None,
+        preferred_change_puzzle_hash: Optional[bytes32] = None,
     ) -> list[CoinSpend]:
         """
         Generates a unsigned transaction in form of List(Puzzle, Solutions)
@@ -338,15 +308,22 @@ class Wallet:
                 ]
 
                 if change > 0:
-                    if action_scope.config.tx_config.reuse_puzhash:
-                        change_puzzle_hash: bytes32 = coin.puzzle_hash
-                        for primary in primaries:
-                            if change_puzzle_hash == primary.puzzle_hash and change == primary.amount:
-                                # We cannot create two coins has same id, create a new puzhash for the change:
-                                change_puzzle_hash = await self.get_new_puzzlehash()
-                                break
-                    else:
-                        change_puzzle_hash = await self.get_new_puzzlehash()
+                    change_puzzle_hash = (
+                        preferred_change_puzzle_hash
+                        if preferred_change_puzzle_hash is not None
+                        else await action_scope.get_puzzle_hash(self.wallet_state_manager)
+                    )
+                    for primary in primaries:
+                        if change_puzzle_hash == primary.puzzle_hash and change == primary.amount:
+                            if preferred_change_puzzle_hash is not None:
+                                raise ValueError(
+                                    "A `preferred_change_puzzle_hash` was specified that would make a duplicate output"
+                                )
+                            # We cannot create two coins has same id, create a new puzhash for the change:
+                            change_puzzle_hash = await action_scope.get_puzzle_hash(
+                                self.wallet_state_manager, override_reuse_puzhash_with=False
+                            )
+                            break
                     primaries.append(CreateCoin(change_puzzle_hash, uint64(change)))
                 message_list: list[bytes32] = [c.name() for c in coins]
                 for primary in primaries:
@@ -355,7 +332,7 @@ class Wallet:
                 puzzle: Program = await self.puzzle_for_puzzle_hash(coin.puzzle_hash)
                 solution: Program = self.make_solution(
                     primaries=primaries,
-                    fee=fee,
+                    fee=fee if reserve_fee is None else reserve_fee,
                     conditions=(*extra_conditions, CreateCoinAnnouncement(message)),
                 )
                 solution = decorator_manager.solve(inner_puzzle, target_primaries, solution)
@@ -416,6 +393,8 @@ class Wallet:
         origin_id: Optional[bytes32] = kwargs.get("origin_id", None)
         negative_change_allowed: bool = kwargs.get("negative_change_allowed", False)
         puzzle_decorator_override: Optional[list[dict[str, Any]]] = kwargs.get("puzzle_decorator_override", None)
+        reserve_fee: Optional[uint64] = kwargs.get("reserve_fee", None)
+        preferred_change_puzzle_hash: Optional[bytes32] = kwargs.get("preferred_change_puzzle_hash", None)
         """
         Use this to generate transaction.
         Note: this must be called under a wallet state manager lock
@@ -435,6 +414,8 @@ class Wallet:
             negative_change_allowed,
             puzzle_decorator_override=puzzle_decorator_override,
             extra_conditions=extra_conditions,
+            reserve_fee=reserve_fee,
+            preferred_change_puzzle_hash=preferred_change_puzzle_hash,
         )
         assert len(transaction) > 0
         spend_bundle = WalletSpendBundle(transaction, G2Element())
@@ -477,16 +458,22 @@ class Wallet:
         self,
         fee: uint64,
         action_scope: WalletActionScope,
+        coins: Optional[set[Coin]] = None,
         extra_conditions: tuple[Condition, ...] = tuple(),
+        reserve_fee: Optional[uint64] = None,
+        preferred_change_puzzle_hash: Optional[bytes32] = None,
     ) -> None:
-        chia_coins = await self.select_coins(fee, action_scope)
+        if coins is None:
+            coins = await self.select_coins(fee, action_scope)
         await self.generate_signed_transaction(
             [],
             [],
             action_scope,
             fee=fee,
-            coins=chia_coins,
+            coins=coins,
             extra_conditions=extra_conditions,
+            reserve_fee=reserve_fee,
+            preferred_change_puzzle_hash=preferred_change_puzzle_hash,
         )
 
     async def get_coins_to_offer(
@@ -522,6 +509,9 @@ class Wallet:
                 return True
         return False
 
+    def hardened_pubkey_for_path(self, path: list[int]) -> G1Element:
+        return _derive_path(self.wallet_state_manager.get_master_private_key(), path).get_g1()
+
     async def sum_hint_for_pubkey(self, pk: bytes) -> Optional[SumHint]:
         pk_parsed: G1Element = G1Element.from_bytes(pk)
         dr: Optional[DerivationRecord] = await self.wallet_state_manager.puzzle_store.record_for_puzzle_hash(

chia/wallet/wallet_action_scope.py

@@ -3,16 +3,22 @@ from __future__ import annotations
 import contextlib
 from collections.abc import AsyncIterator
 from dataclasses import dataclass, field, replace
-from typing import TYPE_CHECKING, Optional, cast, final
+from typing import TYPE_CHECKING, Callable, Optional, cast, final
+
+from chia_rs.chia_rs import G1Element
+from chia_rs.sized_bytes import bytes32
 
 from chia.data_layer.singleton_record import SingletonRecord
 from chia.types.blockchain_format.coin import Coin
+from chia.types.blockchain_format.program import Program
 from chia.util.action_scope import ActionScope
 from chia.util.streamable import Streamable, streamable
+from chia.wallet.derivation_record import DerivationRecord
 from chia.wallet.signer_protocol import SigningResponse
 from chia.wallet.transaction_record import TransactionRecord
 from chia.wallet.util.tx_config import TXConfig
 from chia.wallet.wallet_spend_bundle import WalletSpendBundle
+from chia.wallet.wsm_apis import GetUnusedDerivationRecordResult, StreambleGetUnusedDerivationRecordResult
 
 if TYPE_CHECKING:
     # Avoid a circular import here
@@ -27,6 +33,7 @@ class _StreamableWalletSideEffects(Streamable):
     extra_spends: list[WalletSpendBundle]
     selected_coins: list[Coin]
     singleton_records: list[SingletonRecord]
+    get_unused_derivation_record_result: Optional[StreambleGetUnusedDerivationRecordResult]
 
 
 @dataclass
@@ -36,6 +43,7 @@ class WalletSideEffects:
     extra_spends: list[WalletSpendBundle] = field(default_factory=list)
     selected_coins: list[Coin] = field(default_factory=list)
     singleton_records: list[SingletonRecord] = field(default_factory=list)
+    get_unused_derivation_record_result: Optional[StreambleGetUnusedDerivationRecordResult] = None
 
     def __bytes__(self) -> bytes:
         return bytes(_StreamableWalletSideEffects(**self.__dict__))
@@ -54,6 +62,7 @@ class WalletActionConfig:
     additional_signing_responses: list[SigningResponse]
     extra_spends: list[WalletSpendBundle]
     tx_config: TXConfig
+    puzzle_for_pk: Callable[[G1Element], Program]
 
     def adjust_for_side_effects(self, side_effects: WalletSideEffects) -> WalletActionConfig:
         return replace(
@@ -65,7 +74,59 @@ class WalletActionConfig:
         )
 
 
-WalletActionScope = ActionScope[WalletSideEffects, WalletActionConfig]
+class WalletActionScope(ActionScope[WalletSideEffects, WalletActionConfig]):
+    async def _get_unused_derivation_path(
+        self, wallet_state_manager: WalletStateManager
+    ) -> GetUnusedDerivationRecordResult:
+        async with self.use() as interface:
+            result = await wallet_state_manager._get_unused_derivation_record(
+                wallet_state_manager.main_wallet.id(),
+                previous_result=interface.side_effects.get_unused_derivation_record_result.to_standard()
+                if interface.side_effects.get_unused_derivation_record_result is not None
+                else None,
+            )
+            interface.side_effects.get_unused_derivation_record_result = (
+                StreambleGetUnusedDerivationRecordResult.from_standard(result)
+            )
+        return result
+
+    async def _get_new_puzzle(self, wallet_state_manager: WalletStateManager) -> Program:
+        puzzle = self.config.puzzle_for_pk((await self._get_unused_derivation_path(wallet_state_manager)).record.pubkey)
+        return puzzle
+
+    async def _get_new_puzzle_hash(self, wallet_state_manager: WalletStateManager) -> bytes32:
+        return (await self._get_unused_derivation_path(wallet_state_manager)).record.puzzle_hash
+
+    async def get_puzzle(
+        self, wallet_state_manager: WalletStateManager, override_reuse_puzhash_with: Optional[bool] = None
+    ) -> Program:
+        if (
+            self.config.tx_config.reuse_puzhash or override_reuse_puzhash_with is True
+        ) and override_reuse_puzhash_with is not False:
+            record: Optional[DerivationRecord] = await wallet_state_manager.get_current_derivation_record_for_wallet(
+                wallet_state_manager.main_wallet.id()
+            )
+            if record is None:
+                return await self._get_new_puzzle(wallet_state_manager)  # pragma: no cover
+            puzzle = self.config.puzzle_for_pk(record.pubkey)
+            return puzzle
+        else:
+            return await self._get_new_puzzle(wallet_state_manager)
+
+    async def get_puzzle_hash(
+        self, wallet_state_manager: WalletStateManager, override_reuse_puzhash_with: Optional[bool] = None
+    ) -> bytes32:
+        if (
+            self.config.tx_config.reuse_puzhash or override_reuse_puzhash_with is True
+        ) and override_reuse_puzhash_with is not False:
+            record: Optional[DerivationRecord] = await wallet_state_manager.get_current_derivation_record_for_wallet(
+                wallet_state_manager.main_wallet.id()
+            )
+            if record is None:
+                return await self._get_new_puzzle_hash(wallet_state_manager)  # pragma: no cover
+            return record.puzzle_hash
+        else:
+            return await self._get_new_puzzle_hash(wallet_state_manager)
 
 
 @contextlib.asynccontextmanager
@@ -77,10 +138,16 @@ async def new_wallet_action_scope(
     sign: Optional[bool] = None,
     additional_signing_responses: list[SigningResponse] = [],
     extra_spends: list[WalletSpendBundle] = [],
+    puzzle_for_pk: Optional[Callable[[G1Element], Program]] = None,
 ) -> AsyncIterator[WalletActionScope]:
-    async with ActionScope.new_scope(
+    if puzzle_for_pk is None:
+        puzzle_for_pk = wallet_state_manager.main_wallet.puzzle_for_pk
+    assert puzzle_for_pk is not None
+    async with WalletActionScope.new_scope(
         WalletSideEffects,
-        WalletActionConfig(push, merge_spends, sign, additional_signing_responses, extra_spends, tx_config),
+        WalletActionConfig(
+            push, merge_spends, sign, additional_signing_responses, extra_spends, tx_config, puzzle_for_pk
+        ),
     ) as self:
         self = cast(WalletActionScope, self)
         async with self.use() as interface:
@@ -98,3 +165,5 @@ async def new_wallet_action_scope(
         extra_spends=self.side_effects.extra_spends,
         singleton_records=self.side_effects.singleton_records,
     )
+    if push and self.side_effects.get_unused_derivation_record_result is not None:
+        await self.side_effects.get_unused_derivation_record_result.to_standard().commit(wallet_state_manager)

chia/wallet/wallet_blockchain.py

@@ -3,16 +3,14 @@ from __future__ import annotations
 import logging
 from typing import TYPE_CHECKING, ClassVar, Optional, cast
 
-from chia_rs import ConsensusConstants
+from chia_rs import BlockRecord, ConsensusConstants, HeaderBlock
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64
 
 from chia.consensus.block_header_validation import validate_finished_header_block
-from chia.consensus.block_record import BlockRecord
 from chia.consensus.blockchain import AddBlockResult
 from chia.consensus.find_fork_point import find_fork_point_in_chain
 from chia.consensus.full_block_to_block_record import block_to_block_record
-from chia.types.header_block import HeaderBlock
 from chia.types.validation_state import ValidationState
 from chia.types.weight_proof import WeightProof
 from chia.util.errors import Err

chia/wallet/wallet_interested_store.py

@@ -2,10 +2,10 @@ from __future__ import annotations
 
 from typing import Optional
 
+from chia_rs import CoinState
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32
 
-from chia.protocols.wallet_protocol import CoinState
 from chia.util.db_wrapper import DBWrapper2
 
 

chia/wallet/wallet_nft_store.py

@@ -3,10 +3,11 @@ from __future__ import annotations
 import json
 import logging
 from sqlite3 import Row
-from typing import Optional, TypeVar, Union
+from typing import Optional, Union
 
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32
+from typing_extensions import Self
 
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
@@ -15,7 +16,6 @@ from chia.wallet.lineage_proof import LineageProof
 from chia.wallet.nft_wallet.nft_info import DEFAULT_STATUS, IN_TRANSACTION_STATUS, NFTCoinInfo
 
 log = logging.getLogger(__name__)
-_T_WalletNftStore = TypeVar("_T_WalletNftStore", bound="WalletNftStore")
 REMOVE_BUFF_BLOCKS = 1000
 NFT_COIN_INFO_COLUMNS = "nft_id, coin, lineage_proof, mint_height, status, full_puzzle, latest_height, minter_did"
 
@@ -42,7 +42,7 @@ class WalletNftStore:
     db_wrapper: DBWrapper2
 
     @classmethod
-    async def create(cls: type[_T_WalletNftStore], db_wrapper: DBWrapper2) -> _T_WalletNftStore:
+    async def create(cls, db_wrapper: DBWrapper2) -> Self:
         self = cls()
         self.db_wrapper = db_wrapper
         async with self.db_wrapper.writer_maybe_transaction() as conn:

chia/wallet/wallet_node.py

@@ -14,7 +14,7 @@ from pathlib import Path
 from typing import TYPE_CHECKING, Any, ClassVar, Literal, Optional, Union, cast, overload
 
 import aiosqlite
-from chia_rs import AugSchemeMPL, ConsensusConstants, G1Element, G2Element, PrivateKey
+from chia_rs import AugSchemeMPL, CoinState, ConsensusConstants, G1Element, G2Element, HeaderBlock, PrivateKey
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint16, uint32, uint64, uint128
 from packaging.version import Version
@@ -23,9 +23,9 @@ from chia.consensus.blockchain import AddBlockResult
 from chia.daemon.keychain_proxy import KeychainProxy, connect_to_keychain_and_validate, wrap_local_keychain
 from chia.full_node.full_node_api import FullNodeAPI
 from chia.protocols.full_node_protocol import RequestProofOfWeight, RespondProofOfWeight
+from chia.protocols.outbound_message import Message, NodeType, make_msg
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
 from chia.protocols.wallet_protocol import (
-    CoinState,
     CoinStateUpdate,
     NewPeakWallet,
     RegisterForCoinUpdates,
@@ -38,11 +38,9 @@ from chia.protocols.wallet_protocol import (
 )
 from chia.rpc.rpc_server import StateChangedProtocol, default_get_connections
 from chia.server.node_discovery import WalletPeers
-from chia.server.outbound_message import Message, NodeType, make_msg
 from chia.server.server import ChiaServer
 from chia.server.ws_connection import WSChiaConnection
 from chia.types.blockchain_format.coin import Coin
-from chia.types.header_block import HeaderBlock
 from chia.types.mempool_inclusion_status import MempoolInclusionStatus
 from chia.types.weight_proof import WeightProof
 from chia.util.batches import to_batches
@@ -202,7 +200,7 @@ class WalletNode:
             else:
                 self._keychain_proxy = await connect_to_keychain_and_validate(self.root_path, self.log)
                 if not self._keychain_proxy:
-                    raise KeychainProxyConnectionFailure()
+                    raise KeychainProxyConnectionFailure
         return self._keychain_proxy
 
     def get_cache_for_peer(self, peer: WSChiaConnection) -> PeerRequestCache:
@@ -470,7 +468,8 @@ class WalletNode:
         async with self.wallet_state_manager.puzzle_store.lock:
             index = await self.wallet_state_manager.puzzle_store.get_last_derivation_path()
             if index is None or index < self.wallet_state_manager.initial_num_public_keys - 1:
-                await self.wallet_state_manager.create_more_puzzle_hashes(from_zero=True)
+                result = await self.wallet_state_manager.create_more_puzzle_hashes(from_zero=True)
+                await result.commit(self.wallet_state_manager)
 
         if self.wallet_peers is None:
             self.initialize_wallet_peers()
@@ -708,15 +707,16 @@ class WalletNode:
         testing = self.config.get("testing", False)
         if self.wallet_peers is None and connect_to_unknown_peers and not testing:
             self.wallet_peers = WalletPeers(
-                self.server,
-                self.config["target_peer_count"],
-                self.root_path / Path(self.config.get("wallet_peers_file_path", "wallet/db/wallet_peers.dat")),
-                self.config["introducer_peer"],
-                self.config.get("dns_servers", ["dns-introducer.chia.net"]),
-                self.config["peer_connect_interval"],
-                network_name,
-                default_port,
-                self.log,
+                server=self.server,
+                target_outbound_count=self.config["target_peer_count"],
+                peers_file_path=self.root_path
+                / Path(self.config.get("wallet_peers_file_path", "wallet/db/wallet_peers.dat")),
+                introducer_info=self.config["introducer_peer"],
+                dns_servers=self.config.get("dns_servers", ["dns-introducer.chia.net"]),
+                peer_connect_interval=self.config["peer_connect_interval"],
+                selected_network=network_name,
+                default_port=default_port,
+                log=self.log,
             )
             create_referenced_task(self.wallet_peers.start())
 
@@ -828,7 +828,8 @@ class WalletNode:
         min_height_for_subscriptions = fork_height if use_delta_sync else 0
         already_checked_ph: set[bytes32] = set()
         while not self._shut_down:
-            await self.wallet_state_manager.create_more_puzzle_hashes()
+            result = await self.wallet_state_manager.create_more_puzzle_hashes()
+            await result.commit(self.wallet_state_manager)
             all_puzzle_hashes = await self.get_puzzle_hashes_to_subscribe()
             not_checked_puzzle_hashes = set(all_puzzle_hashes) - already_checked_ph
             if not_checked_puzzle_hashes == set():

chia/wallet/wallet_node_api.py

@@ -3,9 +3,11 @@ from __future__ import annotations
 import logging
 from typing import TYPE_CHECKING, ClassVar, cast
 
+from chia_rs import RespondToPhUpdates
+
 from chia.protocols import full_node_protocol, introducer_protocol, wallet_protocol
+from chia.protocols.outbound_message import NodeType
 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.errors import Err
@@ -37,14 +39,12 @@ class WalletNodeAPI:
         """
         The full node has rejected our request for removals.
         """
-        pass
 
     @metadata.request()
     async def reject_additions_request(self, response: wallet_protocol.RejectAdditionsRequest):
         """
         The full node has rejected our request for additions.
         """
-        pass
 
     @metadata.request(peer_required=True, execute_task=True)
     async def new_peak_wallet(self, peak: wallet_protocol.NewPeakWallet, peer: WSChiaConnection):
@@ -81,7 +81,6 @@ class WalletNodeAPI:
         """
         The full node has rejected our request for a header.
         """
-        pass
 
     @metadata.request()
     async def respond_block_header(self, response: wallet_protocol.RespondBlockHeader):
@@ -187,7 +186,7 @@ class WalletNodeAPI:
     #       subclass, as you might expect it wouldn't be.  Maybe we can get the
     #       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):
+    async def respond_to_ph_updates(self, request: RespondToPhUpdates):
         pass
 
     @metadata.request()

chia/wallet/wallet_pool_store.py

@@ -2,9 +2,9 @@ from __future__ import annotations
 
 import logging
 
+from chia_rs import CoinSpend
 from chia_rs.sized_ints import uint32
 
-from chia.types.coin_spend import CoinSpend
 from chia.util.db_wrapper import DBWrapper2
 
 log = logging.getLogger(__name__)

chia/wallet/wallet_protocol.py

@@ -102,3 +102,5 @@ class GSTOptionalArgs(TypedDict):
     origin_id: NotRequired[Optional[bytes32]]
     negative_change_allowed: NotRequired[bool]
     puzzle_decorator_override: NotRequired[Optional[list[dict[str, Any]]]]
+    reserve_fee: NotRequired[Optional[uint64]]
+    preferred_change_puzzle_hash: NotRequired[Optional[bytes32]]

chia/wallet/wallet_puzzle_store.py

@@ -380,7 +380,7 @@ class WalletPuzzleStore:
             pass
         self.last_derivation_index = None
 
-    async def get_unused_count(self, wallet_id: uint32) -> int:
+    async def get_used_count(self, wallet_id: uint32) -> int:
         """
         Returns a count of unused derivation indexes
         """