chia-blockchain 2.5.1rc1__py3-none-any.whl

chia/wallet/puzzles/tails.py

@@ -0,0 +1,348 @@
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from chia_rs import Coin
+
+from chia.types.blockchain_format.program import Program
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.util.byte_types import hexstr_to_bytes
+from chia.util.ints import uint64
+from chia.wallet.cat_wallet.cat_info import CATInfo
+from chia.wallet.cat_wallet.cat_utils import (
+    CAT_MOD,
+    SpendableCAT,
+    construct_cat_puzzle,
+    unsigned_spend_bundle_for_spendable_cats,
+)
+from chia.wallet.cat_wallet.lineage_store import CATLineageStore
+from chia.wallet.dao_wallet.dao_utils import create_cat_launcher_for_singleton_id
+from chia.wallet.lineage_proof import LineageProof
+from chia.wallet.payment import Payment
+from chia.wallet.puzzles.load_clvm import load_clvm_maybe_recompile
+from chia.wallet.transaction_record import TransactionRecord
+from chia.wallet.wallet_action_scope import WalletActionScope
+from chia.wallet.wallet_spend_bundle import WalletSpendBundle
+
+GENESIS_BY_ID_MOD = load_clvm_maybe_recompile(
+    "genesis_by_coin_id.clsp", package_or_requirement="chia.wallet.cat_wallet.puzzles"
+)
+GENESIS_BY_PUZHASH_MOD = load_clvm_maybe_recompile(
+    "genesis_by_puzzle_hash.clsp", package_or_requirement="chia.wallet.cat_wallet.puzzles"
+)
+EVERYTHING_WITH_SIG_MOD = load_clvm_maybe_recompile(
+    "everything_with_signature.clsp", package_or_requirement="chia.wallet.cat_wallet.puzzles"
+)
+DELEGATED_LIMITATIONS_MOD = load_clvm_maybe_recompile(
+    "delegated_tail.clsp", package_or_requirement="chia.wallet.cat_wallet.puzzles"
+)
+GENESIS_BY_ID_OR_SINGLETON_MOD = load_clvm_maybe_recompile(
+    "genesis_by_coin_id_or_singleton.clsp", package_or_requirement="chia.wallet.cat_wallet.puzzles"
+)
+
+
+class LimitationsProgram:
+    @staticmethod
+    def match(uncurried_mod: Program, curried_args: Program) -> tuple[bool, list[Program]]:
+        raise NotImplementedError("Need to implement 'match' on limitations programs")
+
+    @staticmethod
+    def construct(args: list[Program]) -> Program:
+        raise NotImplementedError("Need to implement 'construct' on limitations programs")
+
+    @staticmethod
+    def solve(args: list[Program], solution_dict: dict) -> Program:
+        raise NotImplementedError("Need to implement 'solve' on limitations programs")
+
+    @classmethod
+    async def generate_issuance_bundle(
+        cls, wallet, cat_tail_info: dict, amount: uint64, action_scope: WalletActionScope
+    ) -> WalletSpendBundle:
+        raise NotImplementedError("Need to implement 'generate_issuance_bundle' on limitations programs")
+
+
+class GenesisById(LimitationsProgram):
+    """
+    This TAIL allows for coins to be issued only by a specific "genesis" coin ID.
+    There can therefore only be one issuance. There is no minting or melting allowed.
+    """
+
+    @staticmethod
+    def match(uncurried_mod: Program, curried_args: Program) -> tuple[bool, list[Program]]:
+        if uncurried_mod == GENESIS_BY_ID_MOD:
+            genesis_id = curried_args.first()
+            return True, [genesis_id]
+        else:
+            return False, []
+
+    @staticmethod
+    def construct(args: list[Program]) -> Program:
+        return GENESIS_BY_ID_MOD.curry(args[0])
+
+    @staticmethod
+    def solve(args: list[Program], solution_dict: dict) -> Program:
+        return Program.to([])
+
+    @classmethod
+    async def generate_issuance_bundle(
+        cls,
+        wallet,
+        _: dict,
+        amount: uint64,
+        action_scope: WalletActionScope,
+        fee: uint64 = uint64(0),
+    ) -> WalletSpendBundle:
+        coins = await wallet.standard_wallet.select_coins(amount + fee, action_scope)
+
+        origin = coins.copy().pop()
+        origin_id = origin.name()
+
+        cat_inner: Program = await wallet.standard_wallet.get_puzzle(
+            new=not action_scope.config.tx_config.reuse_puzhash
+        )
+        tail: Program = cls.construct([Program.to(origin_id)])
+
+        wallet.lineage_store = await CATLineageStore.create(
+            wallet.wallet_state_manager.db_wrapper, tail.get_tree_hash().hex()
+        )
+        await wallet.add_lineage(origin_id, LineageProof())
+
+        minted_cat_puzzle_hash: bytes32 = construct_cat_puzzle(CAT_MOD, tail.get_tree_hash(), cat_inner).get_tree_hash()
+
+        async with wallet.wallet_state_manager.new_action_scope(
+            action_scope.config.tx_config, push=False
+        ) as inner_action_scope:
+            await wallet.standard_wallet.generate_signed_transaction(
+                amount, minted_cat_puzzle_hash, inner_action_scope, fee, coins, origin_id=origin_id
+            )
+
+        async with action_scope.use() as interface:
+            interface.side_effects.transactions = inner_action_scope.side_effects.transactions
+
+        inner_tree_hash = cat_inner.get_tree_hash()
+        inner_solution = wallet.standard_wallet.add_condition_to_solution(
+            Program.to([51, 0, -113, tail, []]),
+            wallet.standard_wallet.make_solution(primaries=[Payment(inner_tree_hash, amount, [inner_tree_hash])]),
+        )
+        eve_spend = unsigned_spend_bundle_for_spendable_cats(
+            CAT_MOD,
+            [
+                SpendableCAT(
+                    next(
+                        filter(
+                            lambda a: a.amount == amount,
+                            [add for tx in inner_action_scope.side_effects.transactions for add in tx.additions],
+                        )
+                    ),
+                    tail.get_tree_hash(),
+                    cat_inner,
+                    inner_solution,
+                    limitations_program_reveal=tail,
+                )
+            ],
+        )
+
+        if wallet.cat_info.my_tail is None:
+            await wallet.save_info(CATInfo(tail.get_tree_hash(), tail))
+
+        return eve_spend
+
+
+class GenesisByPuzhash(LimitationsProgram):
+    """
+    This TAIL allows for issuance of a certain coin only by a specific puzzle hash.
+    There is no minting or melting allowed.
+    """
+
+    @staticmethod
+    def match(uncurried_mod: Program, curried_args: Program) -> tuple[bool, list[Program]]:
+        if uncurried_mod == GENESIS_BY_PUZHASH_MOD:
+            genesis_puzhash = curried_args.first()
+            return True, [genesis_puzhash]
+        else:
+            return False, []
+
+    @staticmethod
+    def construct(args: list[Program]) -> Program:
+        return GENESIS_BY_PUZHASH_MOD.curry(args[0])
+
+    @staticmethod
+    def solve(args: list[Program], solution_dict: dict) -> Program:
+        pid = hexstr_to_bytes(solution_dict["parent_coin_info"])
+        return Program.to([pid, solution_dict["amount"]])
+
+
+class EverythingWithSig(LimitationsProgram):
+    """
+    This TAIL allows for issuance, minting, and melting as long as you provide a signature with the spend.
+    """
+
+    @staticmethod
+    def match(uncurried_mod: Program, curried_args: Program) -> tuple[bool, list[Program]]:
+        if uncurried_mod == EVERYTHING_WITH_SIG_MOD:
+            pubkey = curried_args.first()
+            return True, [pubkey]
+        else:
+            return False, []
+
+    @staticmethod
+    def construct(args: list[Program]) -> Program:
+        return EVERYTHING_WITH_SIG_MOD.curry(args[0])
+
+    @staticmethod
+    def solve(args: list[Program], solution_dict: dict) -> Program:
+        return Program.to([])
+
+
+class DelegatedLimitations(LimitationsProgram):
+    """
+    This TAIL allows for another TAIL to be used, as long as a signature of that TAIL's puzzlehash is included.
+    """
+
+    @staticmethod
+    def match(uncurried_mod: Program, curried_args: Program) -> tuple[bool, list[Program]]:
+        if uncurried_mod == DELEGATED_LIMITATIONS_MOD:
+            pubkey = curried_args.first()
+            return True, [pubkey]
+        else:
+            return False, []
+
+    @staticmethod
+    def construct(args: list[Program]) -> Program:
+        return DELEGATED_LIMITATIONS_MOD.curry(args[0])
+
+    @staticmethod
+    def solve(args: list[Program], solution_dict: dict) -> Program:
+        signed_program = ALL_LIMITATIONS_PROGRAMS[solution_dict["signed_program"]["identifier"]]
+        inner_program_args = [Program.fromhex(item) for item in solution_dict["signed_program"]["args"]]
+        inner_solution_dict = solution_dict["program_arguments"]
+        return Program.to(
+            [
+                signed_program.construct(inner_program_args),
+                signed_program.solve(inner_program_args, inner_solution_dict),
+            ]
+        )
+
+
+class GenesisByIdOrSingleton(LimitationsProgram):
+    """
+    This TAIL allows for another TAIL to be used, as long as a signature of that TAIL's puzzlehash is included.
+    """
+
+    @staticmethod
+    def match(uncurried_mod: Program, curried_args: Program) -> tuple[bool, list[Program]]:  # pragma: no cover
+        if uncurried_mod == GENESIS_BY_ID_OR_SINGLETON_MOD:
+            genesis_id = curried_args.first()
+            return True, [genesis_id]
+        else:
+            return False, []
+
+    @staticmethod
+    def construct(args: list[Program]) -> Program:
+        return GENESIS_BY_ID_OR_SINGLETON_MOD.curry(
+            args[0],
+            args[1],
+        )
+
+    @staticmethod
+    def solve(args: list[Program], solution_dict: dict) -> Program:  # pragma: no cover
+        pid = hexstr_to_bytes(solution_dict["parent_coin_info"])
+        return Program.to([pid, solution_dict["amount"]])
+
+    @classmethod
+    async def generate_issuance_bundle(
+        cls,
+        wallet,
+        tail_info: dict,
+        amount: uint64,
+        action_scope: WalletActionScope,
+        fee: uint64 = uint64(0),
+    ) -> WalletSpendBundle:
+        if "coins" in tail_info:
+            coins: list[Coin] = tail_info["coins"]
+            origin_id = coins.copy().pop().name()
+        else:  # pragma: no cover
+            coins = await wallet.standard_wallet.select_coins(amount + fee, action_scope)
+            origin = coins.copy().pop()
+            origin_id = origin.name()
+
+        cat_inner: Program = await wallet.standard_wallet.get_puzzle(
+            new=not action_scope.config.tx_config.reuse_puzhash
+        )
+        # GENESIS_ID
+        # TREASURY_SINGLETON_STRUCT  ; (SINGLETON_MOD_HASH, (LAUNCHER_ID, LAUNCHER_PUZZLE_HASH))
+        launcher_puzhash = create_cat_launcher_for_singleton_id(tail_info["treasury_id"]).get_tree_hash()
+        tail: Program = cls.construct(
+            [
+                Program.to(origin_id),
+                Program.to(launcher_puzhash),
+            ]
+        )
+
+        wallet.lineage_store = await CATLineageStore.create(
+            wallet.wallet_state_manager.db_wrapper, tail.get_tree_hash().hex()
+        )
+        await wallet.add_lineage(origin_id, LineageProof())
+
+        minted_cat_puzzle_hash: bytes32 = construct_cat_puzzle(CAT_MOD, tail.get_tree_hash(), cat_inner).get_tree_hash()
+
+        async with wallet.wallet_state_manager.new_action_scope(
+            action_scope.config.tx_config, push=False
+        ) as inner_action_scope:
+            await wallet.standard_wallet.generate_signed_transaction(
+                amount,
+                minted_cat_puzzle_hash,
+                inner_action_scope,
+                fee,
+                coins=set(coins),
+                origin_id=origin_id,
+            )
+
+        async with action_scope.use() as interface:
+            interface.side_effects.transactions.extend(inner_action_scope.side_effects.transactions)
+        tx_record: TransactionRecord = inner_action_scope.side_effects.transactions[0]
+        assert tx_record.spend_bundle is not None
+        payment = Payment(cat_inner.get_tree_hash(), amount)
+        inner_solution = wallet.standard_wallet.add_condition_to_solution(
+            Program.to([51, 0, -113, tail, []]),
+            wallet.standard_wallet.make_solution(
+                primaries=[payment],
+            ),
+        )
+        eve_spend = unsigned_spend_bundle_for_spendable_cats(
+            CAT_MOD,
+            [
+                SpendableCAT(
+                    next(filter(lambda a: a.amount == amount, tx_record.additions)),
+                    tail.get_tree_hash(),
+                    cat_inner,
+                    inner_solution,
+                    limitations_program_reveal=tail,
+                )
+            ],
+        )
+
+        if wallet.cat_info.my_tail is None:
+            await wallet.save_info(CATInfo(tail.get_tree_hash(), tail))
+
+        return eve_spend
+
+
+# This should probably be much more elegant than just a dictionary with strings as identifiers
+# Right now this is small and experimental so it can stay like this
+ALL_LIMITATIONS_PROGRAMS: dict[str, Any] = {
+    "genesis_by_id": GenesisById,
+    "genesis_by_puzhash": GenesisByPuzhash,
+    "everything_with_signature": EverythingWithSig,
+    "delegated_limitations": DelegatedLimitations,
+    "genesis_by_id_or_singleton": GenesisByIdOrSingleton,
+}
+
+
+def match_limitations_program(limitations_program: Program) -> tuple[Optional[LimitationsProgram], list[Program]]:
+    uncurried_mod, curried_args = limitations_program.uncurry()
+    for key, lp in ALL_LIMITATIONS_PROGRAMS.items():
+        matched, args = lp.match(uncurried_mod, curried_args)
+        if matched:
+            return lp, args
+    return None, []

