chia-blockchain 2.5.1rc1__py3-none-any.whl

chia/wallet/puzzles/singleton_top_layer.clsp

@@ -0,0 +1,177 @@
+(mod (SINGLETON_STRUCT INNER_PUZZLE lineage_proof my_amount inner_solution)
+
+  ;; SINGLETON_STRUCT = (MOD_HASH . (LAUNCHER_ID . LAUNCHER_PUZZLE_HASH))
+
+  ; SINGLETON_STRUCT, INNER_PUZZLE are curried in by the wallet
+
+  ; EXAMPLE SOLUTION '(0xfadeddab 0xdeadbeef 1 (0xdeadbeef 200) 50 ((51 0xfadeddab 100) (60 "trash") (51 deadbeef 0)))'
+
+
+  ; This puzzle is a wrapper around an inner smart puzzle which guarantees uniqueness.
+  ; It takes its singleton identity from a coin with a launcher puzzle which guarantees that it is unique.
+
+  (include condition_codes.clib)
+  (include curry-and-treehash.clib)
+  (include singleton_truths.clib)
+
+  ; takes a lisp tree and returns the hash of it
+  (defun sha256tree1 (TREE)
+    (if (l TREE)
+        (sha256 2 (sha256tree1 (f TREE)) (sha256tree1 (r TREE)))
+        (sha256 1 TREE)
+    )
+  )
+
+  ; "assert" is a macro that wraps repeated instances of "if"
+  ; usage: (assert A0 A1 ... An R)
+  ; all of A0, A1, ... An must evaluate to non-null, or an exception is raised
+  ; return the value of R (if we get that far)
+
+  (defmacro assert items
+    (if (r items)
+        (list if (f items) (c assert (r items)) (q . (x)))
+        (f items)
+    )
+  )
+
+  (defun-inline mod_hash_for_singleton_struct (SINGLETON_STRUCT) (f SINGLETON_STRUCT))
+  (defun-inline launcher_id_for_singleton_struct (SINGLETON_STRUCT) (f (r SINGLETON_STRUCT)))
+  (defun-inline launcher_puzzle_hash_for_singleton_struct (SINGLETON_STRUCT) (r (r SINGLETON_STRUCT)))
+
+  ;; return the full puzzlehash for a singleton with the innerpuzzle curried in
+  ; puzzle-hash-of-curried-function is imported from curry-and-treehash.clib
+  (defun-inline calculate_full_puzzle_hash (SINGLETON_STRUCT inner_puzzle_hash)
+    (puzzle-hash-of-curried-function (mod_hash_for_singleton_struct SINGLETON_STRUCT)
+      inner_puzzle_hash
+      (sha256tree1 SINGLETON_STRUCT)
+    )
+  )
+
+  ; assembles information from the solution to create our own full ID including asserting our parent is a singleton
+  (defun create_my_ID (SINGLETON_STRUCT full_puzzle_hash parent_parent parent_inner_puzzle_hash parent_amount my_amount)
+    (sha256 (sha256 parent_parent (calculate_full_puzzle_hash SINGLETON_STRUCT parent_inner_puzzle_hash) parent_amount)
+      full_puzzle_hash
+    my_amount)
+  )
+
+  ;; take a boolean and a non-empty list of conditions
+  ;; strip off the first condition if a boolean is set
+  ;; this is used to remove `(CREATE_COIN xxx -113)`
+  ;; pretty sneaky, eh?
+  (defun strip_first_condition_if (boolean condition_list)
+    (if boolean
+        (r condition_list)
+        condition_list
+    )
+  )
+
+  (defun-inline morph_condition (condition SINGLETON_STRUCT)
+    (list (f condition) (calculate_full_puzzle_hash SINGLETON_STRUCT (f (r condition))) (f (r (r condition))))
+  )
+
+  ;; return the value of the coin created if this is a `CREATE_COIN` condition, or 0 otherwise
+  (defun-inline created_coin_value_or_0 (condition)
+    (if (= (f condition) CREATE_COIN)
+        (f (r (r condition)))
+        0
+    )
+  )
+
+  ;; Returns a (bool . bool)
+  (defun odd_cons_m113 (output_amount)
+    (c
+      (= (logand output_amount 1) 1)  ;; is it odd?
+      (= output_amount -113)  ;; is it the escape value?
+    )
+  )
+
+  ; Assert exactly one output with odd value exists - ignore it if value is -113
+
+  ;; this function iterates over the output conditions from the inner puzzle & solution
+  ;; and both checks that exactly one unique singleton child is created (with odd valued output),
+  ;; and wraps the inner puzzle with this same singleton wrapper puzzle
+  ;;
+  ;; The special case where the output value is -113 means a child singleton is intentionally
+  ;; *NOT* being created, thus forever ending this singleton's existence
+
+  (defun check_and_morph_conditions_for_singleton (SINGLETON_STRUCT conditions has_odd_output_been_found)
+    (if conditions
+        (morph_next_condition SINGLETON_STRUCT conditions has_odd_output_been_found (odd_cons_m113 (created_coin_value_or_0 (f conditions))))
+        (if has_odd_output_been_found
+            0
+            (x)  ;; no odd output found
+        )
+    )
+  )
+
+  ;; a continuation of `check_and_morph_conditions_for_singleton` with booleans `is_output_odd` and `is_output_m113`
+  ;; precalculated
+  (defun morph_next_condition (SINGLETON_STRUCT conditions has_odd_output_been_found (is_output_odd . is_output_m113))
+    (assert
+      (not (all is_output_odd has_odd_output_been_found))
+      (strip_first_condition_if
+        is_output_m113
+        (c (if is_output_odd
+               (morph_condition (f conditions) SINGLETON_STRUCT)
+               (f conditions)
+          )
+          (check_and_morph_conditions_for_singleton SINGLETON_STRUCT (r conditions) (any is_output_odd has_odd_output_been_found))
+        )
+      )
+    )
+  )
+
+  ; this final stager asserts our ID
+  ; it also runs the innerpuz with the innersolution with the "truths" added
+  ; it then passes that output conditions from the innerpuz to the morph conditions function
+  (defun stager_three (SINGLETON_STRUCT lineage_proof my_id full_puzhash innerpuzhash my_amount INNER_PUZZLE inner_solution)
+    (c (list ASSERT_MY_COIN_ID my_id) (check_and_morph_conditions_for_singleton SINGLETON_STRUCT (a INNER_PUZZLE (c (truth_data_to_truth_struct my_id full_puzhash innerpuzhash my_amount lineage_proof SINGLETON_STRUCT) inner_solution)) 0))
+  )
+
+  ; this checks whether we are an eve spend or not and calculates our full coin ID appropriately and passes it on to the final stager
+  ; if we are the eve spend it also adds the additional checks that our parent's puzzle is the standard launcher format and that out parent ID is the same as our singleton ID
+
+  (defun stager_two (SINGLETON_STRUCT lineage_proof full_puzhash innerpuzhash my_amount INNER_PUZZLE inner_solution)
+    (stager_three
+      SINGLETON_STRUCT
+      lineage_proof
+      (if (is_not_eve_proof lineage_proof)
+          (create_my_ID
+            SINGLETON_STRUCT
+            full_puzhash
+            (parent_info_for_lineage_proof lineage_proof)
+            (puzzle_hash_for_lineage_proof lineage_proof)
+            (amount_for_lineage_proof lineage_proof)
+            my_amount
+          )
+          (if (=
+                (launcher_id_for_singleton_struct SINGLETON_STRUCT)
+                (sha256 (parent_info_for_eve_proof lineage_proof) (launcher_puzzle_hash_for_singleton_struct SINGLETON_STRUCT) (amount_for_eve_proof lineage_proof))
+              )
+              (sha256 (launcher_id_for_singleton_struct SINGLETON_STRUCT) full_puzhash my_amount)
+              (x)
+          )
+      )
+      full_puzhash
+      innerpuzhash
+      my_amount
+      INNER_PUZZLE
+      inner_solution
+    )
+  )
+
+  ; this calculates our current full puzzle hash and passes it to stager two
+  (defun stager_one (SINGLETON_STRUCT lineage_proof my_innerpuzhash my_amount INNER_PUZZLE inner_solution)
+    (stager_two SINGLETON_STRUCT lineage_proof (calculate_full_puzzle_hash SINGLETON_STRUCT my_innerpuzhash) my_innerpuzhash my_amount INNER_PUZZLE inner_solution)
+  )
+
+
+  ; main
+
+  ; if our value is not an odd amount then we are invalid
+  ; this calculates my_innerpuzhash and passes all values to stager_one
+  (if (logand my_amount 1)
+      (stager_one SINGLETON_STRUCT lineage_proof (sha256tree1 INNER_PUZZLE) my_amount INNER_PUZZLE inner_solution)
+      (x)
+  )
+)

