chia-blockchain 2.5.1rc1__py3-none-any.whl

chia/wallet/nft_wallet/uncurry_nft.py

@@ -0,0 +1,217 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from typing import Optional, TypeVar
+
+from chia.protocols.wallet_protocol import CoinState
+from chia.types.blockchain_format.program import Program
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.coin_spend import CoinSpend
+from chia.util.ints import uint16
+from chia.util.streamable import Streamable, streamable
+from chia.wallet.puzzles.load_clvm import load_clvm_maybe_recompile
+
+log = logging.getLogger(__name__)
+SINGLETON_TOP_LAYER_MOD = load_clvm_maybe_recompile("singleton_top_layer_v1_1.clsp")
+NFT_MOD = load_clvm_maybe_recompile("nft_state_layer.clsp", package_or_requirement="chia.wallet.nft_wallet.puzzles")
+NFT_OWNERSHIP_LAYER = load_clvm_maybe_recompile(
+    "nft_ownership_layer.clsp", package_or_requirement="chia.wallet.nft_wallet.puzzles"
+)
+
+_T_UncurriedNFT = TypeVar("_T_UncurriedNFT", bound="UncurriedNFT")
+
+
+@streamable
+@dataclass(frozen=True)
+class UncurriedNFT(Streamable):
+    """
+    A simple solution for uncurry NFT puzzle.
+    Initial the class with a full NFT puzzle, it will do a deep uncurry.
+    This is the only place you need to change after modified the Chialisp curried parameters.
+    """
+
+    nft_mod_hash: bytes32
+    """NFT module hash"""
+
+    nft_state_layer: Program
+    """NFT state layer puzzle"""
+
+    singleton_struct: Program
+    """
+    Singleton struct
+    [singleton_mod_hash, singleton_launcher_id, launcher_puzhash]
+    """
+    singleton_mod_hash: Program
+    singleton_launcher_id: bytes32
+    launcher_puzhash: Program
+
+    metadata_updater_hash: Program
+    """Metadata updater puzzle hash"""
+
+    metadata: Program
+    """
+    NFT metadata
+    [("u", data_uris), ("h", data_hash)]
+    """
+    data_uris: Program
+    data_hash: Program
+    meta_uris: Program
+    meta_hash: Program
+    license_uris: Program
+    license_hash: Program
+    edition_number: Program
+    edition_total: Program
+
+    inner_puzzle: Program
+    """NFT state layer inner puzzle"""
+
+    p2_puzzle: Program
+    """p2 puzzle of the owner, either for ownership layer or standard"""
+
+    # ownership layer fields
+    owner_did: Optional[bytes32]
+    """Owner's DID"""
+
+    supports_did: bool
+    """If the inner puzzle support the DID"""
+
+    nft_inner_puzzle_hash: Optional[bytes32]
+    """Puzzle hash of the ownership layer inner puzzle """
+
+    transfer_program: Optional[Program]
+    """Puzzle hash of the transfer program"""
+
+    transfer_program_curry_params: Optional[Program]
+    """
+    Curried parameters of the transfer program
+    [royalty_address, trade_price_percentage, settlement_mod_hash, cat_mod_hash]
+    """
+    royalty_address: Optional[bytes32]
+    trade_price_percentage: Optional[uint16]
+
+    @classmethod
+    def uncurry(cls: type[_T_UncurriedNFT], mod: Program, curried_args: Program) -> Optional[_T_UncurriedNFT]:
+        """
+        Try to uncurry a NFT puzzle
+        :param cls UncurriedNFT class
+        :param mod: uncurried Puzzle program
+        :param uncurried_args: uncurried arguments to program
+        :return Uncurried NFT
+        """
+        if mod != SINGLETON_TOP_LAYER_MOD:
+            log.debug("Cannot uncurry NFT puzzle, failed on singleton top layer: Mod %s", mod)
+            return None
+        try:
+            (singleton_struct, nft_state_layer) = curried_args.as_iter()
+            singleton_mod_hash = singleton_struct.first()
+            singleton_launcher_id = singleton_struct.rest().first()
+            launcher_puzhash = singleton_struct.rest().rest()
+        except ValueError as e:
+            log.debug("Cannot uncurry singleton top layer: Args %s error: %s", curried_args, e)
+            return None
+
+        mod, curried_args = curried_args.rest().first().uncurry()
+        if mod != NFT_MOD:
+            log.debug("Cannot uncurry NFT puzzle, failed on NFT state layer: Mod %s", mod)
+            return None
+        try:
+            # Set nft parameters
+            nft_mod_hash, metadata, metadata_updater_hash, inner_puzzle = curried_args.as_iter()
+            data_uris = Program.to([])
+            data_hash = Program.to(0)
+            meta_uris = Program.to([])
+            meta_hash = Program.to(0)
+            license_uris = Program.to([])
+            license_hash = Program.to(0)
+            edition_number = Program.to(1)
+            edition_total = Program.to(1)
+            # Set metadata
+            for kv_pair in metadata.as_iter():
+                if kv_pair.first().as_atom() == b"u":
+                    data_uris = kv_pair.rest()
+                if kv_pair.first().as_atom() == b"h":
+                    data_hash = kv_pair.rest()
+                if kv_pair.first().as_atom() == b"mu":
+                    meta_uris = kv_pair.rest()
+                if kv_pair.first().as_atom() == b"mh":
+                    meta_hash = kv_pair.rest()
+                if kv_pair.first().as_atom() == b"lu":
+                    license_uris = kv_pair.rest()
+                if kv_pair.first().as_atom() == b"lh":
+                    license_hash = kv_pair.rest()
+                if kv_pair.first().as_atom() == b"sn":
+                    edition_number = kv_pair.rest()
+                if kv_pair.first().as_atom() == b"st":
+                    edition_total = kv_pair.rest()
+            current_did: Optional[bytes32] = None
+            transfer_program = None
+            transfer_program_args = None
+            royalty_address: Optional[bytes32] = None
+            royalty_percentage: Optional[uint16] = None
+            nft_inner_puzzle_mod = None
+            mod, ol_args = inner_puzzle.uncurry()
+            supports_did = False
+            if mod == NFT_OWNERSHIP_LAYER:
+                supports_did = True
+                log.debug("Parsing ownership layer")
+                _, current_did_p, transfer_program, p2_puzzle = ol_args.as_iter()
+                _, transfer_program_args = transfer_program.uncurry()
+                _, royalty_address_p, royalty_percentage_p = transfer_program_args.as_iter()
+                royalty_percentage = uint16(royalty_percentage_p.as_int())
+                royalty_address = bytes32(royalty_address_p.as_atom())
+                current_did_atom = current_did_p.as_atom()
+                if current_did_atom == b"":
+                    # For unassigned NFT, set owner DID to None
+                    current_did = None
+                else:
+                    current_did = bytes32(current_did_atom)
+            else:
+                log.debug("Creating a standard NFT puzzle")
+                p2_puzzle = inner_puzzle
+        except Exception as e:
+            log.debug("Cannot uncurry NFT state layer: Args %s Error: %s", curried_args, e)
+            return None
+
+        return cls(
+            nft_mod_hash=bytes32(nft_mod_hash.as_atom()),
+            nft_state_layer=nft_state_layer,
+            singleton_struct=singleton_struct,
+            singleton_mod_hash=singleton_mod_hash,
+            singleton_launcher_id=bytes32(singleton_launcher_id.as_atom()),
+            launcher_puzhash=launcher_puzhash,
+            metadata=metadata,
+            data_uris=data_uris,
+            data_hash=data_hash,
+            p2_puzzle=p2_puzzle,
+            metadata_updater_hash=metadata_updater_hash,
+            meta_uris=meta_uris,
+            meta_hash=meta_hash,
+            license_uris=license_uris,
+            license_hash=license_hash,
+            edition_number=edition_number,
+            edition_total=edition_total,
+            inner_puzzle=inner_puzzle,
+            owner_did=current_did,
+            supports_did=supports_did,
+            transfer_program=transfer_program,
+            transfer_program_curry_params=transfer_program_args,
+            royalty_address=royalty_address,
+            trade_price_percentage=royalty_percentage,
+            nft_inner_puzzle_hash=nft_inner_puzzle_mod,
+        )
+
+    def get_innermost_solution(self, solution: Program) -> Program:
+        state_layer_inner_solution: Program = solution.at("rrff")
+        if self.supports_did:
+            return state_layer_inner_solution.first()
+        else:
+            return state_layer_inner_solution
+
+
+@streamable
+@dataclass(frozen=True)
+class NFTCoinData(Streamable):
+    uncurried_nft: UncurriedNFT
+    parent_coin_state: CoinState
+    parent_coin_spend: CoinSpend