chia/wallet/puzzles/utility_macros.clib

@@ -0,0 +1,48 @@
+(
+  ; assert takes a list of parameters
+  ; all items in the list are required to be non-nil
+  ; except for the final item which is returned
+  (defmacro assert items
+    (if (r items)
+        (list if (f items) (c assert (r items)) (q . (x)))
+        (f items)
+    )
+  )
+
+  (defmacro and ARGS
+    (if ARGS
+        (qq (if (unquote (f ARGS))
+                (unquote (c and (r ARGS)))
+                ()
+        ))
+    1)
+  )
+
+  (defmacro or ARGS
+    (if ARGS
+        (qq (if (unquote (f ARGS))
+                1
+                (unquote (c or (r ARGS)))
+        ))
+    0)
+  )
+
+  (defun in (atom list_a)
+    (if list_a
+        (i (= atom (f list_a))
+          1
+          (in atom (r list_a))
+        )
+        ()
+    )
+  )
+
+  (defun gte (atom_a atom_b)
+    (not (> atom_b atom_a))
+  )
+
+  (defun lte (atom_a atom_b)
+    (not (> atom_a atom_b))
+  )
+
+)

chia/wallet/signer_protocol.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from chia.types.blockchain_format.coin import Coin as _Coin
+from chia.types.blockchain_format.program import Program
+from chia.types.blockchain_format.serialized_program import SerializedProgram
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.coin_spend import CoinSpend
+from chia.util.ints import uint64
+from chia.util.streamable import Streamable
+from chia.wallet.util.clvm_streamable import clvm_streamable
+
+# This file contains the base types for communication between a wallet and an offline transaction signer.
+# These types should be compliant with CHIP-0028
+
+
+@clvm_streamable
+@dataclass(frozen=True)
+class Coin(Streamable):
+    parent_coin_id: bytes32
+    puzzle_hash: bytes32
+    amount: uint64
+
+
+@clvm_streamable
+@dataclass(frozen=True)
+class Spend(Streamable):
+    coin: Coin
+    puzzle: Program
+    solution: Program
+
+    @classmethod
+    def from_coin_spend(cls, coin_spend: CoinSpend) -> Spend:
+        return cls(
+            Coin(
+                coin_spend.coin.parent_coin_info,
+                coin_spend.coin.puzzle_hash,
+                uint64(coin_spend.coin.amount),
+            ),
+            coin_spend.puzzle_reveal.to_program(),
+            coin_spend.solution.to_program(),
+        )
+
+    def as_coin_spend(self) -> CoinSpend:
+        return CoinSpend(
+            _Coin(
+                self.coin.parent_coin_id,
+                self.coin.puzzle_hash,
+                self.coin.amount,
+            ),
+            SerializedProgram.from_program(self.puzzle),
+            SerializedProgram.from_program(self.solution),
+        )
+
+
+@clvm_streamable
+@dataclass(frozen=True)
+class TransactionInfo(Streamable):
+    spends: list[Spend]
+
+
+@clvm_streamable
+@dataclass(frozen=True)
+class SigningTarget(Streamable):
+    fingerprint: bytes
+    message: bytes
+    hook: bytes32
+
+
+@clvm_streamable
+@dataclass(frozen=True)
+class SumHint(Streamable):
+    fingerprints: list[bytes]
+    synthetic_offset: bytes
+    final_pubkey: bytes
+
+
+@clvm_streamable
+@dataclass(frozen=True)
+class PathHint(Streamable):
+    root_fingerprint: bytes
+    path: list[uint64]
+
+
+@clvm_streamable
+@dataclass(frozen=True)
+class KeyHints(Streamable):
+    sum_hints: list[SumHint]
+    path_hints: list[PathHint]
+
+
+@clvm_streamable
+@dataclass(frozen=True)
+class SigningInstructions(Streamable):
+    key_hints: KeyHints
+    targets: list[SigningTarget]
+
+
+@clvm_streamable
+@dataclass(frozen=True)
+class UnsignedTransaction(Streamable):
+    transaction_info: TransactionInfo
+    signing_instructions: SigningInstructions
+
+
+@clvm_streamable
+@dataclass(frozen=True)
+class SigningResponse(Streamable):
+    signature: bytes
+    hook: bytes32
+
+
+@clvm_streamable
+@dataclass(frozen=True)
+class Signature(Streamable):
+    type: str
+    signature: bytes
+
+
+@clvm_streamable
+@dataclass(frozen=True)
+class SignedTransaction(Streamable):
+    transaction_info: TransactionInfo
+    signatures: list[Signature]

