chia-blockchain 2.5.1rc1__py3-none-any.whl

chia/wallet/vc_wallet/vc_puzzles/covenant_layer.clsp

@@ -0,0 +1,30 @@
+; This is a utility layer for a coin that allows it to prove that it came from some INITIAL_PUZZLE_HASH
+(mod
+  (
+    INITIAL_PUZZLE_HASH  ; The ancestor's puzzle hash this layer is evidence of
+    PARENT_MORPHER  ; Defines how to wrap a parent inner puzzle hash to prove that it had this layer running inside it
+    INNER_PUZZLE
+    lineage_proof  ; parent id, parent inner puzzle hash (wrapped with PARENT_MORPHER), parent amount
+    morpher_solution  ; solution to PARENT_MORPHER
+    inner_solution
+  )
+
+  (include condition_codes.clib)
+
+  (c
+    (list ASSERT_MY_PARENT_ID
+      (sha256
+        (f lineage_proof)
+        (if (r (r lineage_proof))  ; different logic based on whether the lineage proof is 2 or 3 elements long
+            (a PARENT_MORPHER (c INITIAL_PUZZLE_HASH (c (f (r lineage_proof)) morpher_solution)))
+            INITIAL_PUZZLE_HASH
+        )
+        (if (r (r lineage_proof))  ; different logic based on whether the lineage proof is 2 or 3 elements long
+            (f (r (r lineage_proof)))
+            (f (r lineage_proof))
+        )
+      )
+    )
+    (a INNER_PUZZLE inner_solution)
+  )
+)

chia/wallet/vc_wallet/vc_puzzles/covenant_layer.clsp.hex

@@ -0,0 +1 @@
+ff02ffff01ff04ffff04ff02ffff04ffff0bff4fffff02ffff03ff81efffff01ff02ff0bffff04ff05ffff04ff81afff5f808080ffff010580ff0180ffff02ffff03ff81efffff0182016fffff0181af80ff018080ff808080ffff02ff17ff81bf8080ffff04ffff0147ff018080

chia/wallet/vc_wallet/vc_puzzles/eml_covenant_morpher.clsp

@@ -0,0 +1,75 @@
+; This is a PARENT_MORPHER for use with covenant_layer.clsp
+
+; It is used to prove that the parent was a singleton -> exigent metadata layer (w/ covenant_layer in TP) puzzle stack
+(mod
+  (
+    ; We curry twice: first, all of the static information we need, then the hash of the program with all of that info
+    ; this allows use to be more efficient when calculating our own hash (a (q . SELF_HASH) (c SELF_HASH 1))
+    ; curried first - a bunch of info to create a singleton -> ownership layer puzzle stack
+    COVENANT_MOD_HASH
+    EML_MOD_HASH
+    ADAPTER_MOD_HASH
+    SINGLETON_MOD_HASH
+    SINGLETON_LAUNCHER_HASH_HASH
+    TP_HASH
+    ; curried second
+    SELF_HASH  ; tree hash of all the other hashes above
+    ; Truths
+    COVENANT_INITIAL_PUZZLE_HASH
+    PREVIOUS_INNER_PUZHASH
+    ; solution
+    previous_metadata_hash  ; pre-treehashed METADATA from our parent's EML
+    my_singleton_id  ; no need to commit to this, our parent is guaranteed to be a singleton with the same ID as ours
+  )
+
+  (include curry.clib)
+
+  (defconstant ONE 1)
+
+  (defun main
+    (
+      EML_MOD_HASH
+      SINGLETON_MOD_HASH
+      SINGLETON_LAUNCHER_HASH_HASH
+      PREVIOUS_INNER_PUZHASH
+      previous_metadata_hash
+      my_singleton_id
+      tp_hash
+    )
+
+    (curry_hashes SINGLETON_MOD_HASH
+      (sha256 TWO
+        (sha256 ONE SINGLETON_MOD_HASH)
+        (sha256 TWO
+          (sha256 ONE my_singleton_id)
+          SINGLETON_LAUNCHER_HASH_HASH
+        )
+      )
+      (curry_hashes EML_MOD_HASH
+        (sha256 ONE EML_MOD_HASH)
+        previous_metadata_hash
+        tp_hash
+        (sha256 ONE tp_hash)
+        PREVIOUS_INNER_PUZHASH
+      )
+    )
+  )
+
+  (main
+    EML_MOD_HASH
+    SINGLETON_MOD_HASH
+    SINGLETON_LAUNCHER_HASH_HASH
+    PREVIOUS_INNER_PUZHASH
+    previous_metadata_hash
+    my_singleton_id
+    (curry_hashes ADAPTER_MOD_HASH
+      (curry_hashes COVENANT_MOD_HASH
+        (sha256 ONE COVENANT_INITIAL_PUZZLE_HASH)
+        (curry_hashes SELF_HASH
+          (sha256 ONE SELF_HASH)
+        )
+        TP_HASH
+      )
+    )
+  )
+)

