chia-blockchain 2.5.7rc4__py3-none-any.whl → 2.5.8rc1__py3-none-any.whl

chia/wallet/wallet_rpc_client.py

@@ -1,17 +1,11 @@
 from __future__ import annotations
 
-from typing import Any, Optional, Union
-
-from chia_rs.sized_bytes import bytes32
-from chia_rs.sized_ints import uint32, uint64
+from typing import Any
 
 from chia.data_layer.data_layer_util import DLProof, VerifyProofResponse
 from chia.rpc.rpc_client import RpcClient
-from chia.types.blockchain_format.coin import Coin
-from chia.wallet.conditions import Condition, ConditionValidTimes, conditions_to_json_dicts
+from chia.wallet.conditions import Condition, ConditionValidTimes
 from chia.wallet.puzzles.clawback.metadata import AutoClaimSettings
-from chia.wallet.trade_record import TradeRecord
-from chia.wallet.trading.offer import Offer
 from chia.wallet.transaction_record import TransactionRecord
 from chia.wallet.util.clvm_streamable import json_deserialize_with_clvm_streamable
 from chia.wallet.util.tx_config import TXConfig
@@ -21,7 +15,9 @@ from chia.wallet.wallet_request_types import (
     AddKeyResponse,
     ApplySignatures,
     ApplySignaturesResponse,
+    CancelOffer,
     CancelOfferResponse,
+    CancelOffers,
     CancelOffersResponse,
     CATAssetIDToName,
     CATAssetIDToNameResponse,
@@ -39,9 +35,15 @@ from chia.wallet.wallet_request_types import (
     CheckOfferValidityResponse,
     CombineCoins,
     CombineCoinsResponse,
+    CRCATApprovePending,
+    CRCATApprovePendingResponse,
     CreateNewDL,
     CreateNewDLResponse,
+    CreateNewWallet,
+    CreateNewWalletResponse,
+    CreateOfferForIDs,
     CreateOfferForIDsResponse,
+    CreateSignedTransaction,
     CreateSignedTransactionsResponse,
     DeleteKey,
     DeleteNotifications,
@@ -96,17 +98,25 @@ from chia.wallet.wallet_request_types import (
     GatherSigningInfo,
     GatherSigningInfoResponse,
     GenerateMnemonicResponse,
+    GetAllOffers,
+    GetAllOffersResponse,
     GetCATListResponse,
     GetCoinRecordsByNames,
     GetCoinRecordsByNamesResponse,
     GetCurrentDerivationIndexResponse,
+    GetFarmedAmount,
+    GetFarmedAmountResponse,
     GetHeightInfoResponse,
     GetLoggedInFingerprintResponse,
     GetNextAddress,
     GetNextAddressResponse,
     GetNotifications,
     GetNotificationsResponse,
+    GetOffer,
+    GetOfferResponse,
     GetOffersCountResponse,
+    GetOfferSummary,
+    GetOfferSummaryResponse,
     GetPrivateKey,
     GetPrivateKeyResponse,
     GetPublicKeysResponse,
@@ -176,6 +186,7 @@ from chia.wallet.wallet_request_types import (
     SendNotification,
     SendNotificationResponse,
     SendTransaction,
+    SendTransactionMulti,
     SendTransactionMultiResponse,
     SendTransactionResponse,
     SetWalletResyncOnStartup,
@@ -189,6 +200,7 @@ from chia.wallet.wallet_request_types import (
     SplitCoinsResponse,
     SubmitTransactions,
     SubmitTransactionsResponse,
+    TakeOffer,
     TakeOfferResponse,
     VCAddProofs,
     VCGet,
@@ -315,6 +327,20 @@ class WalletRpcClient(RpcClient):
     async def get_next_address(self, request: GetNextAddress) -> GetNextAddressResponse:
         return GetNextAddressResponse.from_json_dict(await self.fetch("get_next_address", request.to_json_dict()))
 
+    async def create_new_wallet(
+        self,
+        request: CreateNewWallet,
+        tx_config: TXConfig,
+        extra_conditions: tuple[Condition, ...] = tuple(),
+        timelock_info: ConditionValidTimes = ConditionValidTimes(),
+    ) -> CreateNewWalletResponse:
+        return CreateNewWalletResponse.from_json_dict(
+            await self.fetch(
+                "create_new_wallet",
+                request.json_serialize_for_transport(tx_config, extra_conditions, timelock_info),
+            )
+        )
+
     async def send_transaction(
         self,
         request: SendTransaction,
@@ -331,33 +357,17 @@ class WalletRpcClient(RpcClient):
 
     async def send_transaction_multi(
         self,
-        wallet_id: int,
-        additions: list[dict[str, Any]],
+        request: SendTransactionMulti,
         tx_config: TXConfig,
-        coins: Optional[list[Coin]] = None,
-        fee: uint64 = uint64(0),
-        push: bool = True,
+        extra_conditions: tuple[Condition, ...] = tuple(),
         timelock_info: ConditionValidTimes = ConditionValidTimes(),
     ) -> SendTransactionMultiResponse:
-        # Converts bytes to hex for puzzle hashes
-        additions_hex = []
-        for ad in additions:
-            additions_hex.append({"amount": ad["amount"], "puzzle_hash": ad["puzzle_hash"].hex()})
-            if "memos" in ad:
-                additions_hex[-1]["memos"] = ad["memos"]
-        request = {
-            "wallet_id": wallet_id,
-            "additions": additions_hex,
-            "fee": fee,
-            "push": push,
-            **tx_config.to_json_dict(),
-            **timelock_info.to_json_dict(),
-        }
-        if coins is not None and len(coins) > 0:
-            coins_json = [c.to_json_dict() for c in coins]
-            request["coins"] = coins_json
-        response = await self.fetch("send_transaction_multi", request)
-        return json_deserialize_with_clvm_streamable(response, SendTransactionMultiResponse)
+        return SendTransactionMultiResponse.from_json_dict(
+            await self.fetch(
+                "send_transaction_multi",
+                request.json_serialize_for_transport(tx_config, extra_conditions, timelock_info),
+            )
+        )
 
     async def spend_clawback_coins(
         self,
@@ -383,45 +393,22 @@ class WalletRpcClient(RpcClient):
             await self.fetch("extend_derivation_index", request.to_json_dict())
         )
 
-    async def get_farmed_amount(self, include_pool_rewards: bool = False) -> dict[str, Any]:
-        return await self.fetch("get_farmed_amount", {"include_pool_rewards": include_pool_rewards})
+    async def get_farmed_amount(self, request: GetFarmedAmount) -> GetFarmedAmountResponse:
+        return GetFarmedAmountResponse.from_json_dict(await self.fetch("get_farmed_amount", request.to_json_dict()))
 
     async def create_signed_transactions(
         self,
-        additions: list[dict[str, Any]],
+        request: CreateSignedTransaction,
         tx_config: TXConfig,
-        coins: Optional[list[Coin]] = None,
-        fee: uint64 = uint64(0),
-        wallet_id: Optional[int] = None,
         extra_conditions: tuple[Condition, ...] = tuple(),
         timelock_info: ConditionValidTimes = ConditionValidTimes(),
-        push: bool = False,
     ) -> CreateSignedTransactionsResponse:
-        # Converts bytes to hex for puzzle hashes
-        additions_hex = []
-        for ad in additions:
-            additions_hex.append({"amount": ad["amount"], "puzzle_hash": ad["puzzle_hash"].hex()})
-            if "memos" in ad:
-                additions_hex[-1]["memos"] = ad["memos"]
-
-        request = {
-            "additions": additions_hex,
-            "fee": fee,
-            "extra_conditions": conditions_to_json_dicts(extra_conditions),
-            "push": push,
-            **tx_config.to_json_dict(),
-            **timelock_info.to_json_dict(),
-        }
-
-        if coins is not None and len(coins) > 0:
-            coins_json = [c.to_json_dict() for c in coins]
-            request["coins"] = coins_json
-
-        if wallet_id:
-            request["wallet_id"] = wallet_id
-
-        response = await self.fetch("create_signed_transaction", request)
-        return json_deserialize_with_clvm_streamable(response, CreateSignedTransactionsResponse)
+        return CreateSignedTransactionsResponse.from_json_dict(
+            await self.fetch(
+                "create_signed_transaction",
+                request.json_serialize_for_transport(tx_config, extra_conditions, timelock_info),
+            )
+        )
 
     async def select_coins(self, request: SelectCoins) -> SelectCoinsResponse:
         return SelectCoinsResponse.from_json_dict(await self.fetch("select_coins", request.to_json_dict()))
@@ -438,37 +425,6 @@ class WalletRpcClient(RpcClient):
         )
 
     # DID wallet
-    async def create_new_did_wallet(
-        self,
-        amount: int,
-        tx_config: TXConfig,
-        fee: int = 0,
-        name: Optional[str] = "DID Wallet",
-        backup_ids: list[str] = [],
-        required_num: int = 0,
-        type: str = "new",
-        backup_data: str = "",
-        push: bool = True,
-        extra_conditions: tuple[Condition, ...] = tuple(),
-        timelock_info: ConditionValidTimes = ConditionValidTimes(),
-    ) -> dict[str, Any]:
-        request = {
-            "wallet_type": "did_wallet",
-            "did_type": type,
-            "backup_dids": backup_ids,
-            "num_of_backup_ids_needed": required_num,
-            "amount": amount,
-            "fee": fee,
-            "wallet_name": name,
-            "push": push,
-            "backup_data": backup_data,
-            "extra_conditions": conditions_to_json_dicts(extra_conditions),
-            **tx_config.to_json_dict(),
-            **timelock_info.to_json_dict(),
-        }
-        response = await self.fetch("create_new_wallet", request)
-        return response
-
     async def get_did_id(self, request: DIDGetDID) -> DIDGetDIDResponse:
         return DIDGetDIDResponse.from_json_dict(await self.fetch("did_get_did", request.to_json_dict()))
 
@@ -547,41 +503,6 @@ class WalletRpcClient(RpcClient):
     async def did_get_wallet_name(self, request: DIDGetWalletName) -> DIDGetWalletNameResponse:
         return DIDGetWalletNameResponse.from_json_dict(await self.fetch("did_get_wallet_name", request.to_json_dict()))
 
-    # TODO: test all invocations of create_new_pool_wallet with new fee arg.
-    async def create_new_pool_wallet(
-        self,
-        target_puzzlehash: Optional[bytes32],
-        pool_url: Optional[str],
-        relative_lock_height: uint32,
-        backup_host: str,
-        mode: str,
-        state: str,
-        fee: uint64,
-        p2_singleton_delay_time: Optional[uint64] = None,
-        p2_singleton_delayed_ph: Optional[bytes32] = None,
-        extra_conditions: tuple[Condition, ...] = tuple(),
-        timelock_info: ConditionValidTimes = ConditionValidTimes(),
-    ) -> TransactionRecord:
-        request = {
-            "wallet_type": "pool_wallet",
-            "mode": mode,
-            "initial_target_state": {
-                "target_puzzle_hash": target_puzzlehash.hex() if target_puzzlehash else None,
-                "relative_lock_height": relative_lock_height,
-                "pool_url": pool_url,
-                "state": state,
-            },
-            "fee": fee,
-            "extra_conditions": conditions_to_json_dicts(extra_conditions),
-            **timelock_info.to_json_dict(),
-        }
-        if p2_singleton_delay_time is not None:
-            request["p2_singleton_delay_time"] = p2_singleton_delay_time
-        if p2_singleton_delayed_ph is not None:
-            request["p2_singleton_delayed_ph"] = p2_singleton_delayed_ph.hex()
-        res = await self.fetch("create_new_wallet", request)
-        return TransactionRecord.from_json_dict(res["transaction"])
-
     async def pw_self_pool(
         self,
         request: PWSelfPool,
@@ -625,16 +546,6 @@ class WalletRpcClient(RpcClient):
         return PWStatusResponse.from_json_dict(await self.fetch("pw_status", request.to_json_dict()))
 
     # CATS
-    async def create_new_cat_and_wallet(
-        self, amount: uint64, fee: uint64 = uint64(0), test: bool = False
-    ) -> dict[str, Any]:
-        request = {"wallet_type": "cat_wallet", "mode": "new", "amount": amount, "fee": fee, "test": test}
-        return await self.fetch("create_new_wallet", request)
-
-    async def create_wallet_for_existing_cat(self, asset_id: bytes) -> dict[str, Any]:
-        request = {"wallet_type": "cat_wallet", "asset_id": asset_id.hex(), "mode": "existing"}
-        return await self.fetch("create_new_wallet", request)
-
     async def get_cat_asset_id(self, request: CATGetAssetID) -> CATGetAssetIDResponse:
         return CATGetAssetIDResponse.from_json_dict(await self.fetch("cat_get_asset_id", request.to_json_dict()))
 
@@ -666,37 +577,19 @@ class WalletRpcClient(RpcClient):
     # Offers
     async def create_offer_for_ids(
         self,
-        offer_dict: dict[Union[uint32, str], int],
+        request: CreateOfferForIDs,
         tx_config: TXConfig,
-        driver_dict: Optional[dict[str, Any]] = None,
-        solver: Optional[dict[str, Any]] = None,
-        fee: int = 0,
-        validate_only: bool = False,
         extra_conditions: tuple[Condition, ...] = tuple(),
         timelock_info: ConditionValidTimes = ConditionValidTimes(),
     ) -> CreateOfferForIDsResponse:
-        send_dict: dict[str, int] = {str(key): value for key, value in offer_dict.items()}
-
-        req = {
-            "offer": send_dict,
-            "validate_only": validate_only,
-            "fee": fee,
-            "extra_conditions": conditions_to_json_dicts(extra_conditions),
-            **tx_config.to_json_dict(),
-            **timelock_info.to_json_dict(),
-        }
-        if driver_dict is not None:
-            req["driver_dict"] = driver_dict
-        if solver is not None:
-            req["solver"] = solver
-        res = await self.fetch("create_offer_for_ids", req)
-        return json_deserialize_with_clvm_streamable(res, CreateOfferForIDsResponse)
-
-    async def get_offer_summary(
-        self, offer: Offer, advanced: bool = False
-    ) -> tuple[bytes32, dict[str, dict[str, int]]]:
-        res = await self.fetch("get_offer_summary", {"offer": offer.to_bech32(), "advanced": advanced})
-        return bytes32.from_hexstr(res["id"]), res["summary"]
+        return CreateOfferForIDsResponse.from_json_dict(
+            await self.fetch(
+                "create_offer_for_ids", request.json_serialize_for_transport(tx_config, extra_conditions, timelock_info)
+            )
+        )
+
+    async def get_offer_summary(self, request: GetOfferSummary) -> GetOfferSummaryResponse:
+        return GetOfferSummaryResponse.from_json_dict(await self.fetch("get_offer_summary", request.to_json_dict()))
 
     async def check_offer_validity(self, request: CheckOfferValidity) -> CheckOfferValidityResponse:
         return CheckOfferValidityResponse.from_json_dict(
@@ -705,133 +598,56 @@ class WalletRpcClient(RpcClient):
 
     async def take_offer(
         self,
-        offer: Offer,
+        request: TakeOffer,
         tx_config: TXConfig,
-        solver: Optional[dict[str, Any]] = None,
-        fee: int = 0,
         extra_conditions: tuple[Condition, ...] = tuple(),
         timelock_info: ConditionValidTimes = ConditionValidTimes(),
-        push: bool = True,
     ) -> TakeOfferResponse:
-        req = {
-            "offer": offer.to_bech32(),
-            "fee": fee,
-            "extra_conditions": conditions_to_json_dicts(extra_conditions),
-            "push": push,
-            **tx_config.to_json_dict(),
-            **timelock_info.to_json_dict(),
-        }
-        if solver is not None:
-            req["solver"] = solver
-        res = await self.fetch("take_offer", req)
-        return json_deserialize_with_clvm_streamable(res, TakeOfferResponse)
-
-    async def get_offer(self, trade_id: bytes32, file_contents: bool = False) -> TradeRecord:
-        res = await self.fetch("get_offer", {"trade_id": trade_id.hex(), "file_contents": file_contents})
-        offer_str = bytes(Offer.from_bech32(res["offer"])).hex() if file_contents else ""
-        return TradeRecord.from_json_dict_convenience(res["trade_record"], offer_str)
-
-    async def get_all_offers(
-        self,
-        start: int = 0,
-        end: int = 50,
-        sort_key: Optional[str] = None,
-        reverse: bool = False,
-        file_contents: bool = False,
-        exclude_my_offers: bool = False,
-        exclude_taken_offers: bool = False,
-        include_completed: bool = False,
-    ) -> list[TradeRecord]:
-        res = await self.fetch(
-            "get_all_offers",
-            {
-                "start": start,
-                "end": end,
-                "sort_key": sort_key,
-                "reverse": reverse,
-                "file_contents": file_contents,
-                "exclude_my_offers": exclude_my_offers,
-                "exclude_taken_offers": exclude_taken_offers,
-                "include_completed": include_completed,
-            },
+        return TakeOfferResponse.from_json_dict(
+            await self.fetch(
+                "take_offer", request.json_serialize_for_transport(tx_config, extra_conditions, timelock_info)
+            )
         )
 
-        records = []
-        if file_contents:
-            optional_offers = [bytes(Offer.from_bech32(o)).hex() for o in res["offers"]]
-        else:
-            optional_offers = [""] * len(res["trade_records"])
-        for record, offer in zip(res["trade_records"], optional_offers):
-            records.append(TradeRecord.from_json_dict_convenience(record, offer))
+    async def get_offer(self, request: GetOffer) -> GetOfferResponse:
+        return GetOfferResponse.from_json_dict(await self.fetch("get_offer", request.to_json_dict()))
 
-        return records
+    async def get_all_offers(self, request: GetAllOffers) -> GetAllOffersResponse:
+        return GetAllOffersResponse.from_json_dict(await self.fetch("get_all_offers", request.to_json_dict()))
 
     async def get_offers_count(self) -> GetOffersCountResponse:
         return GetOffersCountResponse.from_json_dict(await self.fetch("get_offers_count", {}))
 
     async def cancel_offer(
         self,
-        trade_id: bytes32,
+        request: CancelOffer,
         tx_config: TXConfig,
-        fee: int = 0,
-        secure: bool = True,
         extra_conditions: tuple[Condition, ...] = tuple(),
         timelock_info: ConditionValidTimes = ConditionValidTimes(),
-        push: bool = True,
     ) -> CancelOfferResponse:
-        res = await self.fetch(
-            "cancel_offer",
-            {
-                "trade_id": trade_id.hex(),
-                "secure": secure,
-                "fee": fee,
-                "extra_conditions": conditions_to_json_dicts(extra_conditions),
-                "push": push,
-                **tx_config.to_json_dict(),
-                **timelock_info.to_json_dict(),
-            },
+        return CancelOfferResponse.from_json_dict(
+            await self.fetch(
+                "cancel_offer", request.json_serialize_for_transport(tx_config, extra_conditions, timelock_info)
+            )
         )
 
-        return json_deserialize_with_clvm_streamable(res, CancelOfferResponse)
-
     async def cancel_offers(
         self,
+        request: CancelOffers,
         tx_config: TXConfig,
-        batch_fee: int = 0,
-        secure: bool = True,
-        batch_size: int = 5,
-        cancel_all: bool = False,
-        asset_id: Optional[bytes32] = None,
         extra_conditions: tuple[Condition, ...] = tuple(),
         timelock_info: ConditionValidTimes = ConditionValidTimes(),
-        push: bool = True,
     ) -> CancelOffersResponse:
-        res = await self.fetch(
-            "cancel_offers",
-            {
-                "secure": secure,
-                "batch_fee": batch_fee,
-                "batch_size": batch_size,
-                "cancel_all": cancel_all,
-                "asset_id": None if asset_id is None else asset_id.hex(),
-                "extra_conditions": conditions_to_json_dicts(extra_conditions),
-                "push": push,
-                **tx_config.to_json_dict(),
-                **timelock_info.to_json_dict(),
-            },
+        return CancelOffersResponse.from_json_dict(
+            await self.fetch(
+                "cancel_offers", request.json_serialize_for_transport(tx_config, extra_conditions, timelock_info)
+            )
         )
 
-        return json_deserialize_with_clvm_streamable(res, CancelOffersResponse)
-
     async def get_cat_list(self) -> GetCATListResponse:
         return GetCATListResponse.from_json_dict(await self.fetch("get_cat_list", {}))
 
     # NFT wallet
-    async def create_new_nft_wallet(self, did_id: Optional[str], name: Optional[str] = None) -> dict[str, Any]:
-        request = {"wallet_type": "nft_wallet", "did_id": did_id, "name": name}
-        response = await self.fetch("create_new_wallet", request)
-        return response
-
     async def mint_nft(
         self,
         request: NFTMintNFTRequest,
@@ -1135,25 +951,17 @@ class WalletRpcClient(RpcClient):
 
     async def crcat_approve_pending(
         self,
-        wallet_id: uint32,
-        min_amount_to_claim: uint64,
+        request: CRCATApprovePending,
         tx_config: TXConfig,
-        fee: uint64 = uint64(0),
-        push: bool = True,
+        extra_conditions: tuple[Condition, ...] = tuple(),
         timelock_info: ConditionValidTimes = ConditionValidTimes(),
-    ) -> list[TransactionRecord]:
-        response = await self.fetch(
-            "crcat_approve_pending",
-            {
-                "wallet_id": wallet_id,
-                "min_amount_to_claim": min_amount_to_claim,
-                "fee": fee,
-                "push": push,
-                **tx_config.to_json_dict(),
-                **timelock_info.to_json_dict(),
-            },
+    ) -> CRCATApprovePendingResponse:
+        return CRCATApprovePendingResponse.from_json_dict(
+            await self.fetch(
+                "crcat_approve_pending",
+                request.json_serialize_for_transport(tx_config, extra_conditions, timelock_info),
+            )
         )
-        return [TransactionRecord.from_json_dict(tx) for tx in response["transactions"]]
 
     async def gather_signing_info(
         self,

chia/wallet/wallet_singleton_store.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import json
 import logging
 from sqlite3 import Row
-from typing import Optional, Union
 
 from chia_rs import CoinSpend
 from chia_rs.sized_bytes import bytes32
@@ -234,7 +233,7 @@ class WalletSingletonStore:
             )
             await cursor.close()
 
-    async def count(self, wallet_id: Optional[uint32] = None) -> int:
+    async def count(self, wallet_id: uint32 | None = None) -> int:
         sql = "SELECT COUNT(singleton_id) FROM singletons WHERE removed_height=0"
         params: list[uint32] = []
         if wallet_id is not None:
@@ -246,9 +245,9 @@ class WalletSingletonStore:
                 return int(count_row[0])
         return -1  # pragma: no cover
 
-    async def is_empty(self, wallet_id: Optional[uint32] = None) -> bool:
+    async def is_empty(self, wallet_id: uint32 | None = None) -> bool:
         sql = "SELECT 1 FROM singletons WHERE removed_height=0"
-        params: list[Union[uint32, bytes32]] = []
+        params: list[uint32 | bytes32] = []
         if wallet_id is not None:
             sql += " AND wallet_id=?"
             params.append(wallet_id)