Port get_offer to @marshal

Author: Quexington

chia/_tests/cmds/wallet/test_wallet.py

@@ -60,6 +60,8 @@
     GetHeightInfoResponse,
     GetNextAddress,
     GetNextAddressResponse,
+    GetOffer,
+    GetOfferResponse,
     GetTransaction,
     GetTransactions,
     GetTransactionsResponse,
@@ -1163,22 +1165,25 @@ def test_cancel_offer(capsys: object, get_test_cli_clients: tuple[TestRpcClients
 
     # set RPC Client
     class CancelOfferRpcClient(TestWalletRpcClient):
-        async def get_offer(self, trade_id: bytes32, file_contents: bool = False) -> TradeRecord:
-            self.add_to_log("get_offer", (trade_id, file_contents))
+        async def get_offer(self, request: GetOffer) -> GetOfferResponse:
+            self.add_to_log("get_offer", (request.trade_id, request.file_contents))
             offer = Offer.from_bech32(test_offer_file_bech32)
-            return TradeRecord(
-                confirmed_at_index=uint32(0),
-                accepted_at_time=uint64(0),
-                created_at_time=uint64(12345678),
-                is_my_offer=True,
-                sent=uint32(0),
-                sent_to=[],
-                offer=bytes(offer),
-                taken_offer=None,
-                coins_of_interest=offer.get_involved_coins(),
-                trade_id=offer.name(),
-                status=uint32(TradeStatus.PENDING_ACCEPT.value),
-                valid_times=ConditionValidTimes(),
+            return GetOfferResponse(
+                test_offer_file_bech32,
+                TradeRecord(
+                    confirmed_at_index=uint32(0),
+                    accepted_at_time=uint64(0),
+                    created_at_time=uint64(12345678),
+                    is_my_offer=True,
+                    sent=uint32(0),
+                    sent_to=[],
+                    offer=bytes(offer),
+                    taken_offer=None,
+                    coins_of_interest=offer.get_involved_coins(),
+                    trade_id=offer.name(),
+                    status=uint32(TradeStatus.PENDING_ACCEPT.value),
+                    valid_times=ConditionValidTimes(),
+                ),
             )
 
         async def cancel_offer(

chia/_tests/wallet/rpc/test_wallet_rpc.py

@@ -134,6 +134,7 @@
     GetCoinRecordsByNames,
     GetNextAddress,
     GetNotifications,
+    GetOffer,
     GetOfferSummary,
     GetPrivateKey,
     GetSpendableCoins,
@@ -1662,15 +1663,15 @@ async def test_offer_endpoints(wallet_environments: WalletTestFramework, wallet_
 
     await env_1.rpc_client.cancel_offer(offer.name(), wallet_environments.tx_config, secure=False)
 
-    trade_record = await env_1.rpc_client.get_offer(offer.name(), file_contents=True)
+    trade_record = (await env_1.rpc_client.get_offer(GetOffer(offer.name(), file_contents=True))).trade_record
     assert trade_record.offer == bytes(offer)
     assert TradeStatus(trade_record.status) == TradeStatus.CANCELLED
 
     failed_cancel_res = await env_1.rpc_client.cancel_offer(
         offer.name(), wallet_environments.tx_config, fee=uint64(1), secure=True
     )
 
-    trade_record = await env_1.rpc_client.get_offer(offer.name())
+    trade_record = (await env_1.rpc_client.get_offer(GetOffer(offer.name()))).trade_record
     assert TradeStatus(trade_record.status) == TradeStatus.PENDING_CANCEL
 
     create_res = await env_1.rpc_client.create_offer_for_ids(
@@ -1757,7 +1758,7 @@ async def test_offer_endpoints(wallet_environments: WalletTestFramework, wallet_
     )
 
     async def is_trade_confirmed(client: WalletRpcClient, offer: Offer) -> bool:
-        trade_record = await client.get_offer(offer.name())
+        trade_record = (await client.get_offer(GetOffer(offer.name()))).trade_record
         return TradeStatus(trade_record.status) == TradeStatus.CONFIRMED
 
     await time_out_assert(15, is_trade_confirmed, True, env_1.rpc_client, offer)
@@ -1766,7 +1767,7 @@ async def is_trade_confirmed(client: WalletRpcClient, offer: Offer) -> bool:
     def only_ids(trades: list[TradeRecord]) -> list[bytes32]:
         return [t.trade_id for t in trades]
 
-    trade_record = await env_1.rpc_client.get_offer(offer.name())
+    trade_record = (await env_1.rpc_client.get_offer(GetOffer(offer.name()))).trade_record
     all_offers = await env_1.rpc_client.get_all_offers(include_completed=True)  # confirmed at index descending
     assert len(all_offers) == 2
     assert only_ids(all_offers) == only_ids([trade_record, new_trade_record])

chia/cmds/wallet_funcs.py

@@ -66,6 +66,7 @@
     FungibleAsset,
     GetNextAddress,
     GetNotifications,
+    GetOffer,
     GetTransaction,
     GetTransactions,
     GetWalletBalance,
@@ -787,7 +788,7 @@ async def get_offers(
                 start = end
                 end += batch_size
         else:
-            records = [await wallet_client.get_offer(offer_id, file_contents)]
+            records = [(await wallet_client.get_offer(GetOffer(offer_id, file_contents))).trade_record]
             if filepath is not None:
                 with open(pathlib.Path(filepath), "w") as file:
                     file.write(Offer.from_bytes(records[0].offer).to_bech32())
@@ -919,7 +920,7 @@ async def cancel_offer(
     condition_valid_times: ConditionValidTimes,
 ) -> list[TransactionRecord]:
     async with get_wallet_client(root_path, wallet_rpc_port, fp) as (wallet_client, fingerprint, config):
-        trade_record = await wallet_client.get_offer(offer_id, file_contents=True)
+        trade_record = (await wallet_client.get_offer(GetOffer(offer_id, file_contents=True))).trade_record
         await print_trade_record(trade_record, wallet_client, summaries=True)
 
         cli_confirm(f"Are you sure you wish to cancel offer with ID: {trade_record.trade_id}? (y/n): ")

chia/data_layer/data_layer.py

@@ -79,6 +79,7 @@
     DLUpdateMultiple,
     DLUpdateMultipleUpdates,
     DLUpdateRoot,
+    GetOffer,
     LauncherRootPair,
     LogIn,
     TakeOffer,
@@ -1282,7 +1283,9 @@ async def cancel_offer(self, trade_id: bytes32, secure: bool, fee: uint64) -> No
         store_ids: list[bytes32] = []
 
         if not secure:
-            trade_record = await self.wallet_rpc.get_offer(trade_id=trade_id, file_contents=True)
+            trade_record = (
+                await self.wallet_rpc.get_offer(GetOffer(trade_id=trade_id, file_contents=True))
+            ).trade_record
             trading_offer = TradingOffer.from_bytes(trade_record.offer)
             summary = await DataLayerWallet.get_offer_summary(offer=trading_offer)
             store_ids = [offered.launcher_id for offered in summary.offered]

chia/wallet/wallet_request_types.py

@@ -1947,6 +1947,33 @@ class TakeOfferResponse(_OfferEndpointResponse):  # Inheriting for de-dup sake
     pass
 
 
+@streamable
+@dataclass(frozen=True)
+class GetOffer(Streamable):
+    trade_id: bytes32
+    file_contents: bool = False
+
+
+@streamable
+@dataclass(frozen=True)
+class GetOfferResponse(Streamable):
+    offer: Optional[str]
+    trade_record: TradeRecord
+
+    def to_json_dict(self) -> dict[str, Any]:
+        return {**super().to_json_dict(), "trade_record": self.trade_record.to_json_dict_convenience()}
+
+    @classmethod
+    def from_json_dict(cls, json_dict: dict[str, Any]) -> Self:
+        return cls(
+            offer=json_dict["offer"],
+            trade_record=TradeRecord.from_json_dict_convenience(
+                json_dict["trade_record"],
+                bytes(Offer.from_bech32(json_dict["offer"])).hex() if json_dict["offer"] is not None else "",
+            ),
+        )
+
+
 @streamable
 @dataclass(frozen=True)
 class CancelOfferResponse(TransactionEndpointResponse):

chia/wallet/wallet_rpc_api.py

@@ -196,6 +196,8 @@
     GetNextAddressResponse,
     GetNotifications,
     GetNotificationsResponse,
+    GetOffer,
+    GetOfferResponse,
     GetOffersCountResponse,
     GetOfferSummary,
     GetOfferSummaryResponse,
@@ -2353,18 +2355,20 @@ async def take_offer(
             trade_record,
         )
 
-    async def get_offer(self, request: dict[str, Any]) -> EndpointResult:
+    @marshal
+    async def get_offer(self, request: GetOffer) -> GetOfferResponse:
         trade_mgr = self.service.wallet_state_manager.trade_manager
 
-        trade_id = bytes32.from_hexstr(request["trade_id"])
-        file_contents: bool = request.get("file_contents", False)
-        trade_record: Optional[TradeRecord] = await trade_mgr.get_trade_by_id(bytes32(trade_id))
+        trade_record: Optional[TradeRecord] = await trade_mgr.get_trade_by_id(request.trade_id)
         if trade_record is None:
-            raise ValueError(f"No trade with trade id: {trade_id.hex()}")
+            raise ValueError(f"No trade with trade id: {request.trade_id.hex()}")
 
         offer_to_return: bytes = trade_record.offer if trade_record.taken_offer is None else trade_record.taken_offer
-        offer_value: Optional[str] = Offer.from_bytes(offer_to_return).to_bech32() if file_contents else None
-        return {"trade_record": trade_record.to_json_dict_convenience(), "offer": offer_value}
+        offer: Optional[str] = Offer.from_bytes(offer_to_return).to_bech32() if request.file_contents else None
+        return GetOfferResponse(
+            offer,
+            trade_record,
+        )
 
     async def get_all_offers(self, request: dict[str, Any]) -> EndpointResult:
         trade_mgr = self.service.wallet_state_manager.trade_manager

chia/wallet/wallet_rpc_client.py

@@ -107,6 +107,8 @@
     GetNextAddressResponse,
     GetNotifications,
     GetNotificationsResponse,
+    GetOffer,
+    GetOfferResponse,
     GetOffersCountResponse,
     GetOfferSummary,
     GetOfferSummaryResponse,
@@ -702,10 +704,8 @@ async def take_offer(
             )
         )
 
-    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_offer(self, request: GetOffer) -> GetOfferResponse:
+        return GetOfferResponse.from_json_dict(await self.fetch("get_offer", request.to_json_dict()))
 
     async def get_all_offers(
         self,