chia/wallet/vc_wallet/vc_puzzles/eml_covenant_morpher.clsp.hex

@@ -0,0 +1 @@
+ff02ffff01ff02ff1effff04ff02ffff04ff0bffff04ff2fffff04ff5fffff04ff8205ffffff04ff820bffffff04ff8217ffffff04ffff02ff1affff04ff02ffff04ff17ffff04ffff02ff1affff04ff02ffff04ff05ffff04ffff0bff08ff8202ff80ffff04ffff02ff1affff04ff02ffff04ff82017fffff04ffff0bff08ff82017f80ff8080808080ffff04ff81bfff80808080808080ff8080808080ff80808080808080808080ffff04ffff01ffff01ff02ff02ffff03ff05ffff01ff0bff72ffff02ff16ffff04ff02ffff04ff09ffff04ffff02ff1cffff04ff02ffff04ff0dff80808080ff808080808080ffff016280ff0180ffffffffa04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459aa09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ffa102a12871fee210fb8619291eaea194581cbd2531e4b23759d225f6806923f63222a102a8d5dd63fba471ebcb1f3e8f7c1e1879b7152a6e7298a91ce119a63400ade7c5ff0bff52ffff02ff16ffff04ff02ffff04ff05ffff04ffff02ff1cffff04ff02ffff04ff07ff80808080ff808080808080ffff0bff14ffff0bff14ff62ff0580ffff0bff14ff0bff428080ff02ff1affff04ff02ffff04ff0bffff04ffff0bff14ffff0bff08ff0b80ffff0bff14ffff0bff08ff81bf80ff178080ffff04ffff02ff1affff04ff02ffff04ff05ffff04ffff0bff08ff0580ffff04ff5fffff04ff82017fffff04ffff0bff08ff82017f80ffff04ff2fff808080808080808080ff808080808080ff018080

chia/wallet/vc_wallet/vc_puzzles/eml_transfer_program_covenant_adapter.clsp

@@ -0,0 +1,32 @@
+; This is a layer that adapts the API between an ownership layer and its transfer program when the transfer program is
+; wrapped with a covenant layer.
+(mod
+  (
+    COVENANT_LAYER
+    METADATA  ; Truth
+    CONDITIONS  ; Truth
+    ; covenant layer solution
+    (
+      lineage_proof
+      morpher_solution
+      inner_solution
+    )
+  )
+
+  ; Solution from covenant layer comes back like so:
+  ; ((ASSERT_MY_PARENT_ID 0x...) new_metadata new_tp conditions)
+  ; so we need to move that ASSERT_MY_PARENT_ID to the returned conditions from the TP
+  (defun fix_condition ((parent_assertion . (new_owner new_tp conditions)))
+    (list new_owner new_tp (c parent_assertion conditions))
+  )
+
+  (fix_condition (a
+      COVENANT_LAYER
+      (list
+        lineage_proof
+        morpher_solution
+        ; Covenant layer doesn't know about truths so we need to pass those down to the inner tp solution
+        (list METADATA CONDITIONS inner_solution)
+      )
+  ))
+)

chia/wallet/vc_wallet/vc_puzzles/eml_transfer_program_covenant_adapter.clsp.hex

@@ -0,0 +1 @@
+ff02ffff01ff02ff02ffff04ff02ffff04ffff02ff05ffff04ff4fffff04ff81afffff04ffff04ff0bffff04ff17ffff04ff82016fff80808080ff8080808080ff80808080ffff04ffff01ff04ff15ffff04ff2dffff04ffff04ff09ff5d80ff80808080ff018080

chia/wallet/vc_wallet/vc_puzzles/eml_update_metadata_with_DID.clsp

