chia-blockchain 2.5.1rc1__py3-none-any.whl

chia/wallet/util/compute_memos.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from clvm.casts import int_from_bytes
+
+from chia.types.blockchain_format.coin import Coin
+from chia.types.blockchain_format.program import INFINITE_COST
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.coin_spend import CoinSpend
+from chia.types.condition_opcodes import ConditionOpcode
+from chia.util.ints import uint64
+from chia.wallet.wallet_spend_bundle import WalletSpendBundle
+
+
+def compute_memos_for_spend(coin_spend: CoinSpend) -> dict[bytes32, list[bytes]]:
+    _, result = coin_spend.puzzle_reveal.run_with_cost(INFINITE_COST, coin_spend.solution)
+    memos: dict[bytes32, list[bytes]] = {}
+    for condition in result.as_python():
+        if condition[0] == ConditionOpcode.CREATE_COIN and len(condition) >= 4:
+            # If only 3 elements (opcode + 2 args), there is no memo, this is ph, amount
+            coin_added = Coin(coin_spend.coin.name(), bytes32(condition[1]), uint64(int_from_bytes(condition[2])))
+            if type(condition[3]) is not list:
+                # If it's not a list, it's not the correct format
+                continue
+            memos[coin_added.name()] = condition[3]
+    return memos
+
+
+def compute_memos(bundle: WalletSpendBundle) -> dict[bytes32, list[bytes]]:
+    """
+    Retrieves the memos for additions in this spend_bundle, which are formatted as a list in the 3rd parameter of
+    CREATE_COIN. If there are no memos, the addition coin_id is not included. If they are not formatted as a list
+    of bytes, they are not included. This is expensive to call, it should not be used in full node code.
+    """
+    memos: dict[bytes32, list[bytes]] = {}
+    for coin_spend in bundle.coin_spends:
+        spend_memos = compute_memos_for_spend(coin_spend)
+        for coin_name, coin_memos in spend_memos.items():
+            existing_memos = memos.get(coin_name)
+            if existing_memos is None:
+                memos[coin_name] = coin_memos
+            else:
+                memos[coin_name] = existing_memos + coin_memos
+    return memos

chia/wallet/util/curry_and_treehash.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+from hashlib import sha256
+from typing import Callable
+
+from clvm.casts import int_to_bytes
+
+from chia.types.blockchain_format.sized_bytes import bytes32
+
+CurryHashFunction = Callable[..., bytes32]
+
+
+NULL = bytes.fromhex("")
+ONE = bytes.fromhex("01")
+TWO = bytes.fromhex("02")
+Q_KW = bytes.fromhex("01")
+A_KW = bytes.fromhex("02")
+C_KW = bytes.fromhex("04")
+
+
+def shatree_atom(atom: bytes) -> bytes32:
+    s = sha256()
+    s.update(ONE)
+    s.update(atom)
+    return bytes32(s.digest())
+
+
+def shatree_pair(left_hash: bytes32, right_hash: bytes32) -> bytes32:
+    s = sha256()
+    s.update(TWO)
+    s.update(left_hash)
+    s.update(right_hash)
+    return bytes32(s.digest())
+
+
+Q_KW_TREEHASH = shatree_atom(Q_KW)
+A_KW_TREEHASH = shatree_atom(A_KW)
+C_KW_TREEHASH = shatree_atom(C_KW)
+ONE_TREEHASH = shatree_atom(ONE)
+NIL_TREEHASH = shatree_atom(NULL)
+
+
+def shatree_atom_list(li: Sequence[bytes]) -> bytes32:
+    ret = NIL_TREEHASH
+    for item in reversed(li):
+        ret = shatree_pair(shatree_atom(item), ret)
+    return ret
+
+
+def shatree_int(val: int) -> bytes32:
+    return shatree_atom(int_to_bytes(val))
+
+
+# The environment `E = (F . R)` recursively expands out to
+# `(c . ((q . F) . EXPANSION(R)))` if R is not 0
+# `1` if R is 0
+
+
+def curried_values_tree_hash(arguments: list[bytes32]) -> bytes32:
+    if len(arguments) == 0:
+        return ONE_TREEHASH
+
+    return shatree_pair(
+        C_KW_TREEHASH,
+        shatree_pair(
+            shatree_pair(Q_KW_TREEHASH, arguments[0]),
+            shatree_pair(curried_values_tree_hash(arguments[1:]), NIL_TREEHASH),
+        ),
+    )
+
+
+# The curry pattern is `(a . ((q . F)  . (E . 0)))` == `(a (q . F) E)
+# where `F` is the `mod` and `E` is the curried environment
+
+
+def curry_and_treehash(hash_of_quoted_mod_hash: bytes32, *hashed_arguments: bytes32) -> bytes32:
+    """
+    `hash_of_quoted_mod_hash` : tree hash of `(q . MOD)` where `MOD` is template to be curried
+    `arguments` : tree hashes of arguments to be curried
+    """
+
+    curried_values = curried_values_tree_hash(list(hashed_arguments))
+    return shatree_pair(
+        A_KW_TREEHASH,
+        shatree_pair(hash_of_quoted_mod_hash, shatree_pair(curried_values, NIL_TREEHASH)),
+    )
+
+
+def calculate_hash_of_quoted_mod_hash(mod_hash: bytes32) -> bytes32:
+    return shatree_pair(Q_KW_TREEHASH, mod_hash)