chia/wallet/singleton.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+from typing import Optional, Union
+
+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.blockchain_format.sized_bytes import bytes32
+from chia.types.coin_spend import CoinSpend, compute_additions
+from chia.wallet.puzzles.load_clvm import load_clvm_maybe_recompile
+from chia.wallet.util.curry_and_treehash import (
+    calculate_hash_of_quoted_mod_hash,
+    curry_and_treehash,
+    shatree_atom,
+    shatree_pair,
+)
+
+SINGLETON_TOP_LAYER_MOD = load_clvm_maybe_recompile("singleton_top_layer_v1_1.clsp")
+SINGLETON_TOP_LAYER_MOD_HASH = SINGLETON_TOP_LAYER_MOD.get_tree_hash()
+SINGLETON_TOP_LAYER_MOD_HASH_TREE_HASH = shatree_atom(SINGLETON_TOP_LAYER_MOD_HASH)
+SINGLETON_TOP_LAYER_MOD_HASH_QUOTED = calculate_hash_of_quoted_mod_hash(SINGLETON_TOP_LAYER_MOD_HASH)
+SINGLETON_LAUNCHER_PUZZLE = load_clvm_maybe_recompile("singleton_launcher.clsp")
+SINGLETON_LAUNCHER_PUZZLE_HASH = SINGLETON_LAUNCHER_PUZZLE.get_tree_hash()
+SINGLETON_LAUNCHER_PUZZLE_HASH_TREE_HASH = shatree_atom(SINGLETON_LAUNCHER_PUZZLE_HASH)
+
+
+def get_inner_puzzle_from_singleton(puzzle: Union[Program, SerializedProgram]) -> Optional[Program]:
+    """
+    Extract the inner puzzle of a singleton
+    :param puzzle: Singleton puzzle
+    :return: Inner puzzle
+    """
+    r = puzzle.uncurry()
+    if r is None:
+        return None
+    inner_f, args = r
+    if not is_singleton(inner_f):
+        return None
+    _SINGLETON_STRUCT, INNER_PUZZLE = list(args.as_iter())
+    return Program(INNER_PUZZLE)
+
+
+def get_singleton_id_from_puzzle(puzzle: Union[Program, SerializedProgram]) -> Optional[bytes32]:
+    """
+    Extract the singleton ID from a singleton puzzle
+    :param puzzle: Singleton puzzle
+    :return: Inner puzzle
+    """
+    r = puzzle.uncurry()
+    if r is None:
+        return None  # pragma: no cover
+    inner_f, args = r
+    if not is_singleton(inner_f):
+        return None
+    SINGLETON_STRUCT, _INNER_PUZZLE = list(args.as_iter())
+    return bytes32(Program(SINGLETON_STRUCT).rest().first().as_atom())
+
+
+def is_singleton(inner_f: Union[Program, SerializedProgram]) -> bool:
+    """
+    Check if a puzzle is a singleton mod
+    :param inner_f: puzzle
+    :return: Boolean
+    """
+    return inner_f == SINGLETON_TOP_LAYER_MOD
+
+
+def create_singleton_puzzle_hash(innerpuz_hash: bytes32, launcher_id: bytes32) -> bytes32:
+    """
+    Return Hash ID of the whole Singleton Puzzle
+    :param innerpuz_hash: Singleton inner puzzle tree hash
+    :param launcher_id: launcher coin name
+    :return: Singleton full puzzle hash
+    """
+    # singleton_struct = (MOD_HASH . (LAUNCHER_ID . LAUNCHER_PUZZLE_HASH))
+    singleton_struct = shatree_pair(
+        SINGLETON_TOP_LAYER_MOD_HASH_TREE_HASH,
+        shatree_pair(shatree_atom(launcher_id), SINGLETON_LAUNCHER_PUZZLE_HASH_TREE_HASH),
+    )
+
+    return curry_and_treehash(SINGLETON_TOP_LAYER_MOD_HASH_QUOTED, singleton_struct, innerpuz_hash)
+
+
+def create_singleton_puzzle(innerpuz: Union[Program, SerializedProgram], launcher_id: bytes32) -> Program:
+    """
+    Create a full Singleton puzzle
+    :param innerpuz: Singleton inner puzzle
+    :param launcher_id:
+    :return: Singleton full puzzle
+    """
+    # singleton_struct = (MOD_HASH . (LAUNCHER_ID . LAUNCHER_PUZZLE_HASH))
+    singleton_struct = Program.to((SINGLETON_TOP_LAYER_MOD_HASH, (launcher_id, SINGLETON_LAUNCHER_PUZZLE_HASH)))
+    return SINGLETON_TOP_LAYER_MOD.curry(singleton_struct, innerpuz)
+
+
+def get_most_recent_singleton_coin_from_coin_spend(coin_sol: CoinSpend) -> Optional[Coin]:
+    additions: list[Coin] = compute_additions(coin_sol)
+    for coin in additions:
+        if coin.amount % 2 == 1:
+            return coin
+    return None  # pragma: no cover
+
+
+def get_singleton_struct_for_id(id: bytes32) -> Program:
+    singleton_struct: Program = Program.to((SINGLETON_TOP_LAYER_MOD_HASH, (id, SINGLETON_LAUNCHER_PUZZLE_HASH)))
+    return singleton_struct

chia/wallet/singleton_record.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Optional
+
+from chia.types.blockchain_format.coin import Coin
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.coin_spend import CoinSpend
+from chia.util.ints import uint32
+from chia.wallet.lineage_proof import LineageProof
+
+
+@dataclass(frozen=True)
+class SingletonRecord:
+    """
+    These are values that correspond to a singleton in the WalletSingletonStore
+    """
+
+    coin: Coin
+    singleton_id: bytes32
+    wallet_id: uint32
+    parent_coinspend: CoinSpend
+    inner_puzzle_hash: Optional[bytes32]
+    pending: bool
+    removed_height: int
+    lineage_proof: LineageProof
+    custom_data: Optional[Any]
+
+    def name(self) -> bytes32:  # pragma: no cover
+        return self.coin.name()