@@ -0,0 +1,80 @@
+; This is a TRANSFER_PROGRAM for use with exigent_metadata_layer.clsp
+
+; Given a DID's singleton struct, assert its announcement of any changes. If no DID's innerpuz is provided, then just
+; return the same metadata and transfer program with no conditions
+
+; This TP also allows metadata to be cleared and transfer program to be reset simultaneously, no DID required
+(mod
+  (
+    SINGLETON_MOD_HASH
+    SINGLETON_LAUNCHER_HASH
+    (provider_id . metadata)  ; Truth
+    conditions  ; Truth
+    ; tp_solution looks like this in the case of a DID update
+    (
+      provider_innerpuzhash
+      my_coin_id
+      new_metadata
+      new_transfer_program_hash
+    )
+    ; tp_solution could also be () or new_transfer_program_hash for two other cases:
+    ;  - () == continue with the same metadata we currently have
+    ;  - new_transfer_program_hash == update the transfer program to whatever, but clear the metadata
+  )
+
+  (include condition_codes.clib)
+  (include curry.clib)
+  (include sha256tree.clib)
+  (include utility_macros.clib)
+
+  (defconstant ONE 1)
+
+  (defun-inline create_did_puzhash
+    (
+      SINGLETON_MOD_HASH
+      SINGLETON_LAUNCHER_HASH
+      provider_id
+      provider_innerpuzhash
+    )
+
+    (curry_hashes_inline SINGLETON_MOD_HASH
+      ; calculate the singleton struct
+      (sha256 TWO
+        (sha256 ONE SINGLETON_MOD_HASH)
+        (sha256 TWO
+          (sha256 ONE provider_id)
+          (sha256 ONE SINGLETON_LAUNCHER_HASH)
+        )
+      )
+      provider_innerpuzhash
+    )
+  )
+
+  ; Returning (new_metadata new_transfer_program_hash conditions)
+  (if (l (f (r (r (r (r (r @)))))))  ; If a tp solution was provided
+      (list
+        (i new_metadata (c provider_id new_metadata) ())
+        new_transfer_program_hash
+        (list
+          (list ASSERT_MY_COIN_ID my_coin_id)
+          ; get an announcement from the DID in the EML's metadata to update to a new metadata and transfer program
+          (list ASSERT_PUZZLE_ANNOUNCEMENT
+            (sha256
+              (create_did_puzhash SINGLETON_MOD_HASH SINGLETON_LAUNCHER_HASH provider_id provider_innerpuzhash)
+              (sha256
+                my_coin_id
+                (sha256tree new_metadata)
+                new_transfer_program_hash
+              )
+            )
+          )
+        )
+      )
+      ; else - the tp_solution is an atom
+      (if (f (r (r (r (r (r @))))))  ; If a new_transfer_program_hash was provided
+          (list () (f (r (r (r (r (r @)))))) ())
+          ; else - No new TP was provided, continue with current metadata
+          (list (c provider_id metadata) () ())
+      )
+  )
+)

chia/wallet/vc_wallet/vc_puzzles/eml_update_metadata_with_DID.clsp.hex

@@ -0,0 +1 @@
+ff02ffff01ff02ffff03ffff07ff5f80ffff01ff04ffff03ff8202dfffff04ff27ff8202df80ff8080ffff04ff8205dfffff04ffff04ffff04ff08ffff04ff82015fff808080ffff04ffff04ff14ffff04ffff0bffff0bff56ffff0bff0affff0bff0aff66ff0580ffff0bff0affff0bff76ffff0bff0affff0bff0aff66ffff0bff0affff0bff1cff0580ffff0bff0affff0bff1cff2780ffff0bff1cff0b80808080ffff0bff0affff0bff76ffff0bff0affff0bff0aff66ff819f80ffff0bff0aff66ff46808080ff46808080ff46808080ffff0bff82015fffff02ff1effff04ff02ffff04ff8202dfff80808080ff8205df8080ff808080ff808080ff80808080ffff01ff02ffff03ff5fffff01ff04ff80ffff04ff5fffff01ff80808080ffff01ff04ffff04ff27ff3780ffff01ff80ff80808080ff018080ff0180ffff04ffff01ffff46ff3f01ff02ffffffa04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459aa09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ffa102a12871fee210fb8619291eaea194581cbd2531e4b23759d225f6806923f63222a102a8d5dd63fba471ebcb1f3e8f7c1e1879b7152a6e7298a91ce119a63400ade7c5ff02ffff03ffff07ff0580ffff01ff0bffff0102ffff02ff1effff04ff02ffff04ff09ff80808080ffff02ff1effff04ff02ffff04ff0dff8080808080ffff01ff0bffff0101ff058080ff0180ff018080

chia/wallet/vc_wallet/vc_puzzles/exigent_metadata_layer.clsp