chia/wallet/notification_manager.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+import logging
+from typing import Any, Optional
+
+from chia_rs import G2Element
+
+from chia.protocols.wallet_protocol import CoinState
+from chia.types.blockchain_format.coin import Coin
+from chia.types.blockchain_format.program import Program
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.coin_spend import CoinSpend, make_spend
+from chia.util.db_wrapper import DBWrapper2
+from chia.util.ints import uint32, uint64
+from chia.wallet.conditions import AssertCoinAnnouncement, Condition
+from chia.wallet.notification_store import Notification, NotificationStore
+from chia.wallet.util.compute_memos import compute_memos_for_spend
+from chia.wallet.util.notifications import construct_notification
+from chia.wallet.util.wallet_types import WalletType
+from chia.wallet.wallet_action_scope import WalletActionScope
+from chia.wallet.wallet_spend_bundle import WalletSpendBundle
+
+
+class NotificationManager:
+    wallet_state_manager: Any
+    log: logging.Logger
+    notification_store: NotificationStore
+
+    @staticmethod
+    async def create(
+        wallet_state_manager: Any,
+        db_wrapper: DBWrapper2,
+        name: Optional[str] = None,
+    ) -> NotificationManager:
+        self = NotificationManager()
+        if name:
+            self.log = logging.getLogger(name)
+        else:
+            self.log = logging.getLogger(__name__)
+
+        self.wallet_state_manager = wallet_state_manager
+        self.notification_store = await NotificationStore.create(db_wrapper)
+        return self
+
+    async def potentially_add_new_notification(self, coin_state: CoinState, parent_spend: CoinSpend) -> bool:
+        coin_name: bytes32 = coin_state.coin.name()
+        if (
+            coin_state.spent_height is None
+            or not self.wallet_state_manager.wallet_node.config.get("enable_notifications", True)
+            or self.wallet_state_manager.wallet_node.config.get("required_notification_amount", 100000000)
+            > coin_state.coin.amount
+            or await self.notification_store.notification_exists(coin_name)
+        ):
+            return False
+        else:
+            memos: dict[bytes32, list[bytes]] = compute_memos_for_spend(parent_spend)
+            coin_memos: list[bytes] = memos.get(coin_name, [])
+            if len(coin_memos) == 0 or len(coin_memos[0]) != 32:
+                return False
+            wallet_identifier = await self.wallet_state_manager.get_wallet_identifier_for_puzzle_hash(
+                bytes32(coin_memos[0])
+            )
+            if (
+                wallet_identifier is not None
+                and wallet_identifier.type == WalletType.STANDARD_WALLET
+                and len(coin_memos) == 2
+                and construct_notification(bytes32(coin_memos[0]), uint64(coin_state.coin.amount)).get_tree_hash()
+                == coin_state.coin.puzzle_hash
+            ):
+                if len(coin_memos[1]) > 10000:  # 10KB
+                    return False
+                await self.notification_store.add_notification(
+                    Notification(
+                        coin_state.coin.name(),
+                        coin_memos[1],
+                        uint64(coin_state.coin.amount),
+                        uint32(coin_state.spent_height),
+                    )
+                )
+                self.wallet_state_manager.state_changed("new_on_chain_notification")
+            return True
+
+    async def send_new_notification(
+        self,
+        target: bytes32,
+        msg: bytes,
+        amount: uint64,
+        action_scope: WalletActionScope,
+        fee: uint64 = uint64(0),
+        extra_conditions: tuple[Condition, ...] = tuple(),
+    ) -> None:
+        coins: set[Coin] = await self.wallet_state_manager.main_wallet.select_coins(uint64(amount + fee), action_scope)
+        origin_coin: bytes32 = next(iter(coins)).name()
+        notification_puzzle: Program = construct_notification(target, amount)
+        notification_hash: bytes32 = notification_puzzle.get_tree_hash()
+        notification_coin: Coin = Coin(origin_coin, notification_hash, amount)
+        notification_spend = make_spend(
+            notification_coin,
+            notification_puzzle,
+            Program.to(None),
+        )
+        extra_spend_bundle = WalletSpendBundle([notification_spend], G2Element())
+        await self.wallet_state_manager.main_wallet.generate_signed_transaction(
+            amount,
+            notification_hash,
+            action_scope,
+            fee,
+            coins=coins,
+            origin_id=origin_coin,
+            memos=[target, msg],
+            extra_conditions=(
+                *extra_conditions,
+                AssertCoinAnnouncement(asserted_id=notification_coin.name(), asserted_msg=b""),
+            ),
+        )
+        async with action_scope.use() as interface:
+            interface.side_effects.extra_spends.append(extra_spend_bundle)