chia/wallet/util/debug_spend_bundle.py

@@ -0,0 +1,232 @@
+from __future__ import annotations
+
+from chia_rs import AugSchemeMPL
+from clvm.operators import KEYWORD_FROM_ATOM
+from clvm_tools.binutils import disassemble as bu_disassemble
+
+from chia.consensus.default_constants import DEFAULT_CONSTANTS
+from chia.types.blockchain_format.coin import Coin
+from chia.types.blockchain_format.program import INFINITE_COST, Program
+from chia.types.condition_opcodes import ConditionOpcode
+from chia.util.condition_tools import conditions_dict_for_solution, pkm_pairs_for_conditions_dict
+from chia.util.hash import std_hash
+from chia.wallet.uncurried_puzzle import UncurriedPuzzle
+
+CONDITIONS = {opcode.name: opcode.value[0] for opcode in ConditionOpcode}
+KFA = {v: k for k, v in CONDITIONS.items()}
+
+
+# information needed to spend a cc
+# if we ever support more genesis conditions, like a re-issuable coin,
+# we may need also to save the `genesis_coin_mod` or its hash
+
+
+def disassemble(sexp: Program):
+    """
+    This version of `disassemble` also disassembles condition opcodes like `ASSERT_ANNOUNCEMENT_CONSUMED`.
+    """
+    kfa = dict(KEYWORD_FROM_ATOM)
+    kfa.update((Program.to(k).as_atom(), v) for k, v in KFA.items())
+    return bu_disassemble(sexp, kfa)
+
+
+def coin_as_program(coin: Coin) -> Program:
+    """
+    Convenience function for when putting `coin_info` into a solution.
+    """
+    return Program.to([coin.parent_coin_info, coin.puzzle_hash, coin.amount])
+
+
+def dump_coin(coin: Coin) -> str:
+    return disassemble(coin_as_program(coin))
+
+
+def recursive_uncurry_dump(puzzle: Program, layer: int, prefix: str, uncurried_already: UncurriedPuzzle) -> None:
+    mod = uncurried_already.mod
+    curried_args = uncurried_already.args
+    if mod != puzzle:
+        print(f"{prefix}- Layer {layer}:")
+        print(f"{prefix}  - Mod hash: {mod.get_tree_hash().hex()}")
+        for arg in curried_args.as_iter():
+            uncurry_dump(arg, prefix=f"{prefix}  ")
+        mod2, curried_args2 = mod.uncurry()
+        if mod2 != mod:
+            recursive_uncurry_dump(mod, layer + 1, prefix, UncurriedPuzzle(mod2, curried_args2))
+    else:
+        print(f"{prefix}- {bu_disassemble(puzzle)}")
+
+
+def uncurry_dump(puzzle: Program, prefix: str = "") -> None:
+    mod, curried_args = puzzle.uncurry()
+    if mod != puzzle:
+        print(f"{prefix}- <curried puzzle>")
+        prefix = f"{prefix}  "
+
+    recursive_uncurry_dump(puzzle, 1, prefix, UncurriedPuzzle(mod, curried_args))
+
+
+def debug_spend_bundle(spend_bundle, agg_sig_additional_data=DEFAULT_CONSTANTS.AGG_SIG_ME_ADDITIONAL_DATA) -> None:
+    """
+    Print a lot of useful information about a `SpendBundle` that might help with debugging
+    its clvm.
+    """
+
+    pks = []
+    msgs = []
+
+    created_coin_announcements: list[list[bytes]] = []
+    asserted_coin_announcements = []
+    created_puzzle_announcements: list[list[bytes]] = []
+    asserted_puzzle_announcements = []
+
+    print("=" * 80)
+    for coin_spend in spend_bundle.coin_spends:
+        coin = coin_spend.coin
+        puzzle_reveal = Program.from_bytes(bytes(coin_spend.puzzle_reveal))
+        solution = Program.from_bytes(bytes(coin_spend.solution))
+        coin_name = coin.name()
+
+        print(f"consuming coin {dump_coin(coin)}")
+        print(f"  with id {coin_name.hex()}")
+        print()
+        print(f"\nbrun -y main.sym '{bu_disassemble(puzzle_reveal)}' '{bu_disassemble(solution)}'")
+
+        print()
+        print("--- Uncurried Args ---")
+        uncurry_dump(puzzle_reveal)
+
+        if puzzle_reveal.get_tree_hash() != coin_spend.coin.puzzle_hash:
+            print()
+            print("*** BAD PUZZLE REVEAL")
+            print(f"{puzzle_reveal.get_tree_hash().hex()} vs {coin_spend.coin.puzzle_hash.hex()}")
+            print("*" * 80)
+            print()
+            continue
+
+        conditions = conditions_dict_for_solution(puzzle_reveal, solution, INFINITE_COST)
+        for pk, m in pkm_pairs_for_conditions_dict(conditions, coin, agg_sig_additional_data):
+            pks.append(pk)
+            msgs.append(m)
+        print()
+        _cost, r = puzzle_reveal.run_with_cost(INFINITE_COST, solution)
+        print(disassemble(r))
+        create_coin_conditions = [con for con in r.as_iter() if con.first().as_int() == 51]
+        print()
+        if conditions and len(conditions) > 0:
+            print("grouped conditions:")
+            for condition_programs in conditions.values():
+                print()
+                for c in condition_programs:
+                    if len(c.vars) == 0:
+                        as_prog = Program.to([c.opcode])
+                    elif len(c.vars) == 1:
+                        as_prog = Program.to([c.opcode, c.vars[0]])
+                    elif len(c.vars) == 2:
+                        if c.opcode == ConditionOpcode.CREATE_COIN:
+                            cc = next(
+                                cc
+                                for cc in create_coin_conditions
+                                if cc.at("rf").atom == c.vars[0] and cc.at("rrf").atom == c.vars[1]
+                            )
+                            if cc.at("rrr").atom is None:
+                                as_prog = Program.to([c.opcode, c.vars[0], c.vars[1], cc.at("rrrf")])
+                            else:
+                                as_prog = Program.to([c.opcode, c.vars[0], c.vars[1]])
+                        else:
+                            as_prog = Program.to([c.opcode, c.vars[0], c.vars[1]])
+                    else:
+                        raise Exception(f"Unexpected number of vars: {len(c.vars)}")
+
+                    print(f"  {disassemble(as_prog)}")
+            created_coin_announcements.extend(
+                [coin_name, *_.vars] for _ in conditions.get(ConditionOpcode.CREATE_COIN_ANNOUNCEMENT, [])
+            )
+            asserted_coin_announcements.extend(
+                [_.vars[0].hex() for _ in conditions.get(ConditionOpcode.ASSERT_COIN_ANNOUNCEMENT, [])]
+            )
+            created_puzzle_announcements.extend(
+                [puzzle_reveal.get_tree_hash(), *_.vars]
+                for _ in conditions.get(ConditionOpcode.CREATE_PUZZLE_ANNOUNCEMENT, [])
+            )
+            asserted_puzzle_announcements.extend(
+                [_.vars[0].hex() for _ in conditions.get(ConditionOpcode.ASSERT_PUZZLE_ANNOUNCEMENT, [])]
+            )
+            print()
+        else:
+            print("(no output conditions generated)")
+        print()
+        print("-------")
+
+    created = set(spend_bundle.additions())
+    spent = set(spend_bundle.removals())
+
+    zero_coin_set = {coin.name() for coin in created if coin.amount == 0}
+
+    ephemeral = created.intersection(spent)
+    created.difference_update(ephemeral)
+    spent.difference_update(ephemeral)
+    print()
+    print("spent coins")
+    for coin in sorted(spent, key=lambda _: _.name()):
+        print(f"  {dump_coin(coin)}")
+        print(f"      => spent coin id {coin.name().hex()}")
+    print()
+    print("created coins")
+    for coin in sorted(created, key=lambda _: _.name()):
+        print(f"  {dump_coin(coin)}")
+        print(f"      => created coin id {coin.name().hex()}")
+
+    if ephemeral:
+        print()
+        print("ephemeral coins")
+        for coin in sorted(ephemeral, key=lambda _: _.name()):
+            print(f"  {dump_coin(coin)}")
+            print(f"      => created coin id {coin.name().hex()}")
+
+    created_coin_announcement_pairs = [(_, std_hash(b"".join(_)).hex()) for _ in created_coin_announcements]
+    if created_coin_announcement_pairs:
+        print("created coin announcements")
+        for announcement, hashed in sorted(created_coin_announcement_pairs, key=lambda _: _[-1]):
+            as_hex = [f"0x{_.hex()}" for _ in announcement]
+            print(f"  {as_hex} =>\n      {hashed}")
+
+    eor_coin_announcements = sorted({_[-1] for _ in created_coin_announcement_pairs} ^ set(asserted_coin_announcements))
+
+    created_puzzle_announcement_pairs = [(_, std_hash(b"".join(_)).hex()) for _ in created_puzzle_announcements]
+    if created_puzzle_announcements:
+        print("created puzzle announcements")
+        for announcement, hashed in sorted(created_puzzle_announcement_pairs, key=lambda _: _[-1]):
+            as_hex = [f"0x{_.hex()}" for _ in announcement]
+            print(f"  {as_hex} =>\n      {hashed}")
+
+    eor_puzzle_announcements = sorted(
+        {_[-1] for _ in created_puzzle_announcement_pairs} ^ set(asserted_puzzle_announcements)
+    )
+
+    print()
+    print()
+    print(f"zero_coin_set = {sorted(zero_coin_set)}")
+    print()
+    if created_coin_announcement_pairs or asserted_coin_announcements:
+        print(f"created  coin announcements = {sorted([_[-1] for _ in created_coin_announcement_pairs])}")
+        print()
+        print(f"asserted coin announcements = {sorted(asserted_coin_announcements)}")
+        print()
+        print(f"symdiff of coin announcements = {sorted(eor_coin_announcements)}")
+        print()
+    if created_puzzle_announcement_pairs or asserted_puzzle_announcements:
+        print(f"created  puzzle announcements = {sorted([_[-1] for _ in created_puzzle_announcement_pairs])}")
+        print()
+        print(f"asserted puzzle announcements = {sorted(asserted_puzzle_announcements)}")
+        print()
+        print(f"symdiff of puzzle announcements = {sorted(eor_puzzle_announcements)}")
+        print()
+    print()
+    print("=" * 80)
+    print()
+    validates = AugSchemeMPL.aggregate_verify(pks, msgs, spend_bundle.aggregated_signature)
+    print(f"aggregated signature check pass: {validates}")
+    print(f"pks: {pks}")
+    print(f"msgs: {[msg.hex() for msg in msgs]}")
+    print(f"add_data: {agg_sig_additional_data.hex()}")
+    print(f"signature: {spend_bundle.aggregated_signature}")