@@ -0,0 +1,163 @@
+; This layer is an outer puzzle that keeps some metadata that must be reaffirmed by a "transfer program" on every spend.
+;
+; In a way, this puzzle acts as a p2_merkle_tree puzzle where there are always two leaves and BOTH must run every spend.
+;
+; The inner puzzle runs first and actually supplies the solution to the transfer program.
+;
+; Likely, the transfer program is placed into the EML by a party who does not currently control the coin, to enforce
+; that certain behaviors regarding the curried metadata are followed.
+(mod
+  (
+    THIS_MOD_HASH
+    METADATA  ; The metadata can be anything. It is passed to the transfer program and new metadata is returned.
+    TRANSFER_PROGRAM  ; Runs every spend, solution supplied by the inner puzzle
+    TRANSFER_PROGRAM_HASH  ; we also include the hash for efficiency's sake when re-calculating our own hash
+    INNER_PUZZLE
+    inner_solution
+  )
+
+  (include condition_codes.clib)
+  (include curry-and-treehash.clib)
+  (include utility_macros.clib)
+
+  (defun-inline nft_ownership_layer_puzzle_hash
+    (
+      THIS_MOD_HASH
+      new_owner
+      TRANSFER_PROGRAM_HASH
+      inner_puzzle_hash
+    )
+    (puzzle-hash-of-curried-function THIS_MOD_HASH
+      inner_puzzle_hash
+      (sha256 ONE TRANSFER_PROGRAM_HASH)
+      TRANSFER_PROGRAM_HASH
+      (sha256tree new_owner)
+      (sha256 ONE THIS_MOD_HASH)
+    )
+  )
+
+  (defun-inline construct_end_conditions
+    (
+      THIS_MOD_HASH
+      TRANSFER_PROGRAM
+      TRANSFER_PROGRAM_HASH
+      odd_args
+      (new_owner new_tp_hash conditions)
+    )
+    (c
+      (c
+        CREATE_COIN
+        (c
+          (nft_ownership_layer_puzzle_hash
+            THIS_MOD_HASH
+            new_owner
+            (if new_tp_hash new_tp_hash TRANSFER_PROGRAM_HASH)
+            (f odd_args)
+          )
+          (r odd_args)
+        )
+      )
+      conditions
+    )
+  )
+
+  (defun process_conditions
+    (
+      THIS_MOD_HASH
+      TRANSFER_PROGRAM
+      TRANSFER_PROGRAM_HASH
+      METADATA
+      all_conditions
+      conditions
+      ; These args all start at ()
+      (
+        odd_args
+        tp_output
+        condition_to_prepend
+      )
+    )
+    ; This loop works a bit differently than most condition wrapping loops
+    ;
+    ; We expect an invalid condition (-10) that we must strip out, but we must also wrap the odd create coin based on
+    ; information from that condition.
+    ;
+    ; To facilitate this, each iteration of the loop calls the next iteration with the condition it wishes to prepend
+    ; to the list. If we want to strip out a condition, we call the next iteration with () as condition_to_prepend
+    ; which will cause an empty REMARK condition to be prepended as a no-op instead. The two conditions that will
+    ; trigger this are the magic condition (-10) and the odd create coin condition. The magic condition never makes it
+    ; back into the list, but the CREATE_COIN is re-created wrapped by construct_end_conditions.
+    (c
+      (i condition_to_prepend condition_to_prepend (list REMARK))
+      (if conditions
+          (process_conditions
+            THIS_MOD_HASH
+            TRANSFER_PROGRAM
+            TRANSFER_PROGRAM_HASH
+            METADATA
+            all_conditions
+            (r conditions)
+            (if (= (f (f conditions)) CREATE_COIN)
+                (if (logand (f (r (r (f conditions)))) 1)
+                    (assert (not odd_args)
+                      ; then
+                      (list (r (f conditions)) tp_output ())
+                    )
+                    ; else - amount is not odd
+                    (list odd_args tp_output (f conditions))
+                )
+                ; else - condition is not a create coin
+                (if (= (f (f conditions)) -10)  ; -10 is "magic" opcode for running transfer program
+                    (assert (not tp_output)
+                      ; then
+                      (list
+                        odd_args
+                        (a TRANSFER_PROGRAM (list METADATA all_conditions (r (f conditions))))
+                        ()
+                      )
+                    )
+                    ; else - condition is not a create coin nor a NEW_OWNER_CONDITION
+                    (list odd_args tp_output (f conditions))
+                )
+            )
+          )
+          ; else - we have no more conditions
+          ; odd_args and tp_solution are guaranteed to not be nil or else we'll have a path into atom error
+          (construct_end_conditions
+            THIS_MOD_HASH
+            TRANSFER_PROGRAM
+            TRANSFER_PROGRAM_HASH
+            odd_args
+            tp_output
+          )
+      )
+    )
+  )
+
+  (defun main
+    (
+      THIS_MOD_HASH
+      TRANSFER_PROGRAM
+      TRANSFER_PROGRAM_HASH
+      METADATA
+      conditions
+    )
+    (process_conditions
+      THIS_MOD_HASH
+      TRANSFER_PROGRAM
+      TRANSFER_PROGRAM_HASH
+      METADATA
+      conditions
+      conditions
+      (list () () ())
+    )
+  )
+
+  ; main
+  (main
+    THIS_MOD_HASH
+    TRANSFER_PROGRAM
+    TRANSFER_PROGRAM_HASH
+    METADATA
+    (a INNER_PUZZLE inner_solution)
+  )
+)

