Port create_offer_for_ids to @marshal

Quexington · Quexington · commit c03c0b9bc5e6 · 2025-09-10T11:11:56.000-07:00
diff --git a/chia/_tests/wallet/rpc/test_wallet_rpc.py b/chia/_tests/wallet/rpc/test_wallet_rpc.py
@@ -80,6 +80,7 @@
 from chia.wallet.derive_keys import master_sk_to_wallet_sk, master_sk_to_wallet_sk_unhardened
 from chia.wallet.did_wallet.did_wallet import DIDWallet
 from chia.wallet.nft_wallet.nft_wallet import NFTWallet
+from chia.wallet.puzzle_drivers import PuzzleInfo
 from chia.wallet.puzzles.clawback.metadata import AutoClaimSettings
 from chia.wallet.puzzles.p2_delegated_puzzle_or_hidden_puzzle import puzzle_hash_for_pk
 from chia.wallet.signer_protocol import UnsignedTransaction
@@ -113,6 +114,7 @@
     CheckOfferValidity,
     ClawbackPuzzleDecoratorOverride,
     CombineCoins,
+    CreateOfferForIDs,
     DefaultCAT,
     DeleteKey,
     DeleteNotifications,
@@ -1546,28 +1548,29 @@ async def test_offer_endpoints(wallet_environments: WalletTestFramework, wallet_
         )
     # Create an offer of 5 chia for one CAT
     await env_1.rpc_client.create_offer_for_ids(
-        {uint32(1): -5, cat_asset_id.hex(): 1}, wallet_environments.tx_config, validate_only=True
+        CreateOfferForIDs(offer={str(1): "-5", cat_asset_id.hex(): "1"}, validate_only=True),
+        tx_config=wallet_environments.tx_config,
     )
     all_offers = await env_1.rpc_client.get_all_offers()
     assert len(all_offers) == 0
 