chia/wallet/puzzles/singleton_top_layer.clsp.hex

@@ -0,0 +1 @@
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

chia/wallet/puzzles/singleton_top_layer.py

@@ -0,0 +1,296 @@
+from __future__ import annotations
+
+from collections.abc import Iterator
+from typing import Optional
+
+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.types.condition_opcodes import ConditionOpcode
+from chia.util.hash import std_hash
+from chia.util.ints import uint64
+from chia.wallet.lineage_proof import LineageProof
+from chia.wallet.puzzles.load_clvm import load_clvm_maybe_recompile
+
+SINGLETON_MOD = load_clvm_maybe_recompile("singleton_top_layer.clsp")
+SINGLETON_MOD_HASH = SINGLETON_MOD.get_tree_hash()
+P2_SINGLETON_MOD = load_clvm_maybe_recompile("p2_singleton.clsp")
+P2_SINGLETON_OR_DELAYED_MOD = load_clvm_maybe_recompile("p2_singleton_or_delayed_puzhash.clsp")
+SINGLETON_LAUNCHER = load_clvm_maybe_recompile("singleton_launcher.clsp")
+SINGLETON_LAUNCHER_HASH = SINGLETON_LAUNCHER.get_tree_hash()
+ESCAPE_VALUE = -113
+MELT_CONDITION = [ConditionOpcode.CREATE_COIN, 0, ESCAPE_VALUE]
+
+
+#
+# An explanation of how this functions from a user's perspective
+#
+# Consider that you have some coin A that you want to create a singleton
+# containing some inner puzzle I from with amount T.  We'll call the Launcher
+# coin, which is created from A "Launcher" and the first iteration of the
+# singleton, called the "Eve" spend, Eve.  When spent, I yields a coin
+# running I' and so on in a singleton specific way described below.
+#
+# The structure of this on the blockchain when done looks like this
+#
+#   ,------------.
+#   | Coin A     |
+#   `------------'
+#         |
+#  ------------------ Atomic Transaction 1 -----------------
+#         v
+#   .------------.       .-------------------------------.
+#   | Launcher   |------>| Eve Coin Containing Program I |
+#   `------------'       `-------------------------------'
+#                                        |
+#  -------------------- End Transaction 1 ------------------\
+#                                        |                   > The Eve coin
+#  --------------- (2) Transaction With I ------------------/  may also be
+#                                        |                     spent
+#                                        v                     simultaneously
+#                 .-----------------------------------.
+#                 | Running Singleton With Program I' |
+#                 `-----------------------------------'
+#                                        |
+# --------------------- End Transaction 2 ------------------
+#                                        |
+# --------------- (3) Transaction With I' ------------------
+# ...
+#
+#
+# == Practical use of singleton_top_layer.py ==
+#
+# 1) Designate some coin as coin A
+#
+# 2) call puzzle_for_singleton with that coin's name (it is the Parent of the
+#    Launch coin), and the initial inner puzzle I, curried as appropriate for
+#    its own purpose. Adaptations of the program I and its descendants are
+#    required as below.
+#
+# 3) call launch_conditions_and_coinsol to get a set of "launch_conditions",
+#    which will be used to spend standard coin A, and a "spend", which spends
+#    the Launcher created by the application of "launch_conditions" to A in a
+#    spend. These actions must be done in the same spend bundle.
+#
+#    One can create a SpendBundle containing the spend of A giving it the
+#    argument list (() (q . launch_conditions) ()) and then append "spend" onto
+#    its .coin_spends to create a combined spend bundle.
+#
+# 4) submit the combine spend bundle.
+#
+# 5) Remember the identity of the Launcher coin:
+#
+#      Coin(A.name(), SINGLETON_LAUNCHER_HASH, amount)
+#
+# A singleton has been created like this:
+#
+#      Coin(Launcher.name(), puzzle_for_singleton(Launcher.name(), I), amount)
+#
+#
+# == To spend the singleton requires some host side setup ==
+#
+# The singleton adds an ASSERT_MY_COIN_ID to constrain it to the coin that
+# matches its own conception of itself.  It consumes a "LineageProof" object
+# when spent that must be constructed so.  We'll call the singleton we intend
+# to spend "S".
+#
+# Specifically, the required puzzle is the Inner puzzle I for the parent of S
+# unless S is the Eve coin, in which case it is None.
+# So to spend S', the second singleton, I is used, and to spend S'', I' is used.
+# We'll call this puzzle hash (or None) PH.
+#
+#      If this is the Eve singleton:
+#
+#          PH = None
+#          L = LineageProof(Launcher, PH, amount)
+#
+#       - Note: the Eve singleton's .parent_coin_info should match Launcher here.
+#
+#      Otherwise
+#
+#          PH = ParentOf(S).inner_puzzle_hash
+#          L = LineageProof(ParentOf(S).name(), PH, amount)
+#
+#       - Note: ParentOf(S).name is the .parent_coin_info member of the
+#         coin record for S.
+#
+# Now the coin S can be spent.
+# The puzzle to use in the spend is given by
+#
+#      puzzle_for_singleton(S.name(), I'.puzzle_hash())
+#
+# and the arguments are given by (with the argument list to I designated AI)
+#
+#      solution_for_singleton(L, amount, AI)
+#
+# Note that AI contains dynamic arguments to puzzle I _after_ the singleton
+# truths.
+#
+#
+# Adapting puzzles to the singleton
+#
+# 1) For the puzzle to create a coin from inside the singleton it will need the
+#    following values to be added to its curried in arguments:
+#
+#     - A way to compute its own puzzle has for each of I' and so on. This can
+#       be accomplished by giving it its uncurried puzzle hash and using
+#       puzzle-hash-of-curried-function to compute it.  Although full_puzzle_hash
+#       is used for some arguments, the inputs to all singleton_top_layer
+#       functions is the inner puzzle.
+#
+#     - the name() of the Launcher coin (which you can compute from a Coin
+#       object) if you're not already using it in I puzzle for some other
+#       reason.
+#
+# 2) A non-curried argument called "singleton_truths" will be passed to your
+#    program.  It is not required to use anything inside.
+#
+#    There is little value in not receiving this argument via the adaptations
+#    below as a standard puzzle can't be used anyway. To work the result must
+#    be itself a singleton, and the singleton does not change the puzzle hash
+#    in an outgoing CREATE_COIN to cause it to be one.
+#
+#    With this modification of the program I done, I and descendants will
+#    continue to produce I', I'' etc.
+#
+#    The actual CREATE_COIN puzzle hash will be the result of
+#    this.  The Launcher ID referred to here is the name() of
+#    the Launcher coin as above.
+#
+
+
+def match_singleton_puzzle(puzzle: Program) -> tuple[bool, Iterator[Program]]:
+    mod, curried_args = puzzle.uncurry()
+    if mod == SINGLETON_MOD:
+        return True, curried_args.as_iter()
+    else:
+        return False, iter(())
+
+
+# Given the parent and amount of the launcher coin, return the launcher coin
+def generate_launcher_coin(coin: Coin, amount: uint64) -> Coin:
+    return Coin(coin.name(), SINGLETON_LAUNCHER_HASH, amount)
+
+
+# Wrap inner puzzles that are not singleton specific to strip away "truths"
+def adapt_inner_to_singleton(inner_puzzle: Program) -> Program:
+    # (a (q . inner_puzzle) (r 1))
+    return Program.to([2, (1, inner_puzzle), [6, 1]])
+
+
+def adapt_inner_puzzle_hash_to_singleton(inner_puzzle_hash: bytes32) -> bytes32:
+    puzzle = adapt_inner_to_singleton(Program.to(inner_puzzle_hash))
+    return puzzle.get_tree_hash_precalc(inner_puzzle_hash)
+
+
+# Take standard coin and amount -> launch conditions & launcher coin solution
+def launch_conditions_and_coinsol(
+    coin: Coin, inner_puzzle: Program, comment: list[tuple[str, str]], amount: uint64
+) -> tuple[list[Program], CoinSpend]:
+    if (amount % 2) == 0:
+        raise ValueError("Coin amount cannot be even. Subtract one mojo.")
+
+    launcher_coin = generate_launcher_coin(coin, amount)
+    curried_singleton = SINGLETON_MOD.curry(
+        (SINGLETON_MOD_HASH, (launcher_coin.name(), SINGLETON_LAUNCHER_HASH)), inner_puzzle
+    )
+
+    launcher_solution = Program.to([curried_singleton.get_tree_hash(), amount, comment])
+    create_launcher = Program.to([ConditionOpcode.CREATE_COIN, SINGLETON_LAUNCHER_HASH, amount])
+    assert_launcher_announcement = Program.to(
+        [ConditionOpcode.ASSERT_COIN_ANNOUNCEMENT, std_hash(launcher_coin.name() + launcher_solution.get_tree_hash())]
+    )
+
+    conditions = [create_launcher, assert_launcher_announcement]
+
+    launcher_coin_spend = make_spend(launcher_coin, SINGLETON_LAUNCHER, launcher_solution)
+
+    return conditions, launcher_coin_spend
+
+
+# Take a coin solution, return a lineage proof for their child to use in spends
+def lineage_proof_for_coinsol(coin_spend: CoinSpend) -> LineageProof:
+    parent_name = coin_spend.coin.parent_coin_info
+
+    inner_puzzle_hash = None
+    if coin_spend.coin.puzzle_hash != SINGLETON_LAUNCHER_HASH:
+        full_puzzle = Program.from_bytes(bytes(coin_spend.puzzle_reveal))
+        r = full_puzzle.uncurry()
+        if r is not None:
+            _, args = r
+            _, inner_puzzle = list(args.as_iter())
+            inner_puzzle_hash = inner_puzzle.get_tree_hash()
+
+    amount = uint64(coin_spend.coin.amount)
+
+    return LineageProof(parent_name, inner_puzzle_hash, amount)
+
+
+# Return the puzzle reveal of a singleton with specific ID and innerpuz
+def puzzle_for_singleton(
+    launcher_id: bytes32, inner_puz: Program, launcher_hash: bytes32 = SINGLETON_LAUNCHER_HASH
+) -> Program:
+    return SINGLETON_MOD.curry((SINGLETON_MOD_HASH, (launcher_id, launcher_hash)), inner_puz)
+
+
+# Return a solution to spend a singleton
+def solution_for_singleton(lineage_proof: LineageProof, amount: uint64, inner_solution: Program) -> Program:
+    if lineage_proof.inner_puzzle_hash is None:
+        parent_info = [lineage_proof.parent_name, lineage_proof.amount]
+    else:
+        parent_info = [lineage_proof.parent_name, lineage_proof.inner_puzzle_hash, lineage_proof.amount]
+    return Program.to([parent_info, amount, inner_solution])
+
+
+# Create a coin that a singleton can claim
+def pay_to_singleton_puzzle(launcher_id: bytes32) -> Program:
+    return P2_SINGLETON_MOD.curry(SINGLETON_MOD_HASH, launcher_id, SINGLETON_LAUNCHER_HASH)
+
+
+# Create a coin that a singleton can claim or that can be sent to another puzzle after a specified time
+def pay_to_singleton_or_delay_puzzle(launcher_id: bytes32, delay_time: uint64, delay_ph: bytes32) -> Program:
+    return P2_SINGLETON_OR_DELAYED_MOD.curry(
+        SINGLETON_MOD_HASH, launcher_id, SINGLETON_LAUNCHER_HASH, delay_time, delay_ph
+    )
+
+
+# Solution for EITHER p2_singleton or the claiming spend case for p2_singleton_or_delayed_puzhash
+def solution_for_p2_singleton(p2_singleton_coin: Coin, singleton_inner_puzhash: bytes32) -> Program:
+    return Program.to([singleton_inner_puzhash, p2_singleton_coin.name()])
+
+
+# Solution for the delayed spend case for p2_singleton_or_delayed_puzhash
+def solution_for_p2_delayed_puzzle(output_amount: uint64) -> Program:
+    return Program.to([output_amount, []])
+
+
+# Get announcement conditions for singleton solution and full CoinSpend for the claimed coin
+def claim_p2_singleton(
+    p2_singleton_coin: Coin,
+    singleton_inner_puzhash: bytes32,
+    launcher_id: bytes32,
+    delay_time: Optional[uint64] = None,
+    delay_ph: Optional[bytes32] = None,
+) -> tuple[Program, Program, CoinSpend]:
+    assertion = Program.to([ConditionOpcode.ASSERT_COIN_ANNOUNCEMENT, std_hash(p2_singleton_coin.name() + b"$")])
+    announcement = Program.to([ConditionOpcode.CREATE_PUZZLE_ANNOUNCEMENT, p2_singleton_coin.name()])
+    if delay_time is None or delay_ph is None:
+        puzzle = pay_to_singleton_puzzle(launcher_id)
+    else:
+        puzzle = pay_to_singleton_or_delay_puzzle(launcher_id, delay_time, delay_ph)
+    claim_coinsol = make_spend(
+        p2_singleton_coin, puzzle, solution_for_p2_singleton(p2_singleton_coin, singleton_inner_puzhash)
+    )
+    return assertion, announcement, claim_coinsol
+
+
+# Get the CoinSpend for spending to a delayed puzzle
+def spend_to_delayed_puzzle(
+    p2_singleton_coin: Coin, output_amount: uint64, launcher_id: bytes32, delay_time: uint64, delay_ph: bytes32
+) -> CoinSpend:
+    return make_spend(
+        p2_singleton_coin,
+        pay_to_singleton_or_delay_puzzle(launcher_id, delay_time, delay_ph),
+        solution_for_p2_delayed_puzzle(output_amount),
+    )