chia/wallet/vc_wallet/vc_puzzles/exigent_metadata_layer.clsp.hex

@@ -0,0 +1 @@
+ff02ffff01ff02ff3affff04ff02ffff04ff05ffff04ff17ffff04ff2fffff04ff0bffff04ffff02ff5fff81bf80ff8080808080808080ffff04ffff01ffffff02ff3304ff01ff0101ffff02ffff02ffff03ff05ffff01ff02ff2affff04ff02ffff04ff0dffff04ffff0bff12ffff0bff14ff3880ffff0bff12ffff0bff12ffff0bff14ff2c80ff0980ffff0bff12ff0bffff0bff14ff8080808080ff8080808080ffff010b80ff0180ff02ff16ffff04ff02ffff04ff05ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff5fffff01ffff80ff80ff8080808080808080808080ffff04ffff03ff820b7fff820b7fffff04ff3cff808080ffff02ffff03ff81bfffff01ff02ff16ffff04ff02ffff04ff05ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8201bfffff04ffff02ffff03ffff09ff82023fff2880ffff01ff02ffff03ffff18ff820b3fffff010180ffff01ff02ffff03ffff20ff82027f80ffff01ff04ff82033fffff04ff82057fffff01ff80808080ffff01ff088080ff0180ffff01ff04ff82027fffff04ff82057fffff04ff82013fff8080808080ff0180ffff01ff02ffff03ffff09ff82023fffff0181f680ffff01ff02ffff03ffff20ff82057f80ffff01ff04ff82027fffff04ffff02ff0bffff04ff2fffff04ff5fffff04ff82033fff8080808080ffff01ff80808080ffff01ff088080ff0180ffff01ff04ff82027fffff04ff82057fffff04ff82013fff8080808080ff018080ff0180ff80808080808080808080ffff01ff04ffff04ff28ffff04ffff02ff2effff04ff02ffff04ff05ffff04ff82047fffff04ffff0bff14ffff02ffff03ff82157fffff0182157fffff011780ff018080ffff04ffff02ffff03ff82157fffff0182157fffff011780ff0180ffff04ffff02ff3effff04ff02ffff04ff82097fff80808080ffff04ffff0bff14ff0580ff808080808080808080ff82067f8080ff822d7f8080ff018080ffff0bff12ffff0bff14ff1080ffff0bff12ffff0bff12ffff0bff14ff2c80ff0580ffff0bff12ffff02ff2affff04ff02ffff04ff07ffff04ffff0bff14ff1480ff8080808080ffff0bff14ff8080808080ff02ffff03ffff07ff0580ffff01ff0bffff0102ffff02ff3effff04ff02ffff04ff09ff80808080ffff02ff3effff04ff02ffff04ff0dff8080808080ffff01ff0bffff0101ff058080ff0180ff018080

chia/wallet/vc_wallet/vc_puzzles/p2_announced_delegated_puzzle.clsp

@@ -0,0 +1,16 @@
+; This is a generalization of the idea behind singleton_launcher.clsp
+
+; Given a delegated puzzle and solution, just run them and announce the hash of the delegated puzzle.
+; A parent can rely on this announcement so if the exact delegated_puzzle it is expecting is not run, the whole bundle
+; fails due to a grandparent paradox.
+(mod
+  (
+    delegated_puzzle
+    delegated_solution
+  )
+
+  (include condition_codes.clib)
+  (include sha256tree.clib)
+
+  (c (list CREATE_COIN_ANNOUNCEMENT (sha256tree delegated_puzzle)) (a delegated_puzzle delegated_solution))
+)