chia/wallet/util/merkle_tree.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+import math
+from enum import Enum
+from typing import Optional
+
+from clvm.casts import int_to_bytes
+
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.util.hash import std_hash
+
+ONE = int_to_bytes(1)
+TWO = int_to_bytes(2)
+
+
+def hash_a_pair(left: bytes32, right: bytes32) -> bytes32:
+    return std_hash(TWO + left + right)
+
+
+def hash_an_atom(atom: bytes32) -> bytes32:
+    return std_hash(ONE + atom)
+
+
+class TreeType(Enum):
+    TREE = 1
+    WATERFALL = 2
+
+
+class MerkleTree:
+    type: TreeType
+    nodes: list[bytes32]
+
+    def __init__(self, nodes: list[bytes32], waterfall: bool = False) -> None:
+        self.type = TreeType.WATERFALL if waterfall else TreeType.TREE
+        self.nodes = nodes
+
+    def split_list(self, puzzle_hashes: list[bytes32]) -> tuple[list[bytes32], list[bytes32]]:
+        if self.type == TreeType.TREE:
+            mid_index = math.ceil(len(puzzle_hashes) / 2)
+            first = puzzle_hashes[0:mid_index]
+            rest = puzzle_hashes[mid_index : len(puzzle_hashes)]
+        else:
+            first = puzzle_hashes[0:-1]
+            rest = puzzle_hashes[-1 : len(puzzle_hashes)]
+
+        return first, rest
+
+    def _root(self, puzzle_hashes: list[bytes32]) -> bytes32:
+        if len(puzzle_hashes) == 1:
+            return hash_an_atom(puzzle_hashes[0])
+        else:
+            first, rest = self.split_list(puzzle_hashes)
+            return hash_a_pair(self._root(first), self._root(rest))
+
+    def calculate_root(self) -> bytes32:
+        return self._root(self.nodes)
+
+    def _proof(
+        self, puzzle_hashes: list[bytes32], searching_for: bytes32
+    ) -> tuple[Optional[int], Optional[list[bytes32]], bytes32, Optional[int]]:
+        if len(puzzle_hashes) == 1:
+            atom_hash = hash_an_atom(puzzle_hashes[0])
+            if puzzle_hashes[0] == searching_for:
+                return (0, [], atom_hash, 0)
+            else:
+                return (None, [], atom_hash, None)
+        else:
+            first, rest = self.split_list(puzzle_hashes)
+            first_hash = self._proof(first, searching_for)
+            rest_hash = self._proof(rest, searching_for)
+
+            final_path = None
+            final_list = None
+            bit_num = None
+
+            if first_hash[0] is not None:
+                final_list = first_hash[1]
+                # TODO: handle hints
+                #       error: Item "None" of "Optional[list[bytes32]]" has no attribute "append"  [union-attr]
+                final_list.append(rest_hash[2])  # type: ignore[union-attr]
+                bit_num = first_hash[3]
+                final_path = first_hash[0]
+            elif rest_hash[0] is not None:
+                final_list = rest_hash[1]
+                # TODO: handle hints
+                #       error: Item "None" of "Optional[list[bytes32]]" has no attribute "append"  [union-attr]
+                final_list.append(first_hash[2])  # type: ignore[union-attr]
+                bit_num = rest_hash[3]
+                # TODO: handle hints
+                #       error: Unsupported operand types for << ("int" and "None")  [operator]
+                #       note: Right operand is of type "Optional[int]"
+                final_path = rest_hash[0] | (1 << bit_num)  # type: ignore[operator]
+
+            pair_hash = hash_a_pair(first_hash[2], rest_hash[2])
+
+            return (final_path, final_list, pair_hash, bit_num + 1 if bit_num is not None else None)
+
+    def generate_proof(self, leaf_reveal: bytes32) -> tuple[Optional[int], list[Optional[list[bytes32]]]]:
+        proof = self._proof(self.nodes, leaf_reveal)
+        return (proof[0], [proof[1]])