chia/wallet/puzzles/singleton_top_layer_v1_1.clsp

@@ -0,0 +1,107 @@
+(mod (SINGLETON_STRUCT INNER_PUZZLE lineage_proof my_amount inner_solution)
+
+  ;; SINGLETON_STRUCT = (MOD_HASH . (LAUNCHER_ID . LAUNCHER_PUZZLE_HASH))
+
+  ; SINGLETON_STRUCT, INNER_PUZZLE are curried in by the wallet
+
+  ; EXAMPLE SOLUTION '(0xfadeddab 0xdeadbeef 1 (0xdeadbeef 200) 50 ((51 0xfadeddab 100) (60 "trash") (51 deadbeef 0)))'
+
+
+  ; This puzzle is a wrapper around an inner smart puzzle which guarantees uniqueness.
+  ; It takes its singleton identity from a coin with a launcher puzzle which guarantees that it is unique.
+
+  (include condition_codes.clib)
+  (include curry-and-treehash.clib)  ; also imports the constant ONE == 1
+  (include singleton_truths.clib)
+  (include utility_macros.clib)
+
+  (defun-inline mod_hash_for_singleton_struct (SINGLETON_STRUCT) (f SINGLETON_STRUCT))
+  (defun-inline launcher_id_for_singleton_struct (SINGLETON_STRUCT) (f (r SINGLETON_STRUCT)))
+  (defun-inline launcher_puzzle_hash_for_singleton_struct (SINGLETON_STRUCT) (r (r SINGLETON_STRUCT)))
+
+  ;; return the full puzzlehash for a singleton with the innerpuzzle curried in
+  ; puzzle-hash-of-curried-function is imported from curry-and-treehash.clib
+  (defun-inline calculate_full_puzzle_hash (SINGLETON_STRUCT inner_puzzle_hash)
+    (puzzle-hash-of-curried-function (mod_hash_for_singleton_struct SINGLETON_STRUCT)
+      inner_puzzle_hash
+      (sha256tree SINGLETON_STRUCT)
+    )
+  )
+
+  (defun-inline morph_condition (condition SINGLETON_STRUCT)
+    (c (f condition) (c (calculate_full_puzzle_hash SINGLETON_STRUCT (f (r condition))) (r (r condition))))
+  )
+
+  (defun is_odd_create_coin (condition)
+    (and (= (f condition) CREATE_COIN) (logand (f (r (r condition))) 1))
+  )
+
+  ; Assert exactly one output with odd value exists - ignore it if value is -113
+
+  ;; this function iterates over the output conditions from the inner puzzle & solution
+  ;; and both checks that exactly one unique singleton child is created (with odd valued output),
+  ;; and wraps the inner puzzle with this same singleton wrapper puzzle
+  ;;
+  ;; The special case where the output value is -113 means a child singleton is intentionally
+  ;; *NOT* being created, thus forever ending this singleton's existence
+
+  (defun check_and_morph_conditions_for_singleton (SINGLETON_STRUCT conditions has_odd_output_been_found)
+    (if conditions
+        ; check if it's an odd create coin
+        (if (is_odd_create_coin (f conditions))
+            ; check that we haven't already found one
+            (assert (not has_odd_output_been_found)
+              ; then
+              (if (= (f (r (r (f conditions)))) -113)
+                  ; If it's the melt condition we don't bother prepending this condition
+                  (check_and_morph_conditions_for_singleton SINGLETON_STRUCT (r conditions) ONE)
+                  ; If it isn't the melt condition, we morph it and prepend it
+                  (c (morph_condition (f conditions) SINGLETON_STRUCT) (check_and_morph_conditions_for_singleton SINGLETON_STRUCT (r conditions) ONE))
+              )
+            )
+            (c (f conditions) (check_and_morph_conditions_for_singleton SINGLETON_STRUCT (r conditions) has_odd_output_been_found))
+        )
+        (assert has_odd_output_been_found ())
+    )
+  )
+
+  ; assert that either the lineage proof is for a parent singleton, or, if it's for the launcher, verify it matched our launcher ID
+  ; then return a condition asserting it actually is our parent ID
+  (defun verify_lineage_proof (SINGLETON_STRUCT parent_id is_not_launcher)
+    (assert (any is_not_launcher (= parent_id (launcher_id_for_singleton_struct SINGLETON_STRUCT)))
+      ; then
+      (list ASSERT_MY_PARENT_ID parent_id)
+    )
+  )
+
+  ; main
+
+  ; if our value is not an odd amount then we are invalid
+  (assert (logand my_amount ONE)
+    ; then
+    (c
+      (list ASSERT_MY_AMOUNT my_amount)
+      (c
+        ; Verify the lineage proof by asserting our parent's ID
+        (verify_lineage_proof
+          SINGLETON_STRUCT
+          ; calculate our parent's ID
+          (calculate_coin_id
+            (parent_info_for_lineage_proof lineage_proof)
+            (if (is_not_eve_proof lineage_proof)  ; The PH calculation changes based on the lineage proof
+                (calculate_full_puzzle_hash SINGLETON_STRUCT (puzzle_hash_for_lineage_proof lineage_proof))  ; wrap the innerpuz in a singleton
+                (launcher_puzzle_hash_for_singleton_struct SINGLETON_STRUCT)  ; Use the static launcher puzzle hash
+            )
+            (if (is_not_eve_proof lineage_proof)  ; The position of "amount" changes based on the type on lineage proof
+                (amount_for_lineage_proof lineage_proof)
+                (amount_for_eve_proof lineage_proof)
+            )
+          )
+          (is_not_eve_proof lineage_proof)
+        )
+        ; finally check all of the conditions for a single odd output to wrap
+        (check_and_morph_conditions_for_singleton SINGLETON_STRUCT (a INNER_PUZZLE inner_solution) 0)
+      )
+    )
+  )
+)