chia/wallet/vc_wallet/vc_puzzles/p2_announced_delegated_puzzle.clsp.hex

@@ -0,0 +1 @@
+ff02ffff01ff04ffff04ff04ffff04ffff02ff06ffff04ff02ffff04ff05ff80808080ff808080ffff02ff05ff0b8080ffff04ffff01ff3cff02ffff03ffff07ff0580ffff01ff0bffff0102ffff02ff06ffff04ff02ffff04ff09ff80808080ffff02ff06ffff04ff02ffff04ff0dff8080808080ffff01ff0bffff0101ff058080ff0180ff018080

chia/wallet/vc_wallet/vc_puzzles/standard_vc_backdoor_puzzle.clsp

@@ -0,0 +1,74 @@
+; This is the standard puzzle that a VerifiedCredential provider will put into the backdoor slot of viral_backdoor.clsp
+
+; The goal of this puzzle is to recreate the VC exactly as it is except for three things:
+; 1) There is no longer a viral backdoor layer
+; 2) The metadata in the ownership layer becomes ()
+; 3) The transfer program in the ownership layer becomes a curried default
+(mod
+  (
+    SINGLETON_MOD_HASH
+    SINGLETON_LAUNCHER_HASH_HASH
+    OWNERSHIP_LAYER_MOD_HASH
+    VIRAL_BACKDOOR_MOD_HASH
+    DEFAULT_TRANSFER_PROGRAM_HASH
+    ; most of the specific information is solved rather than curried in because we don't care about committing to it
+    launcher_id  ; of the singleton this is inside of
+    metadata_hash  ; of the EML this is inside of
+    tp_hash  ; of the EML this is inside of
+    this_hash_hash  ; the hash of this puzzle with all of its curried arguments hashed AGAIN with (sha256 1 this_hash)
+    inner_puzzle_hash  ; that determines ownership of this coin
+    my_amount  ; this coin's amount
+    ownership_lineage_proof  ; need to solve the covenant layer one last time
+    previous_metadata_hash  ; like metadata_hash above but for the previous coin
+    announcement_nonce  ; Anything to announce (for fees/DID to hook onto)
+    (
+      provider_innerpuzhash  ; DID needs to authorize the transfer program (and therefore this backdoor)
+      my_coin_id
+    )
+  )
+
+  (include condition_codes.clib)
+  (include curry.clib)
+
+  (defconstant ONE 1)
+
+  (list
+    ; The purpose of this condition is just to make sure we're telling the truth about the current inner puzzle hash
+    (list ASSERT_MY_PUZZLEHASH
+      (curry_hashes SINGLETON_MOD_HASH
+        (sha256 TWO
+          (sha256 ONE SINGLETON_MOD_HASH)
+          (sha256 TWO
+            (sha256 ONE launcher_id)
+            SINGLETON_LAUNCHER_HASH_HASH
+          )
+        )
+        (curry_hashes OWNERSHIP_LAYER_MOD_HASH
+          (sha256 ONE OWNERSHIP_LAYER_MOD_HASH)
+          metadata_hash
+          tp_hash
+          (sha256 ONE tp_hash)
+          (curry_hashes VIRAL_BACKDOOR_MOD_HASH
+            (sha256 ONE VIRAL_BACKDOOR_MOD_HASH)
+            this_hash_hash
+            (sha256 ONE inner_puzzle_hash)
+          )
+        )
+      )
+    )
+    (list ASSERT_MY_AMOUNT my_amount)
+    (list CREATE_COIN inner_puzzle_hash my_amount)
+    (list CREATE_COIN_ANNOUNCEMENT announcement_nonce)  ; For fee hooks
+    (list
+      -10
+      ownership_lineage_proof  ; for covenant layer
+      (list previous_metadata_hash launcher_id)  ; for covenant layer parent morpher
+      (list  ; for transfer program
+        provider_innerpuzhash
+        my_coin_id
+        ()
+        DEFAULT_TRANSFER_PROGRAM_HASH
+      )
+    )
+  )
+)

chia/wallet/vc_wallet/vc_puzzles/standard_vc_backdoor_puzzle.clsp.hex