-    driver_dict: dict[str, Any] = {
-        cat_asset_id.hex(): {
-            "type": "CAT",
-            "tail": "0x" + cat_asset_id.hex(),
-            **(
-                {}
-                if wallet_type is CATWallet
-                else {"also": {"type": "revocation layer", "hidden_puzzle_hash": "0x" + bytes32.zeros.hex()}}
-            ),
-        }
+    driver_dict = {
+        cat_asset_id: PuzzleInfo(
+            {
+                "type": "CAT",
+                "tail": "0x" + cat_asset_id.hex(),
+                **(
+                    {}
+                    if wallet_type is CATWallet
+                    else {"also": {"type": "revocation layer", "hidden_puzzle_hash": "0x" + bytes32.zeros.hex()}}
+                ),
+            }
+        )
     }
 
     create_res = await env_1.rpc_client.create_offer_for_ids(
-        {uint32(1): -5, cat_asset_id.hex(): 1},
-        wallet_environments.tx_config,
-        driver_dict=driver_dict,
-        fee=uint64(1),
+        CreateOfferForIDs(offer={str(1): "-5", cat_asset_id.hex(): "1"}, driver_dict=driver_dict, fee=uint64(1)),
+        tx_config=wallet_environments.tx_config,
     )
     offer = create_res.offer
 
@@ -1578,7 +1581,7 @@ async def test_offer_endpoints(wallet_environments: WalletTestFramework, wallet_
     assert summary == {
         "offered": {"xch": 5},
         "requested": {cat_asset_id.hex(): 1},
-        "infos": driver_dict,
+        "infos": {key.hex(): info.info for key, info in driver_dict.items()},
         "fees": 1,
         "additions": [c.name().hex() for c in offer.additions()],
         "removals": [c.name().hex() for c in offer.removals()],
@@ -1622,7 +1625,8 @@ async def test_offer_endpoints(wallet_environments: WalletTestFramework, wallet_
     assert TradeStatus(trade_record.status) == TradeStatus.PENDING_CANCEL
 
     create_res = await env_1.rpc_client.create_offer_for_ids(
-        {uint32(1): -5, cat_wallet_id: 1}, wallet_environments.tx_config, fee=uint64(1)
+        CreateOfferForIDs(offer={str(1): "-5", str(cat_wallet_id): "1"}, fee=uint64(1)),
+        tx_config=wallet_environments.tx_config,
     )
     all_offers = await env_1.rpc_client.get_all_offers()
     assert len(all_offers) == 2
@@ -1736,9 +1740,8 @@ def only_ids(trades: list[TradeRecord]) -> list[bytes32]:
     assert len(all_offers) == 2
 
     await env_1.rpc_client.create_offer_for_ids(
-        {uint32(1): -5, cat_asset_id.hex(): 1},
-        wallet_environments.tx_config,
-        driver_dict=driver_dict,
+        CreateOfferForIDs(offer={str(1): "-5", cat_asset_id.hex(): "1"}, driver_dict=driver_dict),
+        tx_config=wallet_environments.tx_config,
     )
     assert (
         len([o for o in await env_1.rpc_client.get_all_offers() if o.status == TradeStatus.PENDING_ACCEPT.value]) == 2
@@ -1774,14 +1777,12 @@ def only_ids(trades: list[TradeRecord]) -> list[bytes32]:
     )
 
     await env_1.rpc_client.create_offer_for_ids(
-        {uint32(1): -5, cat_asset_id.hex(): 1},
-        wallet_environments.tx_config,
-        driver_dict=driver_dict,
+        CreateOfferForIDs(offer={str(1): "-5", cat_asset_id.hex(): "1"}, driver_dict=driver_dict),
+        tx_config=wallet_environments.tx_config,
     )
     await env_1.rpc_client.create_offer_for_ids(
-        {uint32(1): 5, cat_asset_id.hex(): -1},
-        wallet_environments.tx_config,
-        driver_dict=driver_dict,
+        CreateOfferForIDs(offer={str(1): "5", cat_asset_id.hex(): "-1"}, driver_dict=driver_dict),
+        tx_config=wallet_environments.tx_config,
     )
     assert (
         len([o for o in await env_1.rpc_client.get_all_offers() if o.status == TradeStatus.PENDING_ACCEPT.value]) == 2
@@ -1828,9 +1829,8 @@ def only_ids(trades: list[TradeRecord]) -> list[bytes32]:
     )
 
     await env_1.rpc_client.create_offer_for_ids(
-        {uint32(1): 5, cat_asset_id.hex(): -1},
-        wallet_environments.tx_config,
-        driver_dict=driver_dict,
+        CreateOfferForIDs(offer={str(1): "5", cat_asset_id.hex(): "-1"}, driver_dict=driver_dict),
+        tx_config=wallet_environments.tx_config,
     )
     assert (
         len([o for o in await env_1.rpc_client.get_all_offers() if o.status == TradeStatus.PENDING_ACCEPT.value]) == 1
@@ -1846,9 +1846,11 @@ def only_ids(trades: list[TradeRecord]) -> list[bytes32]:
 
     with pytest.raises(ValueError, match="not currently supported"):
         await env_1.rpc_client.create_offer_for_ids(
-            {uint32(1): -5, cat_asset_id.hex(): 1},
+            CreateOfferForIDs(
+                offer={str(1): "-5", cat_asset_id.hex(): "1"},
+                driver_dict=driver_dict,
+            ),
             wallet_environments.tx_config,
-            driver_dict=driver_dict,
             timelock_info=ConditionValidTimes(min_secs_since_created=uint64(1)),
         )
 
diff --git a/chia/cmds/wallet_funcs.py b/chia/cmds/wallet_funcs.py
@@ -52,6 +52,7 @@
     CATSpend,
     CATSpendResponse,
     ClawbackPuzzleDecoratorOverride,
+    CreateOfferForIDs,
     DeleteNotifications,
     DeleteUnconfirmedTransactions,
     DIDFindLostDID,
@@ -507,16 +508,16 @@ async def make_offer(
         if offers == [] or requests == []:
             print("Not creating offer: Must be offering and requesting at least one asset")
         else:
-            offer_dict: dict[Union[uint32, str], int] = {}
-            driver_dict: dict[str, Any] = {}
+            offer_dict: dict[str, str] = {}
+            driver_dict: dict[bytes32, PuzzleInfo] = {}
             printable_dict: dict[str, tuple[str, int, int]] = {}  # dict[asset_name, tuple[amount, unit, multiplier]]
             royalty_assets: list[RoyaltyAsset] = []
             fungible_assets: list[FungibleAsset] = []
             for item in [*offers, *requests]:
                 name, amount = tuple(item.split(":")[0:2])
                 try:
                     b32_id = bytes32.from_hexstr(name)
-                    id: Union[uint32, str] = b32_id.hex()
+                    id: str = b32_id.hex()
                     result = await wallet_client.cat_asset_id_to_name(CATAssetIDToName(b32_id))
                     if result.name is not None:
                         name = result.name
@@ -535,7 +536,7 @@ async def make_offer(
                             id = info.launcher_id.hex()
                             assert isinstance(id, str)
                             if item in requests:
-                                driver_dict[id] = {
+                                puzzle_info_dict: dict[str, Any] = {
                                     "type": "singleton",
                                     "launcher_id": "0x" + id,
                                     "launcher_ph": "0x" + info.launcher_puzhash.hex(),
@@ -548,7 +549,7 @@ async def make_offer(
                                 if info.supports_did:
                                     assert info.royalty_puzzle_hash is not None
                                     assert info.royalty_percentage is not None
-                                    driver_dict[id]["also"]["also"] = {
+                                    puzzle_info_dict["also"]["also"] = {
                                         "type": "ownership",
                                         "owner": "()",
                                         "transfer_program": {
@@ -565,17 +566,18 @@ async def make_offer(
                                             info.royalty_percentage,
                                         )
                                     )
+                                driver_dict[info.launcher_id] = PuzzleInfo(puzzle_info_dict)
                         else:
                             id = decode_puzzle_hash(name).hex()
                             assert hrp is not None
                             unit = units[hrp]
                     except ValueError:
-                        id = uint32(name)
-                        if id == 1:
+                        id = str(uint32(name))
+                        if id == "1":
                             name = "XCH"
                             unit = units["chia"]
                         else:
-                            name = (await wallet_client.get_cat_name(CATGetName(id))).name
+                            name = (await wallet_client.get_cat_name(CATGetName(uint32(name)))).name
                             unit = units["cat"]
                         if item in offers:
                             fungible_assets.append(FungibleAsset(name, uint64(abs(int(Decimal(amount) * unit)))))
@@ -585,7 +587,7 @@ async def make_offer(
                     print("Not creating offer: Cannot offer and request the same asset in a trade")
                     break
                 else:
-                    offer_dict[id] = int(Decimal(amount) * unit) * multiplier
+                    offer_dict[id] = str(int(Decimal(amount) * unit) * multiplier)
             else:
                 print("Creating Offer")
                 print("--------------")
@@ -642,9 +644,11 @@ async def make_offer(
 
                 with filepath.open(mode="w") as file:
                     res = await wallet_client.create_offer_for_ids(
-                        offer_dict,
-                        driver_dict=driver_dict,
-                        fee=fee,
+                        CreateOfferForIDs(
+                            offer=offer_dict,
+                            driver_dict=driver_dict,
+                            fee=fee,
+                        ),
                         tx_config=CMDTXConfigLoader(
                             reuse_puzhash=reuse_puzhash,
                         ).to_tx_config(units["chia"], config, fingerprint),
diff --git a/chia/data_layer/data_layer.py b/chia/data_layer/data_layer.py
@@ -63,12 +63,14 @@
 from chia.util.async_pool import Job, QueuedAsyncPool
 from chia.util.path import path_from_root
 from chia.util.task_referencer import create_referenced_task
+from chia.wallet.puzzle_drivers import Solver
 from chia.wallet.trade_record import TradeRecord
 from chia.wallet.trading.offer import Offer as TradingOffer
 from chia.wallet.transaction_record import TransactionRecord
 from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG
 from chia.wallet.wallet_request_types import (
     CreateNewDL,
+    CreateOfferForIDs,
     DLDeleteMirror,
     DLGetMirrors,
     DLHistory,
@@ -1137,34 +1139,38 @@ async def make_offer(
         async with self.data_store.transaction():
             our_store_proofs = await self.process_offered_stores(offer_stores=maker)
 
-            offer_dict: dict[Union[uint32, str], int] = {
-                **{offer_store.store_id.hex(): -1 for offer_store in maker},
-                **{offer_store.store_id.hex(): 1 for offer_store in taker},
+            offer_dict: dict[str, str] = {
+                **{offer_store.store_id.hex(): "-1" for offer_store in maker},
+                **{offer_store.store_id.hex(): "1" for offer_store in taker},
             }
 
-            solver: dict[str, Any] = {
-                "0x" + our_offer_store.store_id.hex(): {
-                    "new_root": "0x" + our_store_proofs[our_offer_store.store_id].proofs[0].root().hex(),
-                    "dependencies": [
-                        {
-                            "launcher_id": "0x" + their_offer_store.store_id.hex(),
-                            "values_to_prove": [
-                                "0x" + leaf_hash(key=entry.key, value=entry.value).hex()
-                                for entry in their_offer_store.inclusions
-                            ],
-                        }
-                        for their_offer_store in taker
-                    ],
+            solver = Solver(
+                {
+                    "0x" + our_offer_store.store_id.hex(): {
+                        "new_root": "0x" + our_store_proofs[our_offer_store.store_id].proofs[0].root().hex(),
+                        "dependencies": [
+                            {
+                                "launcher_id": "0x" + their_offer_store.store_id.hex(),
+                                "values_to_prove": [
+                                    "0x" + leaf_hash(key=entry.key, value=entry.value).hex()
+                                    for entry in their_offer_store.inclusions
+                                ],
+                            }
+                            for their_offer_store in taker
+                        ],
+                    }
+                    for our_offer_store in maker
                 }
-                for our_offer_store in maker
-            }
+            )
 
             res = await self.wallet_rpc.create_offer_for_ids(
-                offer_dict=offer_dict,
-                solver=solver,
-                driver_dict={},
-                fee=fee,
-                validate_only=False,
+                CreateOfferForIDs(
+                    offer=offer_dict,
+                    solver=solver,
+                    driver_dict={},
+                    fee=fee,
+                    validate_only=False,
+                ),
                 # TODO: probably shouldn't be default but due to peculiarities in the RPC, we're using a stop gap.
                 # This is not a change in behavior, the default was already implicit.
                 tx_config=DEFAULT_TX_CONFIG,
diff --git a/chia/util/streamable.py b/chia/util/streamable.py
@@ -288,6 +288,8 @@ def recurse_jsonify(
     """
     if next_recursion_step is None:
         next_recursion_step = recurse_jsonify
+    if getattr(d, "json_serialization_override", None) is not None:
+        return d.json_serialization_override(d)
     if dataclasses.is_dataclass(d):
         new_dict = {}
         for field in dataclasses.fields(d):
diff --git a/chia/wallet/puzzle_drivers.py b/chia/wallet/puzzle_drivers.py
@@ -1,7 +1,6 @@
 from __future__ import annotations
 
-from dataclasses import dataclass
-from typing import Any, Optional
+from typing import Any, Optional, Self
 
 from clvm.SExp import SExp
 from clvm_tools.binutils import assemble, type_for_atom
@@ -17,7 +16,6 @@
 """
 
 
-@dataclass(frozen=True)
 class PuzzleInfo:
     """
     There are two 'magic' keys in a PuzzleInfo object:
@@ -27,6 +25,10 @@ class PuzzleInfo:
 
     info: dict[str, Any]
 
+    def __init__(self, info: dict[str, Any]) -> None:
+        self.info = info
+        self.__post_init__()
+
     def __post_init__(self) -> None:
         if "type" not in self.info:
             raise ValueError("A type is required to initialize a puzzle driver")
@@ -74,11 +76,25 @@ def check_type(self, types: list[str]) -> bool:
         else:
             return False
 
+    # Methods to make this a valid Streamable member
+    # Should not be being serialized as bytes
+    stream = None
+    parse = None
+
+    def to_json_dict(self) -> dict[str, Any]:
+        return self.info
+
+    @classmethod
+    def from_json_dict(cls, json_dict: dict[str, Any]) -> Self:
+        return cls(json_dict)
+
 
-@dataclass(frozen=True)
 class Solver:
     info: dict[str, Any]
 
+    def __init__(self, info: dict[str, Any]) -> None:
+        self.info = info
+
     def __getitem__(self, item: str) -> Any:
         value = self.info[item]
         return decode_info_value(Solver, value)
@@ -92,6 +108,17 @@ def __eq__(self, other: object) -> bool:
                 return False
         return True
 
+    # Methods to make this a valid Streamable member
+    stream = None
+    parse = None
+
+    def to_json_dict(self) -> dict[str, Any]:
+        return self.info
+
+    @classmethod
+    def from_json_dict(cls, json_dict: dict[str, Any]) -> Self:
+        return cls(json_dict)
+
 
 def decode_info_value(cls: Any, value: Any) -> Any:
     if isinstance(value, dict):
diff --git a/chia/wallet/trade_manager.py b/chia/wallet/trade_manager.py
@@ -429,7 +429,7 @@ async def create_offer_for_ids(
         validate_only: bool = False,
         extra_conditions: tuple[Condition, ...] = tuple(),
         taking: bool = False,
-    ) -> Union[tuple[Literal[True], TradeRecord, None], tuple[Literal[False], None, str]]:
+    ) -> tuple[Literal[True], TradeRecord, None]:
         if driver_dict is None:
             driver_dict = {}
         if solver is None:
diff --git a/chia/wallet/wallet_request_types.py b/chia/wallet/wallet_request_types.py
diff --git a/chia/wallet/wallet_rpc_api.py b/chia/wallet/wallet_rpc_api.py
diff --git a/chia/wallet/wallet_rpc_client.py b/chia/wallet/wallet_rpc_client.py
