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

chia/data_layer/data_layer.py

@@ -56,10 +56,8 @@ from chia.data_layer.download_data import (
     write_files_for_root,
 )
 from chia.data_layer.singleton_record import SingletonRecord
+from chia.protocols.outbound_message import NodeType
 from chia.rpc.rpc_server import StateChangedProtocol, default_get_connections
-from chia.rpc.wallet_request_types import LogIn
-from chia.rpc.wallet_rpc_client import WalletRpcClient
-from chia.server.outbound_message import NodeType
 from chia.server.server import ChiaServer
 from chia.server.ws_connection import WSChiaConnection
 from chia.util.async_pool import Job, QueuedAsyncPool
@@ -69,6 +67,32 @@ 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,
+    DLDeleteMirror,
+    DLGetMirrors,
+    DLHistory,
+    DLLatestSingleton,
+    DLNewMirror,
+    DLStopTracking,
+    DLTrackNew,
+    DLUpdateMultiple,
+    DLUpdateMultipleUpdates,
+    DLUpdateRoot,
+    LauncherRootPair,
+    LogIn,
+)
+from chia.wallet.wallet_rpc_client import WalletRpcClient
+
+
+def server_files_path_from_config(config: dict[str, Any], root_path: Path) -> Path:
+    server_files_replaced: Path = path_from_root(
+        root_path,
+        config.get("server_files_location", "data_layer/db/server_files_location_CHALLENGE").replace(
+            "CHALLENGE", config["selected_network"]
+        ),
+    )
+    return server_files_replaced
 
 
 async def get_plugin_info(plugin_remote: PluginRemote) -> tuple[PluginRemote, dict[str, Any]]:
@@ -162,9 +186,7 @@ class DataLayer:
             #       need this.
             name = None
 
-        server_files_replaced: str = config.get(
-            "server_files_location", "data_layer/db/server_files_location_CHALLENGE"
-        ).replace("CHALLENGE", config["selected_network"])
+        server_files_replaced = server_files_path_from_config(config, root_path)
 
         db_path_replaced: str = config["database_path"].replace("CHALLENGE", config["selected_network"])
 
@@ -174,7 +196,7 @@ class DataLayer:
             wallet_rpc_init=wallet_rpc_init,
             log=logging.getLogger(name if name is None else __name__),
             db_path=path_from_root(root_path, db_path_replaced),
-            server_files_location=path_from_root(root_path, server_files_replaced),
+            server_files_location=server_files_replaced,
             downloaders=downloaders,
             uploaders=uploaders,
             maximum_full_file_count=config.get("maximum_full_file_count", 1),
@@ -240,12 +262,12 @@ class DataLayer:
         return result.fingerprint
 
     async def create_store(self, fee: uint64, root: bytes32 = bytes32.zeros) -> tuple[list[TransactionRecord], bytes32]:
-        txs, store_id = await self.wallet_rpc.create_new_dl(root, fee)
-        res = await self.data_store.create_tree(store_id=store_id)
+        create_res = await self.wallet_rpc.create_new_dl(CreateNewDL(root=root, fee=fee, push=True), DEFAULT_TX_CONFIG)
+        res = await self.data_store.create_tree(store_id=create_res.launcher_id)
         if res is None:
             self.log.fatal("failed creating store")
         self.initialized = True