@@ -0,0 +1 @@
+ff02ffff01ff04ffff04ff18ffff04ffff02ff2effff04ff02ffff04ff05ffff04ffff0bff12ffff0bff3cff0580ffff0bff12ffff0bff3cff81bf80ff0b8080ffff04ffff02ff2effff04ff02ffff04ff17ffff04ffff0bff3cff1780ffff04ff82017fffff04ff8202ffffff04ffff0bff3cff8202ff80ffff04ffff02ff2effff04ff02ffff04ff2fffff04ffff0bff3cff2f80ffff04ff8205ffffff04ffff0bff3cff820bff80ff80808080808080ff808080808080808080ff808080808080ff808080ffff04ffff04ff10ffff04ff8217ffff808080ffff04ffff04ff14ffff04ff820bffffff04ff8217ffff80808080ffff04ffff04ff2cffff04ff82bfffff808080ffff04ffff04ffff0181f6ffff04ff822fffffff04ffff04ff825fffffff04ff81bfff808080ffff04ffff04ff83027fffffff04ff83057fffffff04ff80ffff04ff5fff8080808080ff8080808080ff808080808080ffff04ffff01ffffff4948ff33ff3c01ffff02ff02ffff03ff05ffff01ff0bff76ffff02ff3effff04ff02ffff04ff09ffff04ffff02ff1affff04ff02ffff04ff0dff80808080ff808080808080ffff016680ff0180ffffffa04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459aa09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ffa102a12871fee210fb8619291eaea194581cbd2531e4b23759d225f6806923f63222a102a8d5dd63fba471ebcb1f3e8f7c1e1879b7152a6e7298a91ce119a63400ade7c5ffff0bff56ffff02ff3effff04ff02ffff04ff05ffff04ffff02ff1affff04ff02ffff04ff07ff80808080ff808080808080ff0bff12ffff0bff12ff66ff0580ffff0bff12ff0bff468080ff018080

chia/wallet/vc_wallet/vc_puzzles/std_parent_morpher.clsp

@@ -0,0 +1,23 @@
+; This is a PARENT_MORPHER for use with covenant_layer.clsp
+
+; You would use this morpher when the covenant layer is the outermost layer of the coin
+(mod
+  (
+    THIS_MOD_HASH
+    COVENANT_MOD_HASH
+    COVENANT_INITIAL_PUZZLE_HASH
+    inner_puzhash
+  )
+
+  (include curry.clib)
+
+  (curry_hashes_inline COVENANT_MOD_HASH
+    (sha256 1 COVENANT_INITIAL_PUZZLE_HASH)
+    (curry_hashes_inline THIS_MOD_HASH
+      (sha256 1 THIS_MOD_HASH)
+      (sha256 1 COVENANT_MOD_HASH)
+      (sha256 1 COVENANT_INITIAL_PUZZLE_HASH)
+    )
+    inner_puzhash
+  )
+)

chia/wallet/vc_wallet/vc_puzzles/std_parent_morpher.clsp.hex

@@ -0,0 +1 @@
+ff02ffff01ff0bff16ffff0bff04ffff0bff04ff1aff0b80ffff0bff04ffff0bff1effff0bff04ffff0bff04ff1affff0bffff0101ff178080ffff0bff04ffff0bff1effff0bff04ffff0bff04ff1affff0bff16ffff0bff04ffff0bff04ff1aff0580ffff0bff04ffff0bff1effff0bff04ffff0bff04ff1affff0bffff0101ff058080ffff0bff04ffff0bff1effff0bff04ffff0bff04ff1affff0bffff0101ff0b8080ffff0bff04ffff0bff1effff0bff04ffff0bff04ff1affff0bffff0101ff178080ffff0bff04ff1aff12808080ff12808080ff12808080ff1280808080ffff0bff04ffff0bff1effff0bff04ffff0bff04ff1aff2f80ffff0bff04ff1aff12808080ff12808080ff12808080ff12808080ffff04ffff01ff02ffffa04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459aa09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ffa102a12871fee210fb8619291eaea194581cbd2531e4b23759d225f6806923f63222a102a8d5dd63fba471ebcb1f3e8f7c1e1879b7152a6e7298a91ce119a63400ade7c5ff018080

chia/wallet/vc_wallet/vc_puzzles/viral_backdoor.clsp