chia/wallet/puzzles/singleton_top_layer_v1_1.clsp.hex

@@ -0,0 +1 @@
+ff02ffff01ff02ffff03ffff18ff2fff3480ffff01ff04ffff04ff20ffff04ff2fff808080ffff04ffff02ff3effff04ff02ffff04ff05ffff04ffff02ff2affff04ff02ffff04ff27ffff04ffff02ffff03ff77ffff01ff02ff36ffff04ff02ffff04ff09ffff04ff57ffff04ffff02ff2effff04ff02ffff04ff05ff80808080ff808080808080ffff011d80ff0180ffff04ffff02ffff03ff77ffff0181b7ffff015780ff0180ff808080808080ffff04ff77ff808080808080ffff02ff3affff04ff02ffff04ff05ffff04ffff02ff0bff5f80ffff01ff8080808080808080ffff01ff088080ff0180ffff04ffff01ffffffff4947ff0233ffff0401ff0102ffffff20ff02ffff03ff05ffff01ff02ff32ffff04ff02ffff04ff0dffff04ffff0bff3cffff0bff34ff2480ffff0bff3cffff0bff3cffff0bff34ff2c80ff0980ffff0bff3cff0bffff0bff34ff8080808080ff8080808080ffff010b80ff0180ffff02ffff03ffff22ffff09ffff0dff0580ff2280ffff09ffff0dff0b80ff2280ffff15ff17ffff0181ff8080ffff01ff0bff05ff0bff1780ffff01ff088080ff0180ff02ffff03ff0bffff01ff02ffff03ffff02ff26ffff04ff02ffff04ff13ff80808080ffff01ff02ffff03ffff20ff1780ffff01ff02ffff03ffff09ff81b3ffff01818f80ffff01ff02ff3affff04ff02ffff04ff05ffff04ff1bffff04ff34ff808080808080ffff01ff04ffff04ff23ffff04ffff02ff36ffff04ff02ffff04ff09ffff04ff53ffff04ffff02ff2effff04ff02ffff04ff05ff80808080ff808080808080ff738080ffff02ff3affff04ff02ffff04ff05ffff04ff1bffff04ff34ff8080808080808080ff0180ffff01ff088080ff0180ffff01ff04ff13ffff02ff3affff04ff02ffff04ff05ffff04ff1bffff04ff17ff8080808080808080ff0180ffff01ff02ffff03ff17ff80ffff01ff088080ff018080ff0180ffffff02ffff03ffff09ff09ff3880ffff01ff02ffff03ffff18ff2dffff010180ffff01ff0101ff8080ff0180ff8080ff0180ff0bff3cffff0bff34ff2880ffff0bff3cffff0bff3cffff0bff34ff2c80ff0580ffff0bff3cffff02ff32ffff04ff02ffff04ff07ffff04ffff0bff34ff3480ff8080808080ffff0bff34ff8080808080ffff02ffff03ffff07ff0580ffff01ff0bffff0102ffff02ff2effff04ff02ffff04ff09ff80808080ffff02ff2effff04ff02ffff04ff0dff8080808080ffff01ff0bffff0101ff058080ff0180ff02ffff03ffff21ff17ffff09ff0bff158080ffff01ff04ff30ffff04ff0bff808080ffff01ff088080ff0180ff018080