-        return txs, store_id
+        return create_res.transactions, create_res.launcher_id
 
     async def batch_update(
         self,
@@ -293,13 +315,15 @@ class DataLayer:
         await self.data_store.clean_node_table()
 
         if submit_on_chain:
-            update_dictionary: dict[bytes32, bytes32] = {}
+            updates: list[LauncherRootPair] = []
             for store_id in store_ids:
                 await self._update_confirmation_status(store_id=store_id)
                 root_hash = await self._get_publishable_root_hash(store_id=store_id)
-                update_dictionary[store_id] = root_hash
-            transaction_records = await self.wallet_rpc.dl_update_multiple(update_dictionary=update_dictionary, fee=fee)
-            return transaction_records
+                updates.append(LauncherRootPair(store_id, root_hash))
+            response = await self.wallet_rpc.dl_update_multiple(
+                DLUpdateMultiple(updates=DLUpdateMultipleUpdates(updates), fee=fee), DEFAULT_TX_CONFIG
+            )
+            return response.transactions
         else:
             return []
 
@@ -321,15 +345,17 @@ class DataLayer:
 
     async def submit_all_pending_roots(self, fee: uint64) -> list[TransactionRecord]:
         pending_roots = await self.data_store.get_all_pending_batches_roots()
-        update_dictionary: dict[bytes32, bytes32] = {}
+        updates: list[LauncherRootPair] = []
         if len(pending_roots) == 0:
             raise Exception("No pending roots found to submit")
         for pending_root in pending_roots:
             root_hash = pending_root.node_hash if pending_root.node_hash is not None else self.none_bytes
-            update_dictionary[pending_root.store_id] = root_hash
+            updates.append(LauncherRootPair(pending_root.store_id, root_hash))
             await self.data_store.change_root_status(pending_root, Status.PENDING)
-        transaction_records = await self.wallet_rpc.dl_update_multiple(update_dictionary=update_dictionary, fee=fee)
-        return transaction_records
+        response = await self.wallet_rpc.dl_update_multiple(
+            DLUpdateMultiple(updates=DLUpdateMultipleUpdates(updates), fee=fee), DEFAULT_TX_CONFIG
+        )
+        return response.transactions
 
     async def batch_insert(
         self,
@@ -371,11 +397,17 @@ class DataLayer:
     ) -> TransactionRecord:
         await self._update_confirmation_status(store_id=store_id)
         root_hash = await self._get_publishable_root_hash(store_id=store_id)
-        transaction_record = await self.wallet_rpc.dl_update_root(
-            launcher_id=store_id,
-            new_root=root_hash,
-            fee=fee,
-        )
+        transaction_record = (
+            await self.wallet_rpc.dl_update_root(
+                DLUpdateRoot(
+                    launcher_id=store_id,
+                    new_root=root_hash,
+                    fee=fee,
+                    push=True,
+                ),
+                DEFAULT_TX_CONFIG,
+            )
+        ).tx_record
         return transaction_record
 
     async def get_key_value_hash(
@@ -455,7 +487,7 @@ class DataLayer:
         return res
 
     async def get_root(self, store_id: bytes32) -> Optional[SingletonRecord]:
-        latest = await self.wallet_rpc.dl_latest_singleton(store_id, True)
+        latest = (await self.wallet_rpc.dl_latest_singleton(DLLatestSingleton(store_id, True))).singleton
         if latest is None:
             self.log.error(f"Failed to get root for {store_id.hex()}")
         return latest
@@ -470,7 +502,7 @@ class DataLayer:
         return res.node_hash
 
     async def get_root_history(self, store_id: bytes32) -> list[SingletonRecord]:
-        records = await self.wallet_rpc.dl_history(store_id)
+        records = (await self.wallet_rpc.dl_history(DLHistory(store_id))).history
         if records is None:
             self.log.error(f"Failed to get root history for {store_id.hex()}")
         root_history = []
@@ -487,7 +519,7 @@ class DataLayer:
                 root = await self.data_store.get_tree_root(store_id=store_id)
             except Exception:
                 root = None
-            singleton_record: Optional[SingletonRecord] = await self.wallet_rpc.dl_latest_singleton(store_id, True)
+            singleton_record = (await self.wallet_rpc.dl_latest_singleton(DLLatestSingleton(store_id, True))).singleton
             if singleton_record is None:
                 return
             if root is None:
@@ -510,11 +542,15 @@ class DataLayer:
                     "Maybe we're doing a batch update."
                 )
                 return
-            wallet_history = await self.wallet_rpc.dl_history(
-                launcher_id=store_id,
-                min_generation=uint32(root.generation + 1),
-                max_generation=singleton_record.generation,
-            )
+            wallet_history = (
+                await self.wallet_rpc.dl_history(
+                    DLHistory(
+                        launcher_id=store_id,
+                        min_generation=uint32(root.generation + 1),
+                        max_generation=singleton_record.generation,
+                    )
+                )
+            ).history
             new_hashes = [record.root for record in reversed(wallet_history)]
             root_hash = self.none_bytes if root.node_hash is None else root.node_hash
             generation_shift = 0
@@ -538,7 +574,7 @@ class DataLayer:
             await self.data_store.clear_pending_roots(store_id=store_id)
 
     async def fetch_and_validate(self, store_id: bytes32) -> None:
-        singleton_record: Optional[SingletonRecord] = await self.wallet_rpc.dl_latest_singleton(store_id, True)
+        singleton_record = (await self.wallet_rpc.dl_latest_singleton(DLLatestSingleton(store_id, True))).singleton
         if singleton_record is None:
             self.log.info(f"Fetch data: No singleton record for {store_id}.")
             return
@@ -577,11 +613,15 @@ class DataLayer:
                 f"Server used: {url}."
             )
 