chia/wallet/notification_store.py

@@ -0,0 +1,178 @@
+from __future__ import annotations
+
+import dataclasses
+import logging
+import sqlite3
+from typing import Optional
+
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.util.db_wrapper import DBWrapper2
+from chia.util.ints import uint32, uint64
+from chia.util.streamable import Streamable, streamable
+
+
+@streamable
+@dataclasses.dataclass(frozen=True)
+class Notification(Streamable):
+    id: bytes32
+    message: bytes
+    amount: uint64
+    height: uint32
+
+
+class NotificationStore:
+    """
+    NotificationStore stores trading history.
+    """
+
+    cache_size: uint32
+    db_wrapper: DBWrapper2
+    log: logging.Logger
+
+    @classmethod
+    async def create(
+        cls, db_wrapper: DBWrapper2, cache_size: uint32 = uint32(600000), name: Optional[str] = None
+    ) -> NotificationStore:
+        self = cls()
+
+        if name:
+            self.log = logging.getLogger(name)
+        else:
+            self.log = logging.getLogger(__name__)
+
+        self.cache_size = cache_size
+        self.db_wrapper = db_wrapper
+
+        async with self.db_wrapper.writer_maybe_transaction() as conn:
+            await conn.execute(
+                "CREATE TABLE IF NOT EXISTS notifications(coin_id blob PRIMARY KEY, msg blob, amount blob)"
+            )
+
+            await conn.execute("CREATE TABLE IF NOT EXISTS all_notification_ids(coin_id blob PRIMARY KEY)")
+
+            try:
+                await conn.execute("ALTER TABLE notifications ADD COLUMN height bigint DEFAULT 0")
+            except sqlite3.OperationalError as e:
+                if "duplicate column" in e.args[0]:
+                    pass  # ignore what is likely Duplicate column error
+                else:
+                    raise e
+
+            # This used to be an accidentally created redundant index on coin_id which is already a primary key
+            # We can remove this at some point in the future when it's unlikely this index still exists
+            await conn.execute("DROP INDEX IF EXISTS coin_id_index")
+
+        return self
+
+    async def add_notification(self, notification: Notification) -> None:
+        """
+        Store Notification into DB
+        """
+        async with self.db_wrapper.writer_maybe_transaction() as conn:
+            cursor = await conn.execute(
+                "INSERT OR REPLACE INTO notifications (coin_id, msg, amount, height) VALUES(?, ?, ?, ?)",
+                (
+                    notification.id,
+                    notification.message,
+                    notification.amount.stream_to_bytes(),
+                    notification.height,
+                ),
+            )
+            cursor = await conn.execute(
+                "INSERT OR REPLACE INTO all_notification_ids (coin_id) VALUES(?)",
+                (notification.id,),
+            )
+            await cursor.close()
+
+    async def get_notifications(self, coin_ids: list[bytes32]) -> list[Notification]:
+        """
+        Checks DB for Notification with id: id and returns it.
+        """
+        coin_ids_str_list = "("
+        for _ in coin_ids:
+            coin_ids_str_list += "?"
+            coin_ids_str_list += ","
+        coin_ids_str_list = coin_ids_str_list[:-1] if len(coin_ids_str_list) > 1 else "("
+        coin_ids_str_list += ")"
+
+        async with self.db_wrapper.reader_no_transaction() as conn:
+            rows = await conn.execute_fetchall(
+                f"SELECT * from notifications WHERE coin_id IN {coin_ids_str_list} ORDER BY amount DESC", coin_ids
+            )
+
+        return [
+            Notification(
+                bytes32(row[0]),
+                bytes(row[1]),
+                uint64.from_bytes(row[2]),
+                uint32(row[3]),
+            )
+            for row in rows
+        ]
+
+    async def get_all_notifications(
+        self, pagination: Optional[tuple[Optional[int], Optional[int]]] = None
+    ) -> list[Notification]:
+        """
+        Checks DB for Notification with id: id and returns it.
+        """
+        if pagination is not None:
+            if pagination[1] is not None and pagination[0] is not None:
+                pagination_str = " LIMIT ?, ?"
+                pagination_params: tuple[int, ...] = (pagination[0], pagination[1] - pagination[0])
+            elif pagination[1] is None and pagination[0] is not None:
+                pagination_str = " LIMIT ?, (SELECT COUNT(*) from notifications)"
+                pagination_params = (pagination[0],)
+            elif pagination[1] is not None and pagination[0] is None:
+                pagination_str = " LIMIT ?"
+                pagination_params = (pagination[1],)
+            else:
+                pagination_str = ""
+                pagination_params = tuple()
+        else:
+            pagination_str = ""
+            pagination_params = tuple()
+
+        async with self.db_wrapper.reader_no_transaction() as conn:
+            rows = await conn.execute_fetchall(
+                f"SELECT * from notifications ORDER BY amount DESC{pagination_str}", pagination_params
+            )
+
+        return [
+            Notification(
+                bytes32(row[0]),
+                bytes(row[1]),
+                uint64.from_bytes(row[2]),
+                uint32(row[3]),
+            )
+            for row in rows
+        ]
+
+    async def delete_notifications(self, coin_ids: list[bytes32]) -> None:
+        coin_ids_str_list = "("
+        for _ in coin_ids:
+            coin_ids_str_list += "?"
+            coin_ids_str_list += ","
+        coin_ids_str_list = coin_ids_str_list[:-1] if len(coin_ids_str_list) > 1 else "("
+        coin_ids_str_list += ")"
+
+        async with self.db_wrapper.writer_maybe_transaction() as conn:
+            # Delete from storage
+            cursor = await conn.execute(f"DELETE FROM notifications WHERE coin_id IN {coin_ids_str_list}", coin_ids)
+            await cursor.close()
+
+    async def delete_all_notifications(self) -> None:
+        async with self.db_wrapper.writer_maybe_transaction() as conn:
+            # Delete from storage
+            cursor = await conn.execute("DELETE FROM notifications")
+            await cursor.close()
+
+    async def notification_exists(self, id: bytes32) -> bool:
+        async with self.db_wrapper.reader_no_transaction() as conn:
+            async with conn.execute(
+                "SELECT EXISTS (SELECT 1 from all_notification_ids WHERE coin_id=?)", (id,)
+            ) as cursor:
+                row = await cursor.fetchone()
+                assert row is not None
+                exists: bool = row[0] > 0
+                return exists