chia/wallet/util/merkle_utils.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+import hashlib
+from typing import Any
+
+from chia.types.blockchain_format.sized_bytes import bytes32
+
+TupleTree = Any  # Union[bytes32, tuple["TupleTree", "TupleTree"]]
+Proof_Tree_Type = Any  # Union[bytes32, tuple[bytes32, "Proof_Tree_Type"]]
+
+
+HASH_TREE_PREFIX = bytes([2])
+HASH_LEAF_PREFIX = bytes([1])
+
+# paths here are not quite the same a `NodePath` paths. We don't need the high order bit
+# anymore since the proof indicates how big the path is.
+
+
+def compose_paths(path_1: int, path_2: int, path_2_length: int) -> int:
+    return (path_1 << path_2_length) | path_2
+
+
+def sha256(*args: bytes) -> bytes32:
+    return bytes32(hashlib.sha256(b"".join(args)).digest())
+
+
+def build_merkle_tree_from_binary_tree(tuples: TupleTree) -> tuple[bytes32, dict[bytes32, tuple[int, list[bytes32]]]]:
+    if isinstance(tuples, bytes):
+        tuples = bytes32(tuples)
+        return sha256(HASH_LEAF_PREFIX, tuples), {tuples: (0, [])}
+
+    left, right = tuples
+    left_root, left_proofs = build_merkle_tree_from_binary_tree(left)
+    right_root, right_proofs = build_merkle_tree_from_binary_tree(right)
+
+    new_root = sha256(HASH_TREE_PREFIX, left_root, right_root)
+    new_proofs = {}
+    for name, (path, proof) in left_proofs.items():
+        proof.append(right_root)
+        new_proofs[name] = (path, proof)
+    for name, (path, proof) in right_proofs.items():
+        path |= 1 << len(proof)
+        proof.append(left_root)
+        new_proofs[name] = (path, proof)
+    return new_root, new_proofs
+
+
+def list_to_binary_tree(objects: list[Any]) -> Any:
+    size = len(objects)
+    if size == 0:
+        raise ValueError("Cannot build a tree out of 0 objects")
+    if size == 1:
+        return objects[0]
+    midpoint = (size + 1) >> 1
+    first_half = objects[:midpoint]
+    last_half = objects[midpoint:]
+    return (list_to_binary_tree(first_half), list_to_binary_tree(last_half))
+
+
+def build_merkle_tree(objects: list[bytes32]) -> tuple[bytes32, dict[bytes32, tuple[int, list[bytes32]]]]:
+    """
+    return (merkle_root, dict_of_proofs)
+    """
+    objects_binary_tree = list_to_binary_tree(objects)
+    return build_merkle_tree_from_binary_tree(objects_binary_tree)
+
+
+def merkle_proof_from_path_and_tree(node_path: int, proof_tree: Proof_Tree_Type) -> tuple[int, list[bytes32]]:
+    proof_path = 0
+    proof = []
+    while not isinstance(proof_tree, bytes32):
+        left_vs_right = node_path & 1
+        path_element = proof_tree[1][1 - left_vs_right]
+        if isinstance(path_element, bytes32):
+            proof.append(path_element)
+        else:
+            proof.append(path_element[0])
+        node_path >>= 1
+        proof_tree = proof_tree[1][left_vs_right]
+        proof_path += proof_path + left_vs_right
+    proof.reverse()
+    return proof_path, proof
+
+
+def _simplify_merkle_proof(tree_hash: bytes32, proof: tuple[int, list[bytes32]]) -> bytes32:
+    # we return the expected merkle root
+    path, nodes = proof
+    for node in nodes:
+        if path & 1:
+            tree_hash = sha256(HASH_TREE_PREFIX, node, tree_hash)
+        else:
+            tree_hash = sha256(HASH_TREE_PREFIX, tree_hash, node)
+        path >>= 1
+    return tree_hash
+
+
+def simplify_merkle_proof(tree_hash: bytes32, proof: tuple[int, list[bytes32]]) -> bytes32:
+    return _simplify_merkle_proof(sha256(HASH_LEAF_PREFIX, tree_hash), proof)
+
+
+def check_merkle_proof(merkle_root: bytes32, tree_hash: bytes32, proof: tuple[int, list[bytes32]]) -> bool:
+    return merkle_root == simplify_merkle_proof(tree_hash, proof)