-            to_download = await self.wallet_rpc.dl_history(
-                launcher_id=store_id,
-                min_generation=uint32(root.generation + 1),
-                max_generation=singleton_record.generation,
-            )
+            to_download = (
+                await self.wallet_rpc.dl_history(
+                    DLHistory(
+                        launcher_id=store_id,
+                        min_generation=uint32(root.generation + 1),
+                        max_generation=singleton_record.generation,
+                    )
+                )
+            ).history
             try:
                 proxy_url = self.config.get("proxy_url", None)
                 success = await insert_from_delta_file(
@@ -653,7 +693,7 @@ class DataLayer:
         return None
 
     async def clean_old_full_tree_files(self, store_id: bytes32) -> None:
-        singleton_record: Optional[SingletonRecord] = await self.wallet_rpc.dl_latest_singleton(store_id, True)
+        singleton_record = (await self.wallet_rpc.dl_latest_singleton(DLLatestSingleton(store_id, True))).singleton
         if singleton_record is None:
             return
         await self._update_confirmation_status(store_id=store_id)
@@ -671,7 +711,7 @@ class DataLayer:
 
     async def upload_files(self, store_id: bytes32) -> None:
         uploaders = await self.get_uploaders(store_id)
-        singleton_record: Optional[SingletonRecord] = await self.wallet_rpc.dl_latest_singleton(store_id, True)
+        singleton_record = (await self.wallet_rpc.dl_latest_singleton(DLLatestSingleton(store_id, True))).singleton
         if singleton_record is None:
             self.log.info(f"Upload files: no on-chain record for {store_id}.")
             return
@@ -738,7 +778,7 @@ class DataLayer:
         root = await self.data_store.get_tree_root(store_id=store_id)
         latest_generation = root.generation
         full_tree_first_publish_generation = max(0, latest_generation - self.maximum_full_file_count + 1)
-        singleton_record: Optional[SingletonRecord] = await self.wallet_rpc.dl_latest_singleton(store_id, True)
+        singleton_record = (await self.wallet_rpc.dl_latest_singleton(DLLatestSingleton(store_id, True))).singleton
         if singleton_record is None:
             self.log.error(f"No singleton record found for: {store_id}")
             return
@@ -783,7 +823,7 @@ class DataLayer:
     async def subscribe(self, store_id: bytes32, urls: list[str]) -> Subscription:
         parsed_urls = [url.rstrip("/") for url in urls]
         subscription = Subscription(store_id, [ServerInfo(url, 0, 0) for url in parsed_urls])
-        await self.wallet_rpc.dl_track_new(subscription.store_id)
+        await self.wallet_rpc.dl_track_new(DLTrackNew(subscription.store_id))
         async with self.subscription_lock:
             await self.data_store.subscribe(subscription)
         self.log.info(f"Done adding subscription: {subscription.store_id}")
@@ -835,7 +875,7 @@ class DataLayer:
                     )
 
         # stop tracking first, then unsubscribe from the data store
