chia-blockchain 2.5.7rc4__py3-none-any.whl → 2.6.0rc2__py3-none-any.whl

chia/data_layer/data_layer_util.py

@@ -5,7 +5,7 @@ from dataclasses import dataclass, field
 from enum import Enum, IntEnum
 from hashlib import sha256
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Optional, Union
+from typing import TYPE_CHECKING, Any, Union
 
 import aiosqlite
 from chia_rs.datalayer import ProofOfInclusion, ProofOfInclusionLayer
@@ -250,8 +250,8 @@ class InternalNode:
     left_hash: bytes32
     right_hash: bytes32
 
-    left: Optional[Node] = None
-    right: Optional[Node] = None
+    left: Node | None = None
+    right: Node | None = None
 
     @classmethod
     def from_child_nodes(cls, left: Node, right: Node) -> InternalNode:
@@ -307,7 +307,7 @@ unspecified = Unspecified.instance
 @dataclass(frozen=True)
 class Root:
     store_id: bytes32
-    node_hash: Optional[bytes32]
+    node_hash: bytes32 | None
     generation: int
     status: Status
 
@@ -352,7 +352,7 @@ class Root:
         }
 
 
-node_type_to_class: dict[NodeType, type[Union[InternalNode, TerminalNode]]] = {
+node_type_to_class: dict[NodeType, type[InternalNode | TerminalNode]] = {
     NodeType.INTERNAL: InternalNode,
     NodeType.TERMINAL: TerminalNode,
 }
@@ -454,7 +454,7 @@ class Layer:
 class MakeOfferRequest:
     maker: tuple[OfferStore, ...]
     taker: tuple[OfferStore, ...]
-    fee: Optional[uint64]
+    fee: uint64 | None
 
     @classmethod
     def unmarshal(cls, marshalled: dict[str, Any]) -> MakeOfferRequest:
@@ -569,7 +569,7 @@ class MakeOfferResponse:
 @dataclasses.dataclass(frozen=True)
 class TakeOfferRequest:
     offer: Offer
-    fee: Optional[uint64]
+    fee: uint64 | None
 
     @classmethod
     def unmarshal(cls, marshalled: dict[str, Any]) -> TakeOfferRequest:
@@ -609,8 +609,8 @@ class TakeOfferResponse:
 class VerifyOfferResponse:
     success: bool
     valid: bool
-    error: Optional[str] = None
-    fee: Optional[uint64] = None
+    error: str | None = None
+    fee: uint64 | None = None
 
     @classmethod
     def unmarshal(cls, marshalled: dict[str, Any]) -> VerifyOfferResponse:
@@ -635,7 +635,7 @@ class CancelOfferRequest:
     trade_id: bytes32
     # cancel on chain (secure) vs. just locally
     secure: bool
-    fee: Optional[uint64]
+    fee: uint64 | None
 
     @classmethod
     def unmarshal(cls, marshalled: dict[str, Any]) -> CancelOfferRequest:
@@ -691,7 +691,7 @@ class ClearPendingRootsRequest:
 class ClearPendingRootsResponse:
     success: bool
 
-    root: Optional[Root]
+    root: Root | None
     # store_id: bytes32
     # node_hash: Optional[bytes32]
     # generation: int
@@ -765,7 +765,7 @@ class KeysValuesCompressed:
     keys_values_hashed: dict[bytes32, bytes32]
     key_hash_to_length: dict[bytes32, int]
     leaf_hash_to_length: dict[bytes32, int]
-    root_hash: Optional[bytes32]
+    root_hash: bytes32 | None
 
 
 @dataclasses.dataclass(frozen=True)
@@ -773,7 +773,7 @@ class KeysPaginationData:
     total_pages: int
     total_bytes: int
     keys: list[bytes]
-    root_hash: Optional[bytes32]
+    root_hash: bytes32 | None
 
 
 @dataclasses.dataclass(frozen=True)
@@ -781,7 +781,7 @@ class KeysValuesPaginationData:
     total_pages: int
     total_bytes: int
     keys_values: list[TerminalNode]
-    root_hash: Optional[bytes32]
+    root_hash: bytes32 | None
 
 
 @dataclasses.dataclass(frozen=True)

chia/data_layer/data_layer_wallet.py

@@ -2,8 +2,7 @@ from __future__ import annotations
 
 import dataclasses
 import logging
-import time
-from typing import TYPE_CHECKING, Any, ClassVar, Optional, cast
+from typing import TYPE_CHECKING, Any, ClassVar, cast
 
 from chia_rs import BlockRecord, CoinSpend, CoinState, G1Element, G2Element
 from chia_rs.datalayer import ProofOfInclusion, ProofOfInclusionLayer
@@ -29,7 +28,6 @@ from chia.wallet.conditions import (
     CreateCoin,
     CreateCoinAnnouncement,
     UnknownCondition,
-    parse_timelock_info,
 )
 from chia.wallet.db_wallet.db_wallet_puzzles import (
     ACS_MU,
@@ -52,9 +50,7 @@ from chia.wallet.singleton import SINGLETON_LAUNCHER_PUZZLE, SINGLETON_LAUNCHER_
 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
 from chia.wallet.util.wallet_sync_utils import fetch_coin_spend, fetch_coin_spend_for_coin_state
 from chia.wallet.util.wallet_types import WalletType
 from chia.wallet.wallet import Wallet
@@ -76,7 +72,7 @@ class Mirror(Streamable):
     amount: uint64
     urls: list[str]
     ours: bool
-    confirmed_at_height: Optional[uint32]
+    confirmed_at_height: uint32 | None
 
     @staticmethod
     def encode_urls(urls: list[str]) -> list[bytes]:
@@ -87,6 +83,27 @@ class Mirror(Streamable):
         return [url.decode("utf8") for url in urls]
 
 
+@streamable
+@dataclasses.dataclass(frozen=True)
+class SingletonDependencies(Streamable):
+    launcher_id: bytes32
+    values_to_prove: list[bytes]
+
+
+@streamable
+@dataclasses.dataclass(frozen=True)
+class SingletonSummary(Streamable):
+    launcher_id: bytes32
+    new_root: bytes32
+    dependencies: list[SingletonDependencies]
+
+
+@streamable
+@dataclasses.dataclass(frozen=True)
+class DataLayerSummary(Streamable):
+    offered: list[SingletonSummary]
+
+
 @final
 class DataLayerWallet:
     if TYPE_CHECKING:
@@ -153,7 +170,7 @@ class DataLayerWallet:
     #############
 
     @staticmethod
-    async def match_dl_launcher(launcher_spend: CoinSpend) -> tuple[bool, Optional[bytes32]]:
+    async def match_dl_launcher(launcher_spend: CoinSpend) -> tuple[bool, bytes32 | None]:
         # Sanity check it's a launcher
         if launcher_spend.puzzle_reveal != SINGLETON_LAUNCHER_PUZZLE.to_serialized():
             return False, None
@@ -197,8 +214,8 @@ class DataLayerWallet:
         self,
         launcher_id: bytes32,
         peer: WSChiaConnection,
-        spend: Optional[CoinSpend] = None,
-        height: Optional[uint32] = None,
+        spend: CoinSpend | None = None,
+        height: uint32 | None = None,
     ) -> None:
         if await self.wallet_state_manager.dl_store.get_launcher(launcher_id) is not None:
             self.log.info(f"Spend of launcher {launcher_id} has already been processed")
@@ -216,7 +233,7 @@ class DataLayerWallet:
         )
         new_singleton = Coin(launcher_id, full_puzhash, amount)
 