@@ -0,0 +1,64 @@
+; This layer ensures that a second puzzle hash or "backdoor" that can be used without the inner puzzle's permission
+; travels with each generation of a coin.
+
+; The hidden puzzle is responsible for recreating this layer if it wishes, this layer will not wrap its outputs.
+(mod
+  (
+    THIS_MOD_HASH
+    HIDDEN_PUZZLE_HASH
+    INNER_PUZZLE_HASH  ; must be a hash so that the backdoor has enough info to create a puzzle reveal to spend the coin
+    hidden  ; bool for whether or not to run the hidden puzzle
+    inner_or_hidden_puzzle_reveal
+    inner_or_hidden_solution
+  )
+
+  (include condition_codes.clib)
+  (include curry.clib)
+  (include sha256tree.clib)
+  (include utility_macros.clib)
+
+  (defconstant ONE 1)
+
+  (defun-inline wrap_puzhash
+    (
+      THIS_MOD_HASH
+      HIDDEN_PUZZLE_HASH
+      new_inner_puzzle_hash
+    )
+
+    (curry_hashes_inline THIS_MOD_HASH
+      (sha256 ONE THIS_MOD_HASH)
+      (sha256 ONE HIDDEN_PUZZLE_HASH)
+      (sha256 ONE new_inner_puzzle_hash)
+    )
+  )
+
+  (defun wrap_create_coins
+    (
+      THIS_MOD_HASH
+      HIDDEN_PUZZLE_HASH
+      conditions
+    )
+    (if conditions
+        (if (= (f (f conditions)) CREATE_COIN)
+            (c
+              (c CREATE_COIN (c (wrap_puzhash THIS_MOD_HASH HIDDEN_PUZZLE_HASH (f (r (f conditions)))) (r (r (f conditions)))))
+              (wrap_create_coins THIS_MOD_HASH HIDDEN_PUZZLE_HASH (r conditions))
+            )
+            (c (f conditions) (wrap_create_coins THIS_MOD_HASH HIDDEN_PUZZLE_HASH (r conditions)))
+        )
+        ()
+    )
+  )
+
+  (if hidden
+      (assert (= HIDDEN_PUZZLE_HASH (sha256tree inner_or_hidden_puzzle_reveal))
+        ; then
+        (a inner_or_hidden_puzzle_reveal inner_or_hidden_solution)
+      )
+      (assert (= INNER_PUZZLE_HASH (sha256tree inner_or_hidden_puzzle_reveal))
+        ; then
+        (wrap_create_coins THIS_MOD_HASH HIDDEN_PUZZLE_HASH (a inner_or_hidden_puzzle_reveal inner_or_hidden_solution))
+      )
+  )
+)

chia/wallet/vc_wallet/vc_puzzles/viral_backdoor.clsp.hex

@@ -0,0 +1 @@
+ff02ffff01ff02ffff03ff2fffff01ff02ffff03ffff09ff0bffff02ff16ffff04ff02ffff04ff5fff8080808080ffff01ff02ff5fff81bf80ffff01ff088080ff0180ffff01ff02ffff03ffff09ff17ffff02ff16ffff04ff02ffff04ff5fff8080808080ffff01ff02ff1effff04ff02ffff04ff05ffff04ff0bffff04ffff02ff5fff81bf80ff808080808080ffff01ff088080ff018080ff0180ffff04ffff01ffff33ff0102ffffffa04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459aa09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ffa102a12871fee210fb8619291eaea194581cbd2531e4b23759d225f6806923f63222a102a8d5dd63fba471ebcb1f3e8f7c1e1879b7152a6e7298a91ce119a63400ade7c5ffff02ffff03ffff07ff0580ffff01ff0bffff0102ffff02ff16ffff04ff02ffff04ff09ff80808080ffff02ff16ffff04ff02ffff04ff0dff8080808080ffff01ff0bffff0101ff058080ff0180ff02ffff03ff17ffff01ff02ffff03ffff09ff47ff0880ffff01ff04ffff04ff08ffff04ffff0bff2affff0bff1cffff0bff1cff32ff0580ffff0bff1cffff0bff3affff0bff1cffff0bff1cff32ffff0bff14ff058080ffff0bff1cffff0bff3affff0bff1cffff0bff1cff32ffff0bff14ff0b8080ffff0bff1cffff0bff3affff0bff1cffff0bff1cff32ffff0bff14ff81a78080ffff0bff1cff32ff22808080ff22808080ff22808080ff22808080ff81e78080ffff02ff1effff04ff02ffff04ff05ffff04ff0bffff04ff37ff80808080808080ffff01ff04ff27ffff02ff1effff04ff02ffff04ff05ffff04ff0bffff04ff37ff8080808080808080ff0180ff8080ff0180ff018080