-        await self.wallet_rpc.dl_stop_tracking(store_id)
+        await self.wallet_rpc.dl_stop_tracking(DLStopTracking(store_id))
         await self.data_store.unsubscribe(store_id)
         if not retain_data:
             await self.data_store.delete_store_data(store_id)
@@ -854,26 +894,27 @@ class DataLayer:
     async def add_mirror(self, store_id: bytes32, urls: list[str], amount: uint64, fee: uint64) -> None:
         if not urls:
             raise RuntimeError("URL list can't be empty")
-        bytes_urls = [bytes(url, "utf8") for url in urls]
-        await self.wallet_rpc.dl_new_mirror(store_id, amount, bytes_urls, fee)
+        await self.wallet_rpc.dl_new_mirror(
+            DLNewMirror(launcher_id=store_id, amount=amount, urls=urls, fee=fee, push=True), DEFAULT_TX_CONFIG
+        )
 
     async def delete_mirror(self, coin_id: bytes32, fee: uint64) -> None:
-        await self.wallet_rpc.dl_delete_mirror(coin_id, fee)
+        await self.wallet_rpc.dl_delete_mirror(DLDeleteMirror(coin_id=coin_id, fee=fee, push=True), DEFAULT_TX_CONFIG)
 
     async def get_mirrors(self, store_id: bytes32) -> list[Mirror]:
-        mirrors: list[Mirror] = await self.wallet_rpc.dl_get_mirrors(store_id)
+        mirrors: list[Mirror] = (await self.wallet_rpc.dl_get_mirrors(DLGetMirrors(store_id))).mirrors
         return [mirror for mirror in mirrors if mirror.urls]
 
     async def update_subscriptions_from_wallet(self, store_id: bytes32) -> None:
-        mirrors: list[Mirror] = await self.wallet_rpc.dl_get_mirrors(store_id)
+        mirrors: list[Mirror] = (await self.wallet_rpc.dl_get_mirrors(DLGetMirrors(store_id))).mirrors
         urls: list[str] = []
         for mirror in mirrors:
-            urls += [url.decode("utf8") for url in mirror.urls]
+            urls += mirror.urls
         urls = [url.rstrip("/") for url in urls]
         await self.data_store.update_subscriptions_from_wallet(store_id, urls)
 
     async def get_owned_stores(self) -> list[SingletonRecord]:
-        return await self.wallet_rpc.dl_owned_singletons()
+        return (await self.wallet_rpc.dl_owned_singletons()).singletons
 
     async def get_kv_diff(self, store_id: bytes32, hash_1: bytes32, hash_2: bytes32) -> set[DiffData]:
         return await self.data_store.get_kv_diff(store_id, hash_1, hash_2)
@@ -898,7 +939,7 @@ class DataLayer:
                 try:
                     subscriptions = await self.data_store.get_subscriptions()
                     for subscription in subscriptions:
-                        await self.wallet_rpc.dl_track_new(subscription.store_id)
+                        await self.wallet_rpc.dl_track_new(DLTrackNew(subscription.store_id))
                     break
                 except aiohttp.client_exceptions.ClientConnectorError:
                     pass
@@ -1248,7 +1289,7 @@ class DataLayer:
         if not await self.data_store.store_id_exists(store_id=store_id):
             raise Exception(f"No store id stored in the local database for {store_id}")
         root = await self.data_store.get_tree_root(store_id=store_id)
-        singleton_record = await self.wallet_rpc.dl_latest_singleton(store_id, True)
+        singleton_record = (await self.wallet_rpc.dl_latest_singleton(DLLatestSingleton(store_id, True))).singleton
         if singleton_record is None:
             raise Exception(f"No singleton found for {store_id}")
 

chia/{rpc → data_layer}/data_layer_rpc_api.py

@@ -8,6 +8,7 @@ from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint64
 
 from chia.data_layer.data_layer_errors import OfferIntegrityError