chia/wallet/outer_puzzles.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+from enum import Enum
+from typing import Optional
+
+from chia.types.blockchain_format.program import Program
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.wallet.cat_wallet.cat_outer_puzzle import CATOuterPuzzle
+from chia.wallet.driver_protocol import DriverProtocol
+from chia.wallet.nft_wallet.metadata_outer_puzzle import MetadataOuterPuzzle
+from chia.wallet.nft_wallet.ownership_outer_puzzle import OwnershipOuterPuzzle
+from chia.wallet.nft_wallet.singleton_outer_puzzle import SingletonOuterPuzzle
+from chia.wallet.nft_wallet.transfer_program_puzzle import TransferProgramPuzzle
+from chia.wallet.puzzle_drivers import PuzzleInfo, Solver
+from chia.wallet.uncurried_puzzle import UncurriedPuzzle
+from chia.wallet.vc_wallet.cr_outer_puzzle import CROuterPuzzle
+
+"""
+This file provides a central location for acquiring drivers for outer puzzles like CATs, NFTs, etc.
+
+A driver for a puzzle must include the following functions:
+  - match(self, puzzle: UncurriedPuzzle) -> Optional[PuzzleInfo]
+    - Given a puzzle reveal, return a PuzzleInfo object that can be used to reconstruct it later
+  - get_inner_puzzle(self, constructor: PuzzleInfo, puzzle_reveal: UncurriedPuzzle) -> Optional[Program]:
+    - Given a PuzzleInfo object and a puzzle reveal, pull out this outer puzzle's inner puzzle
+  - asset_id(self, constructor: PuzzleInfo) -> Optional[bytes32]
+    - Given a PuzzleInfo object, generate a 32 byte ID for use in dictionaries, etc.
+  - construct(self, constructor: PuzzleInfo, inner_puzzle: Program) -> Program
+    - Given a PuzzleInfo object and an innermost puzzle, construct a puzzle reveal for a coin spend
+  - solve(self, constructor: PuzzleInfo, solver: Solver, inner_puzzle: Program, inner_solution: Program) -> Program
+    - Given a PuzzleInfo object, a Solver object, and an innermost puzzle and its solution return a solution for a spend
+    - The "Solver" object can contain any dictionary, it's up to the driver to enforce the needed elements of the API
+    - Some classes that wish to integrate with a driver may not have access to all of the info it needs so the driver
+      needs to raise errors appropriately
+"""
+
+
+class AssetType(Enum):
+    CAT = "CAT"
+    SINGLETON = "singleton"
+    METADATA = "metadata"
+    OWNERSHIP = "ownership"
+    ROYALTY_TRANSFER_PROGRAM = "royalty transfer program"
+    CR = "credential restricted"
+
+
+def match_puzzle(puzzle: UncurriedPuzzle) -> Optional[PuzzleInfo]:
+    for driver in driver_lookup.values():
+        potential_info: Optional[PuzzleInfo] = driver.match(puzzle)
+        if potential_info is not None:
+            return potential_info
+    return None
+
+
+def construct_puzzle(constructor: PuzzleInfo, inner_puzzle: Program) -> Program:
+    return driver_lookup[AssetType(constructor.type())].construct(constructor, inner_puzzle)
+
+
+def solve_puzzle(constructor: PuzzleInfo, solver: Solver, inner_puzzle: Program, inner_solution: Program) -> Program:
+    return driver_lookup[AssetType(constructor.type())].solve(constructor, solver, inner_puzzle, inner_solution)
+
+
+def get_inner_puzzle(constructor: PuzzleInfo, puzzle_reveal: UncurriedPuzzle) -> Optional[Program]:
+    return driver_lookup[AssetType(constructor.type())].get_inner_puzzle(constructor, puzzle_reveal)
+
+
+def get_inner_solution(constructor: PuzzleInfo, solution: Program) -> Optional[Program]:
+    return driver_lookup[AssetType(constructor.type())].get_inner_solution(constructor, solution)
+
+
+def create_asset_id(constructor: PuzzleInfo) -> Optional[bytes32]:
+    return driver_lookup[AssetType(constructor.type())].asset_id(constructor)
+
+
+function_args = (match_puzzle, construct_puzzle, solve_puzzle, get_inner_puzzle, get_inner_solution)
+
+driver_lookup: dict[AssetType, DriverProtocol] = {
+    AssetType.CAT: CATOuterPuzzle(*function_args),
+    AssetType.SINGLETON: SingletonOuterPuzzle(*function_args),
+    AssetType.METADATA: MetadataOuterPuzzle(*function_args),
+    AssetType.OWNERSHIP: OwnershipOuterPuzzle(*function_args),
+    AssetType.ROYALTY_TRANSFER_PROGRAM: TransferProgramPuzzle(*function_args),
+    AssetType.CR: CROuterPuzzle(*function_args),
+}

chia/wallet/payment.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from chia.types.blockchain_format.program import Program
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.util.ints import uint64
+
+
+# This class is supposed to correspond to a CREATE_COIN condition
+@dataclass(frozen=True)
+class Payment:
+    puzzle_hash: bytes32
+    amount: uint64
+    memos: list[bytes] = field(default_factory=list)
+
+    def as_condition_args(self) -> list:
+        return [self.puzzle_hash, self.amount, self.memos]
+
+    def as_condition(self) -> Program:
+        return Program.to([51, *self.as_condition_args()])
+
+    def name(self) -> bytes32:
+        return self.as_condition().get_tree_hash()
+
+    @classmethod
+    def from_condition(cls, condition: Program) -> Payment:
+        python_condition: list = condition.as_python()
+        puzzle_hash, amount = python_condition[1:3]
+        memos: list[bytes] = []
+        if len(python_condition) > 3:
+            memos = python_condition[3]
+        return cls(bytes32(puzzle_hash), uint64(int.from_bytes(amount, "big")), memos)