-        singleton_record: Optional[SingletonRecord] = await self.wallet_state_manager.dl_store.get_latest_singleton(
+        singleton_record: SingletonRecord | None = await self.wallet_state_manager.dl_store.get_latest_singleton(
             launcher_id
         )
         if singleton_record is not None:
@@ -252,9 +269,9 @@ class DataLayerWallet:
         await self.wallet_state_manager.add_interested_puzzle_hashes([launcher_id], [self.id()])
         await self.wallet_state_manager.add_interested_coin_ids([new_singleton.name()])
 
-        new_singleton_coin_record: Optional[
-            WalletCoinRecord
-        ] = await self.wallet_state_manager.coin_store.get_coin_record(new_singleton.name())
+        new_singleton_coin_record: WalletCoinRecord | None = await self.wallet_state_manager.coin_store.get_coin_record(
+            new_singleton.name()
+        )
         while new_singleton_coin_record is not None and new_singleton_coin_record.spent_block_height > 0:
             # We've already synced this before, so we need to sort of force a resync
             parent_spend = await fetch_coin_spend(new_singleton_coin_record.spent_block_height, new_singleton, peer)
@@ -359,10 +376,10 @@ class DataLayerWallet:
     async def create_update_state_spend(
         self,
         launcher_id: bytes32,
-        root_hash: Optional[bytes32],
+        root_hash: bytes32 | None,
         action_scope: WalletActionScope,
-        new_puz_hash: Optional[bytes32] = None,
-        new_amount: Optional[uint64] = None,
+        new_puz_hash: bytes32 | None = None,
+        new_amount: uint64 | None = None,
         fee: uint64 = uint64(0),
         announce_new_state: bool = False,
         extra_conditions: tuple[Condition, ...] = tuple(),
@@ -372,9 +389,9 @@ class DataLayerWallet:
         if root_hash is None:
             root_hash = singleton_record.root
 
-        inner_puzzle_derivation: Optional[
-            DerivationRecord
-        ] = await self.wallet_state_manager.puzzle_store.get_derivation_record_for_puzzle_hash(
+        inner_puzzle_derivation: (
+            DerivationRecord | None
+        ) = await self.wallet_state_manager.puzzle_store.get_derivation_record_for_puzzle_hash(
             singleton_record.inner_puzzle_hash
         )
         if inner_puzzle_derivation is None:
@@ -535,25 +552,16 @@ class DataLayerWallet:
         if announce_new_state:
             spend_bundle = WalletSpendBundle([coin_spend, second_coin_spend], spend_bundle.aggregated_signature)
 
-        dl_tx = TransactionRecord(
-            confirmed_at_height=uint32(0),
-            created_at_time=uint64(time.time()),
-            to_puzzle_hash=new_puz_hash,
-            to_address=self.wallet_state_manager.encode_puzzle_hash(new_puz_hash),
+        dl_tx = self.wallet_state_manager.new_outgoing_transaction(
+            wallet_id=self.id(),
+            puzzle_hash=new_puz_hash,
             amount=uint64(singleton_record.lineage_proof.amount),
-            fee_amount=fee,
-            confirmed=False,
-            sent=uint32(10),
+            fee=fee,
             spend_bundle=spend_bundle,
             additions=spend_bundle.additions(),
             removals=spend_bundle.removals(),
-            memos=compute_memos(spend_bundle),
-            wallet_id=self.id(),
-            sent_to=[],
-            trade_id=None,
-            type=uint32(TransactionType.OUTGOING_TX.value),
             name=singleton_record.coin_id,
-            valid_times=parse_timelock_info(extra_conditions),
+            extra_conditions=extra_conditions,
         )
         assert dl_tx.spend_bundle is not None
         if fee > 0:
@@ -579,13 +587,13 @@ class DataLayerWallet:
         puzzle_hashes: list[bytes32],
         action_scope: WalletActionScope,
         fee: uint64 = uint64(0),
-        coins: Optional[set[Coin]] = None,
-        memos: Optional[list[list[bytes]]] = None,  # ignored
+        coins: set[Coin] | None = None,
+        memos: list[list[bytes]] | None = None,  # ignored
         extra_conditions: tuple[Condition, ...] = tuple(),
         **kwargs: Unpack[GSTOptionalArgs],
     ) -> None:
-        launcher_id: Optional[bytes32] = kwargs.get("launcher_id", None)
-        new_root_hash: Optional[bytes32] = kwargs.get("new_root_hash", None)
+        launcher_id: bytes32 | None = kwargs.get("launcher_id", None)
+        new_root_hash: bytes32 | None = kwargs.get("new_root_hash", None)
         announce_new_state: bool = kwargs.get("announce_new_state", False)
         # Figure out the launcher ID
         if coins is None or len(coins) == 0:
@@ -616,7 +624,7 @@ class DataLayerWallet:
 
     async def get_spendable_singleton_info(self, launcher_id: bytes32) -> tuple[SingletonRecord, LineageProof]:
         # First, let's make sure this is a singleton that we track and that we can spend
-        singleton_record: Optional[SingletonRecord] = await self.get_latest_singleton(launcher_id)
+        singleton_record: SingletonRecord | None = await self.get_latest_singleton(launcher_id)
         if singleton_record is None:
             raise ValueError(f"Singleton with launcher ID {launcher_id} is not tracked by DL Wallet")
 
@@ -629,7 +637,7 @@ class DataLayerWallet:
             raise ValueError(f"Singleton with launcher ID {launcher_id} has insufficient information to spend")
 
         # Finally, let's get the parent record for its lineage proof
-        parent_singleton: Optional[SingletonRecord] = await self.wallet_state_manager.dl_store.get_singleton_record(
+        parent_singleton: SingletonRecord | None = await self.wallet_state_manager.dl_store.get_singleton_record(
             singleton_record.lineage_proof.parent_name
         )
         parent_lineage: LineageProof
@@ -637,7 +645,7 @@ class DataLayerWallet:
             if singleton_record.lineage_proof.parent_name != launcher_id:
                 raise ValueError(f"Have not found the parent of singleton with launcher ID {launcher_id}")
             else:
-                launcher_coin: Optional[Coin] = await self.wallet_state_manager.dl_store.get_launcher(launcher_id)
+                launcher_coin: Coin | None = await self.wallet_state_manager.dl_store.get_launcher(launcher_id)
                 if launcher_coin is None:
                     raise ValueError(f"DL Wallet does not have launcher info for id {launcher_id}")
                 else:
@@ -658,9 +666,9 @@ class DataLayerWallet:
                 # this is likely due to a race between getting the list and acquiring the extra data
                 continue
 
-            inner_puzzle_derivation: Optional[
-                DerivationRecord
-            ] = await self.wallet_state_manager.puzzle_store.get_derivation_record_for_puzzle_hash(
+            inner_puzzle_derivation: (
+                DerivationRecord | None
+            ) = await self.wallet_state_manager.puzzle_store.get_derivation_record_for_puzzle_hash(
                 singleton_record.inner_puzzle_hash
             )
             if inner_puzzle_derivation is not None:
@@ -701,9 +709,9 @@ class DataLayerWallet:
         parent_coin: Coin = (
             await self.wallet_state_manager.wallet_node.get_coin_state([mirror_coin.parent_coin_info], peer=peer)
         )[0].coin
-        inner_puzzle_derivation: Optional[
-            DerivationRecord
-        ] = await self.wallet_state_manager.puzzle_store.get_derivation_record_for_puzzle_hash(parent_coin.puzzle_hash)
+        inner_puzzle_derivation: (
+            DerivationRecord | None
+        ) = await self.wallet_state_manager.puzzle_store.get_derivation_record_for_puzzle_hash(parent_coin.puzzle_hash)
         if inner_puzzle_derivation is None:
             raise ValueError(f"DL Wallet does not have permission to delete mirror with ID {mirror_id}")
 
@@ -730,25 +738,16 @@ class DataLayerWallet:
 
         async with action_scope.use() as interface:
             interface.side_effects.transactions.append(
-                TransactionRecord(
-                    confirmed_at_height=uint32(0),
-                    created_at_time=uint64(time.time()),
-                    to_puzzle_hash=new_puzhash,
-                    to_address=self.wallet_state_manager.encode_puzzle_hash(new_puzhash),
+                self.wallet_state_manager.new_outgoing_transaction(
+                    wallet_id=self.id(),
+                    puzzle_hash=new_puzhash,
                     amount=uint64(mirror_coin.amount),
-                    fee_amount=fee,
-                    confirmed=False,
-                    sent=uint32(10),
+                    fee=fee,
                     spend_bundle=mirror_bundle,
                     additions=mirror_bundle.additions(),
                     removals=mirror_bundle.removals(),
-                    memos=compute_memos(mirror_bundle),
-                    wallet_id=self.id(),  # This is being called before the wallet is created so we're using a ID of 0
-                    sent_to=[],
-                    trade_id=None,
-                    type=uint32(TransactionType.OUTGOING_TX.value),
                     name=mirror_bundle.name(),
-                    valid_times=parse_timelock_info(extra_conditions),
+                    extra_conditions=extra_conditions,
                 )
             )
 
@@ -765,7 +764,7 @@ class DataLayerWallet:
     # SYNCING #
     ###########
 
-    async def coin_added(self, coin: Coin, height: uint32, peer: WSChiaConnection, coin_data: Optional[object]) -> None:
+    async def coin_added(self, coin: Coin, height: uint32, peer: WSChiaConnection, coin_data: object | None) -> None:
         if coin.puzzle_hash == create_mirror_puzzle().get_tree_hash():
             parent_state: CoinState = (
                 await self.wallet_state_manager.wallet_node.get_coin_state([coin.parent_coin_info], peer=peer)
@@ -798,7 +797,7 @@ class DataLayerWallet:
         matched, _ = match_dl_singleton(puzzle)
         if matched:
             self.log.info(f"DL singleton removed: {parent_spend.coin}")
-            singleton_record: Optional[SingletonRecord] = await self.wallet_state_manager.dl_store.get_singleton_record(
+            singleton_record: SingletonRecord | None = await self.wallet_state_manager.dl_store.get_singleton_record(
                 parent_name
             )
             if singleton_record is None:
@@ -868,10 +867,8 @@ class DataLayerWallet:
     # UTILITY #
     ###########
 
-    async def get_latest_singleton(
-        self, launcher_id: bytes32, only_confirmed: bool = False
-    ) -> Optional[SingletonRecord]:
-        singleton: Optional[SingletonRecord] = await self.wallet_state_manager.dl_store.get_latest_singleton(
+    async def get_latest_singleton(self, launcher_id: bytes32, only_confirmed: bool = False) -> SingletonRecord | None:
+        singleton: SingletonRecord | None = await self.wallet_state_manager.dl_store.get_latest_singleton(
             launcher_id, only_confirmed
         )
         return singleton
@@ -879,9 +876,9 @@ class DataLayerWallet:
     async def get_history(
         self,
         launcher_id: bytes32,
-        min_generation: Optional[uint32] = None,
-        max_generation: Optional[uint32] = None,
-        num_results: Optional[uint32] = None,
+        min_generation: uint32 | None = None,
+        max_generation: uint32 | None = None,
+        num_results: uint32 | None = None,
     ) -> list[SingletonRecord]:
         history: list[SingletonRecord] = await self.wallet_state_manager.dl_store.get_all_singletons_for_launcher(
             launcher_id,
@@ -891,8 +888,8 @@ class DataLayerWallet:
         )
         return history
 
-    async def get_singleton_record(self, coin_id: bytes32) -> Optional[SingletonRecord]:
-        singleton: Optional[SingletonRecord] = await self.wallet_state_manager.dl_store.get_singleton_record(coin_id)
+    async def get_singleton_record(self, coin_id: bytes32) -> SingletonRecord | None:
+        singleton: SingletonRecord | None = await self.wallet_state_manager.dl_store.get_singleton_record(coin_id)
         return singleton
 
     async def get_singletons_by_root(self, launcher_id: bytes32, root: bytes32) -> list[SingletonRecord]:
@@ -924,19 +921,19 @@ class DataLayerWallet:
     async def new_peak(self, peak: BlockRecord) -> None:
         pass
 
-    async def get_confirmed_balance(self, record_list: Optional[set[WalletCoinRecord]] = None) -> uint128:
+    async def get_confirmed_balance(self, record_list: set[WalletCoinRecord] | None = None) -> uint128:
         return uint128(0)
 
-    async def get_unconfirmed_balance(self, record_list: Optional[set[WalletCoinRecord]] = None) -> uint128:
+    async def get_unconfirmed_balance(self, record_list: set[WalletCoinRecord] | None = None) -> uint128:
         return uint128(0)
 
-    async def get_spendable_balance(self, unspent_records: Optional[set[WalletCoinRecord]] = None) -> uint128:
+    async def get_spendable_balance(self, unspent_records: set[WalletCoinRecord] | None = None) -> uint128:
         return uint128(0)
 
     async def get_pending_change_balance(self) -> uint64:
         return uint64(0)
 
-    async def get_max_send_amount(self, unspent_records: Optional[set[WalletCoinRecord]] = None) -> uint128:
+    async def get_max_send_amount(self, unspent_records: set[WalletCoinRecord] | None = None) -> uint128:
         return uint128(0)
 
     def get_name(self) -> str:
@@ -977,7 +974,7 @@ class DataLayerWallet:
     @staticmethod
     async def make_update_offer(
         wallet_state_manager: Any,
-        offer_dict: dict[Optional[bytes32], int],
+        offer_dict: dict[bytes32 | None, int],
         driver_dict: dict[bytes32, PuzzleInfo],
         solver: Solver,
         action_scope: WalletActionScope,
@@ -1104,7 +1101,7 @@ class DataLayerWallet:
                     all_proofs = []
                     roots = []
                     for singleton, values in zip(singleton_structs.as_iter(), values_to_prove.as_python()):
-                        asserted_root: Optional[str] = None
+                        asserted_root: str | None = None
                         proofs_of_inclusion = []
                         for value in values:
                             for proof_of_inclusion in solver["proofs_of_inclusion"]:
@@ -1146,8 +1143,8 @@ class DataLayerWallet:
         return Offer({}, WalletSpendBundle(new_spends, offer.aggregated_signature()), offer.driver_dict)
 
     @staticmethod
-    async def get_offer_summary(offer: Offer) -> dict[str, Any]:
-        summary: dict[str, Any] = {"offered": []}
+    async def get_offer_summary(offer: Offer) -> DataLayerSummary:
+        singleton_summaries = []
         for spend in offer.coin_spends():
             solution = Program.from_serialized(spend.solution)
             matched, curried_args = match_dl_singleton(spend.puzzle_reveal)
@@ -1162,21 +1159,22 @@ class DataLayerWallet:
                         cs for cs in offer.coin_spends() if cs.coin.parent_coin_info == spend.coin.name()
                     )
                     _, child_curried_args = match_dl_singleton(child_spend.puzzle_reveal)
-                    singleton_summary = {
-                        "launcher_id": list(curried_args)[2].as_python().hex(),
-                        "new_root": list(child_curried_args)[1].as_python().hex(),
-                        "dependencies": [],
-                    }
                     _, singleton_structs, _, values_to_prove = graftroot_curried_args.as_iter()
+                    dependencies = []
                     for struct, values in zip(singleton_structs.as_iter(), values_to_prove.as_iter()):
-                        singleton_summary["dependencies"].append(
-                            {
-                                "launcher_id": struct.at("rf").as_python().hex(),
-                                "values_to_prove": [value.as_python().hex() for value in values.as_iter()],
-                            }
+                        dependencies.append(
+                            SingletonDependencies(
+                                launcher_id=bytes32(struct.at("rf").as_atom()),
+                                values_to_prove=[value.as_atom() for value in values.as_iter()],
+                            )
                         )
-                    summary["offered"].append(singleton_summary)
-        return summary
+                    singleton_summary = SingletonSummary(
+                        launcher_id=bytes32(list(curried_args)[2].as_atom()),
+                        new_root=bytes32(list(child_curried_args)[1].as_atom()),
+                        dependencies=dependencies,
+                    )
+                    singleton_summaries.append(singleton_summary)
+        return DataLayerSummary(offered=singleton_summaries)
 
     async def select_coins(
         self,
@@ -1192,7 +1190,7 @@ class DataLayerWallet:
 def verify_offer(
     maker: tuple[StoreProofs, ...],
     taker: tuple[OfferStore, ...],
-    summary: dict[str, Any],
+    summary: DataLayerSummary,
 ) -> None:
     # TODO: consistency in error messages
     # TODO: custom exceptions
@@ -1234,10 +1232,7 @@ def verify_offer(
             raise OfferIntegrityError("maker: no roots referenced for store id")
 
     # TODO: what about validating duplicate entries are consistent?
-    maker_from_offer = {
-        bytes32.from_hexstr(offered["launcher_id"]): bytes32.from_hexstr(offered["new_root"])
-        for offered in summary["offered"]
-    }
+    maker_from_offer = {offered.launcher_id: offered.new_root for offered in summary.offered}
 
     maker_from_reference = {
         # verified above that there is at least one proof and all combined hashes match
@@ -1249,11 +1244,9 @@ def verify_offer(
         raise OfferIntegrityError("maker: offered stores and their roots do not match the reference data")
 
     taker_from_offer = {
-        bytes32.from_hexstr(dependency["launcher_id"]): [
-            bytes32.from_hexstr(value) for value in dependency["values_to_prove"]
-        ]
-        for offered in summary["offered"]
-        for dependency in offered["dependencies"]
+        dependency.launcher_id: [bytes32(value) for value in dependency.values_to_prove]
+        for offered in summary.offered
+        for dependency in offered.dependencies
     }
 
     taker_from_reference = {