+from chia.data_layer.data_layer_rpc_util import marshal
 from chia.data_layer.data_layer_util import (
     CancelOfferRequest,
     CancelOfferResponse,
@@ -31,7 +32,6 @@ from chia.data_layer.data_layer_util import (
     unspecified,
 )
 from chia.data_layer.data_layer_wallet import DataLayerWallet, Mirror, verify_offer
-from chia.rpc.data_layer_rpc_util import marshal
 from chia.rpc.rpc_server import Endpoint, EndpointResult
 from chia.rpc.util import marshal as streamable_marshal
 from chia.util.byte_types import hexstr_to_bytes

chia/{rpc → data_layer}/data_layer_rpc_util.py

@@ -1,11 +1,8 @@
 from __future__ import annotations
 
-from typing import Any, TypeVar
-
-from typing_extensions import Protocol
-
-_T = TypeVar("_T")
+from typing import Any
 
+from typing_extensions import Protocol, Self
 
 # If accepted for general use then this should be moved to a common location
 # and probably implemented by the framework instead of manual decoration.
@@ -13,7 +10,7 @@ _T = TypeVar("_T")
 
 class MarshallableProtocol(Protocol):
     @classmethod
-    def unmarshal(cls: type[_T], marshalled: dict[str, Any]) -> _T: ...
+    def unmarshal(cls, marshalled: dict[str, Any]) -> Self: ...
 
     def marshal(self) -> dict[str, Any]: ...
 

chia/data_layer/data_layer_util.py

@@ -392,7 +392,7 @@ class Root:
         }
 
 