chia/wallet/util/new_peak_queue.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+import asyncio
+import dataclasses
+from enum import IntEnum
+from typing import Any
+
+from chia.protocols.wallet_protocol import CoinStateUpdate, NewPeakWallet
+from chia.server.ws_connection import WSChiaConnection
+from chia.types.blockchain_format.sized_bytes import bytes32
+
+
+class NewPeakQueueTypes(IntEnum):
+    # Lower number means higher priority in the queue
+    COIN_ID_SUBSCRIPTION = 1
+    PUZZLE_HASH_SUBSCRIPTION = 2
+    FULL_NODE_STATE_UPDATED = 3
+    NEW_PEAK_WALLET = 4
+
+
+@dataclasses.dataclass
+class NewPeakItem:
+    item_type: NewPeakQueueTypes
+    data: Any
+
+    def __lt__(self, other):
+        if self.item_type != other.item_type:
+            return self.item_type < other.item_type
+        if self.item_type in {NewPeakQueueTypes.COIN_ID_SUBSCRIPTION, NewPeakQueueTypes.PUZZLE_HASH_SUBSCRIPTION}:
+            return False  # All subscriptions are equal
+        return self.data[0].height < other.data[0].height
+
+    def __le__(self, other):
+        if self.item_type != other.item_type:
+            return self.item_type < other.item_type
+        if self.item_type in {NewPeakQueueTypes.COIN_ID_SUBSCRIPTION, NewPeakQueueTypes.PUZZLE_HASH_SUBSCRIPTION}:
+            return True  # All subscriptions are equal
+        return self.data[0].height <= other.data[0].height
+
+    def __gt__(self, other):
+        if self.item_type != other.item_type:
+            return self.item_type > other.item_type
+        if self.item_type in {NewPeakQueueTypes.COIN_ID_SUBSCRIPTION, NewPeakQueueTypes.PUZZLE_HASH_SUBSCRIPTION}:
+            return False  # All subscriptions are equal
+        return self.data[0].height > other.data[0].height
+
+    def __ge__(self, other):
+        if self.item_type != other.item_type:
+            return self.item_type > other.item_type
+        if self.item_type in {NewPeakQueueTypes.COIN_ID_SUBSCRIPTION, NewPeakQueueTypes.PUZZLE_HASH_SUBSCRIPTION}:
+            return True  # All subscriptions are equal
+        return self.data[0].height >= other.data[0].height
+
+
+class NewPeakQueue:
+    def __init__(self, inner_queue: asyncio.PriorityQueue):
+        self._inner_queue: asyncio.PriorityQueue = inner_queue
+        self._pending_data_process_items: int = 0
+
+    async def subscribe_to_coin_ids(self, coin_ids: list[bytes32]):
+        self._pending_data_process_items += 1
+        await self._inner_queue.put(NewPeakItem(NewPeakQueueTypes.COIN_ID_SUBSCRIPTION, coin_ids))
+
+    async def subscribe_to_puzzle_hashes(self, puzzle_hashes: list[bytes32]):
+        self._pending_data_process_items += 1
+        await self._inner_queue.put(NewPeakItem(NewPeakQueueTypes.PUZZLE_HASH_SUBSCRIPTION, puzzle_hashes))
+
+    async def full_node_state_updated(self, coin_state_update: CoinStateUpdate, peer: WSChiaConnection):
+        self._pending_data_process_items += 1
+        await self._inner_queue.put(NewPeakItem(NewPeakQueueTypes.FULL_NODE_STATE_UPDATED, (coin_state_update, peer)))
+
+    async def new_peak_wallet(self, new_peak: NewPeakWallet, peer: WSChiaConnection):
+        await self._inner_queue.put(NewPeakItem(NewPeakQueueTypes.NEW_PEAK_WALLET, (new_peak, peer)))
+
+    async def get(self) -> NewPeakItem:
+        item: NewPeakItem = await self._inner_queue.get()
+        if item.item_type != NewPeakQueueTypes.NEW_PEAK_WALLET:
+            self._pending_data_process_items -= 1
+        return item
+
+    def has_pending_data_process_items(self) -> bool:
+        return self._pending_data_process_items > 0

chia/wallet/util/notifications.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from chia.types.blockchain_format.program import Program
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.util.ints import uint64
+from chia.wallet.puzzles.load_clvm import load_clvm_maybe_recompile
+
+NOTIFICATION_MOD = load_clvm_maybe_recompile("notification.clsp")
+
+
+def construct_notification(target: bytes32, amount: uint64) -> Program:
+    return NOTIFICATION_MOD.curry(target, amount)