-node_type_to_class: dict[NodeType, Union[type[InternalNode], type[TerminalNode]]] = {
+node_type_to_class: dict[NodeType, type[Union[InternalNode, TerminalNode]]] = {
     NodeType.INTERNAL: InternalNode,
     NodeType.TERMINAL: TerminalNode,
 }
@@ -962,14 +962,12 @@ def dl_verify_proof_internal(dl_proof: DLProof, puzzle_hash: bytes32) -> list[Ke
 
 
 async def dl_verify_proof(
-    request: dict[str, Any],
+    dlproof: DLProof,
     wallet_node: WalletNode,
     peer: WSChiaConnection,
-) -> dict[str, Any]:
+) -> VerifyProofResponse:
     """Verify a proof of inclusion for a DL singleton"""
 
-    dlproof = DLProof.from_json_dict(request)
-
     coin_id = dlproof.coin_id
     coin_states = await wallet_node.get_coin_state([coin_id], peer=peer)
     if len(coin_states) == 0:
@@ -982,4 +980,4 @@ async def dl_verify_proof(
         success=True,
         current_root=coin_states[0].spent_height is None,
     )
-    return response.to_json_dict()
+    return response

chia/data_layer/data_layer_wallet.py

@@ -5,23 +5,21 @@ import logging
 import time
 from typing import TYPE_CHECKING, Any, ClassVar, Optional, cast
 
-from chia_rs import G1Element, G2Element
+from chia_rs import BlockRecord, CoinSpend, CoinState, G1Element, G2Element
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint32, uint64, uint128
 from clvm.EvalError import EvalError
 from typing_extensions import Unpack, final
 
-from chia.consensus.block_record import BlockRecord
 from chia.data_layer.data_layer_errors import LauncherCoinNotFoundError, OfferIntegrityError
 from chia.data_layer.data_layer_util import OfferStore, ProofOfInclusion, ProofOfInclusionLayer, StoreProofs, leaf_hash
 from chia.data_layer.singleton_record import SingletonRecord
-from chia.protocols.wallet_protocol import CoinState
 from chia.server.ws_connection import WSChiaConnection
 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, compute_additions
+from chia.types.blockchain_format.program import Program, run_with_cost
+from chia.types.coin_spend import make_spend
 from chia.types.condition_opcodes import ConditionOpcode
+from chia.util.streamable import Streamable, streamable
 from chia.wallet.conditions import (
     AssertAnnouncement,
     AssertCoinAnnouncement,
@@ -52,6 +50,7 @@ from chia.wallet.puzzle_drivers import PuzzleInfo, Solver
 from chia.wallet.singleton import SINGLETON_LAUNCHER_PUZZLE, SINGLETON_LAUNCHER_PUZZLE_HASH
 from chia.wallet.trading.offer import NotarizedPayment, Offer
 from chia.wallet.transaction_record import TransactionRecord
+from chia.wallet.util.compute_additions import compute_additions
 from chia.wallet.util.compute_memos import compute_memos
 from chia.wallet.util.merkle_utils import _simplify_merkle_proof
 from chia.wallet.util.transaction_type import TransactionType
@@ -68,35 +67,23 @@ if TYPE_CHECKING:
     from chia.wallet.wallet_state_manager import WalletStateManager
 
 
+@streamable
 @dataclasses.dataclass(frozen=True)
-class Mirror:
+class Mirror(Streamable):
     coin_id: bytes32
     launcher_id: bytes32
     amount: uint64
-    urls: list[bytes]
+    urls: list[str]
     ours: bool
     confirmed_at_height: Optional[uint32]
 
-    def to_json_dict(self) -> dict[str, Any]:
-        return {
-            "coin_id": self.coin_id.hex(),
-            "launcher_id": self.launcher_id.hex(),
-            "amount": self.amount,
-            "urls": [url.decode("utf8") for url in self.urls],
-            "ours": self.ours,
-            "confirmed_at_height": self.confirmed_at_height,
-        }
+    @staticmethod
+    def encode_urls(urls: list[str]) -> list[bytes]:
+        return [url.encode("utf8") for url in urls]
 
-    @classmethod
-    def from_json_dict(cls, json_dict: dict[str, Any]) -> Mirror:
-        return cls(
-            bytes32.from_hexstr(json_dict["coin_id"]),
-            bytes32.from_hexstr(json_dict["launcher_id"]),
-            json_dict["amount"],
-            [bytes(url, "utf8") for url in json_dict["urls"]],
-            json_dict["ours"],
-            json_dict["confirmed_at_height"],
-        )
+    @staticmethod
+    def decode_urls(urls: list[bytes]) -> list[str]:
+        return [url.decode("utf8") for url in urls]
 
 
 @final
@@ -167,13 +154,13 @@ class DataLayerWallet:
     @staticmethod
     async def match_dl_launcher(launcher_spend: CoinSpend) -> tuple[bool, Optional[bytes32]]:
         # Sanity check it's a launcher
-        if launcher_spend.puzzle_reveal.to_program() != SINGLETON_LAUNCHER_PUZZLE:
+        if launcher_spend.puzzle_reveal != SINGLETON_LAUNCHER_PUZZLE.to_serialized():
             return False, None
 
         # Let's make sure the solution looks how we expect it to
         try:
             full_puzhash, amount, root, inner_puzhash = launch_solution_to_singleton_info(
-                launcher_spend.solution.to_program()
+                Program.from_serialized(launcher_spend.solution)
             )
         except ValueError:
             return False, None
@@ -223,7 +210,9 @@ class DataLayerWallet:
 
         assert spend.coin.name() == launcher_id, "coin_id should always match the launcher_id here"
 
-        full_puzhash, amount, root, inner_puzhash = launch_solution_to_singleton_info(spend.solution.to_program())
+        full_puzhash, amount, root, inner_puzhash = launch_solution_to_singleton_info(
+            Program.from_serialized(spend.solution)
+        )
         new_singleton = Coin(launcher_id, full_puzhash, amount)
 
         singleton_record: Optional[SingletonRecord] = await self.wallet_state_manager.dl_store.get_latest_singleton(
@@ -300,9 +289,7 @@ class DataLayerWallet:
         launcher_parent: Coin = next(iter(coins))
         launcher_coin: Coin = Coin(launcher_parent.name(), SINGLETON_LAUNCHER_PUZZLE_HASH, uint64(1))
 
-        inner_puzzle: Program = await self.standard_wallet.get_puzzle(
-            new=not action_scope.config.tx_config.reuse_puzhash
-        )
+        inner_puzzle: Program = await action_scope.get_puzzle(self.wallet_state_manager)
         full_puzzle: Program = create_host_fullpuz(inner_puzzle, initial_root, launcher_coin.name())
 
         genesis_launcher_solution: Program = Program.to(
@@ -321,10 +308,10 @@ class DataLayerWallet:
             extra_conditions=(*extra_conditions, announcement),
         )
 
-        launcher_cs: CoinSpend = CoinSpend(
+        launcher_cs: CoinSpend = make_spend(
             launcher_coin,
-            SerializedProgram.from_program(SINGLETON_LAUNCHER_PUZZLE),
-            SerializedProgram.from_program(genesis_launcher_solution),
+            SINGLETON_LAUNCHER_PUZZLE,
+            genesis_launcher_solution,
         )
         launcher_sb = WalletSpendBundle([launcher_cs], G2Element())
         launcher_id = launcher_coin.name()
@@ -394,9 +381,7 @@ class DataLayerWallet:
 
         # Make the child's puzzles
         if new_puz_hash is None:
-            new_puz_hash = await self.standard_wallet.get_puzzle_hash(
-                new=not action_scope.config.tx_config.reuse_puzhash
-            )
+            new_puz_hash = await action_scope.get_puzzle_hash(self.wallet_state_manager)
         assert new_puz_hash is not None
         next_full_puz_hash: bytes32 = create_host_fullpuz(new_puz_hash, root_hash, launcher_id).get_tree_hash_precalc(
             new_puz_hash
@@ -457,10 +442,10 @@ class DataLayerWallet:
             second_coin = Coin(
                 current_coin.name(), second_full_puz.get_tree_hash(), singleton_record.lineage_proof.amount
             )
-            second_coin_spend = CoinSpend(
+            second_coin_spend = make_spend(
                 second_coin,
-                SerializedProgram.from_program(second_full_puz),
-                SerializedProgram.to(
+                second_full_puz,
+                Program.to(
                     [
                         LineageProof(
                             current_coin.parent_coin_info,
@@ -538,10 +523,10 @@ class DataLayerWallet:
         )
 
         # Create the spend
-        coin_spend = CoinSpend(
+        coin_spend = make_spend(
             current_coin,
-            SerializedProgram.from_program(current_full_puz),
-            SerializedProgram.from_program(full_sol),
+            current_full_puz,
+            full_sol,
         )
 
         spend_bundle = WalletSpendBundle([coin_spend], G2Element())
@@ -722,18 +707,16 @@ class DataLayerWallet:
             raise ValueError(f"DL Wallet does not have permission to delete mirror with ID {mirror_id}")
 
         parent_inner_puzzle: Program = self.standard_wallet.puzzle_for_pk(inner_puzzle_derivation.pubkey)
-        new_puzhash: bytes32 = await self.standard_wallet.get_puzzle_hash(
-            new=not action_scope.config.tx_config.reuse_puzhash
-        )
+        new_puzhash: bytes32 = await action_scope.get_puzzle_hash(self.wallet_state_manager)
         excess_fee: int = fee - mirror_coin.amount
         inner_sol: Program = self.standard_wallet.make_solution(
             primaries=[CreateCoin(new_puzhash, uint64(mirror_coin.amount - fee))] if excess_fee < 0 else [],
             conditions=(*extra_conditions, CreateCoinAnnouncement(b"$")) if excess_fee > 0 else extra_conditions,
         )
-        mirror_spend = CoinSpend(
+        mirror_spend = make_spend(
             mirror_coin,
-            SerializedProgram.from_program(create_mirror_puzzle()),
-            SerializedProgram.to(
+            create_mirror_puzzle(),
+            Program.to(
                 [
                     parent_coin.parent_coin_info,
                     parent_inner_puzzle,
@@ -798,7 +781,7 @@ class DataLayerWallet:
                         coin.name(),
                         launcher_id,
                         uint64(coin.amount),
-                        urls,
+                        Mirror.decode_urls(urls),
                         ours,
                         height,
                     )
@@ -826,7 +809,7 @@ class DataLayerWallet:
             root: bytes32
             inner_puzzle_hash: bytes32
 
-            conditions = puzzle.run_with_cost(self.wallet_state_manager.constants.MAX_BLOCK_COST_CLVM, solution)[
+            conditions = run_with_cost(puzzle, self.wallet_state_manager.constants.MAX_BLOCK_COST_CLVM, solution)[
                 1
             ].as_python()
             found_singleton: bool = False
@@ -936,14 +919,6 @@ class DataLayerWallet:
     def puzzle_for_pk(self, pubkey: G1Element) -> Program:
         return self.standard_wallet.puzzle_for_pk(pubkey)
 
-    async def get_new_puzzle(self) -> Program:
-        return self.puzzle_for_pk(
-            (await self.wallet_state_manager.get_unused_derivation_record(self.wallet_info.id)).pubkey
-        )
-
-    async def get_new_puzzlehash(self) -> bytes32:
-        return (await self.get_new_puzzle()).get_tree_hash()
-
     async def new_peak(self, peak: BlockRecord) -> None:
         pass
 
@@ -1024,9 +999,7 @@ class DataLayerWallet:
             except KeyError:
                 this_solver = solver["0x" + launcher.hex()]
             new_root: bytes32 = this_solver["new_root"]
-            new_ph: bytes32 = await wallet_state_manager.main_wallet.get_puzzle_hash(
-                new=not action_scope.config.tx_config.reuse_puzhash
-            )
+            new_ph: bytes32 = await action_scope.get_puzzle_hash(wallet_state_manager)
             async with wallet_state_manager.new_action_scope(
                 action_scope.config.tx_config, push=False
             ) as inner_action_scope:
@@ -1050,7 +1023,7 @@ class DataLayerWallet:
                         for cs in tx.spend_bundle.coin_spends
                         if tx.spend_bundle is not None and match_dl_singleton(cs.puzzle_reveal)[0]
                     )
-                dl_solution: Program = dl_spend.solution.to_program()
+                dl_solution = Program.from_serialized(dl_spend.solution)
                 old_graftroot: Program = dl_solution.at("rrffrf")
                 new_graftroot: Program = create_graftroot_offer_puz(
                     [bytes32(dep["launcher_id"]) for dep in this_solver["dependencies"]],
@@ -1059,7 +1032,7 @@ class DataLayerWallet:
                 )
 
                 new_solution: Program = dl_solution.replace(rrffrf=new_graftroot, rrffrrf=Program.to([None] * 5))
-                new_spend: CoinSpend = dl_spend.replace(solution=SerializedProgram.from_program(new_solution))
+                new_spend: CoinSpend = dl_spend.replace(solution=new_solution.to_serialized())
                 async with inner_action_scope.use() as interface:
                     for i, tx in enumerate(interface.side_effects.transactions):
                         if tx.spend_bundle is not None and dl_spend in tx.spend_bundle.coin_spends:
@@ -1115,7 +1088,7 @@ class DataLayerWallet:
         # Create all of the new solutions
         new_spends: list[CoinSpend] = []
         for spend in offer.coin_spends():
-            solution = spend.solution.to_program()
+            solution = Program.from_serialized(spend.solution)
             if match_dl_singleton(spend.puzzle_reveal)[0]:
                 try:
                     graftroot: Program = solution.at("rrffrf")
@@ -1163,7 +1136,7 @@ class DataLayerWallet:
                             ]
                         )
                     )
-                    new_spend: CoinSpend = spend.replace(solution=SerializedProgram.from_program(new_solution))
+                    new_spend: CoinSpend = spend.replace(solution=new_solution.to_serialized())
                     spend = new_spend
             new_spends.append(spend)
 
@@ -1173,7 +1146,7 @@ class DataLayerWallet:
     async def get_offer_summary(offer: Offer) -> dict[str, Any]:
         summary: dict[str, Any] = {"offered": []}
         for spend in offer.coin_spends():
-            solution = spend.solution.to_program()
+            solution = Program.from_serialized(spend.solution)
             matched, curried_args = match_dl_singleton(spend.puzzle_reveal)
             if matched:
                 try: