chia-blockchain 2.5.1rc1__py3-none-any.whl

chia/wallet/puzzles/curry.clib

@@ -0,0 +1,135 @@
+(
+  ;; The code below is used to calculate of the tree hash of a curried function
+  ;; without actually doing the curry, and using other optimization tricks
+  ;; like unrolling `sha256tree`.
+
+  (defconstant TWO 2)
+  (defconstant constant_tree (
+      (0x4bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a .  ;  = `(sha256 1)`
+      0x9dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2) .  ;  = `(sha256 1 1)` = `(sha256 1 #q)`
+      (0x02a12871fee210fb8619291eaea194581cbd2531e4b23759d225f6806923f63222 .  ;  = `(concat 2 (sha256 1 #a))`
+      0x02a8d5dd63fba471ebcb1f3e8f7c1e1879b7152a6e7298a91ce119a63400ade7c5)  ;  = `(concat 2 (sha256 1 #c))`
+    )
+  )
+
+  ; I looked into calculating the values of `constant_tree` because it's pretty easy to code-golf
+  ; out an implementation that produces the values cheaper than just inlining them. The problem is,
+  ; when do we calculate them? If there were a way to calculate it "before main" and include it in
+  ; the globally-accessible constant table, we could do that. But we can't which means to be optimal,
+  ; client code should call the "build table" code once, then pass it around to anyone that wants to
+  ; call `curry` or `curry2`. This is pretty intrusive, so for now we'll just use the existing
+  ; global constant infrastructure, and include it as a fixed table so the tree of four values will
+  ; appear in all code that includes this file, and it will compress better in generators.
+
+  (defun-inline sha256_one _noargs (f (f constant_tree)))
+  (defun-inline sha256_one_one _noargs (r (f constant_tree)))
+  (defun-inline two_sha256_one_a_kw _noargs (f (r constant_tree)))
+  (defun-inline two_sha256_one_c_kw _noargs (r (r constant_tree)))
+
+  ;; this returns the sha256 tree hash of expression F = `((q . a1) a2)`
+  (defun hash_expression_F (a1 a2)
+    (sha256 TWO (sha256 TWO (sha256_one_one) a1)
+    (sha256 TWO a2 (sha256_one)))
+  )
+
+  ;; Given the tree hash `environment_hash` of an environment tree E
+  ;; and the tree hash `parameter_hash` of a constant parameter P
+  ;; return the tree hash of the tree corresponding to
+  ;; `(c (q . P) E)`
+  ;; This is the new environment tree with the addition parameter P curried in.
+  ;;
+  ;; Note that `(c (q . P) E)` = `(c . ((q . P) . (E . 0)))`
+
+  (defun-inline update_hash_for_parameter_hash (parameter_hash environment_hash)
+    (sha256 (two_sha256_one_c_kw) (hash_expression_F parameter_hash environment_hash))
+  )
+
+  ;; Given the tree hash `environment_hash` of an environment tree E
+  ;; and the tree hash `mod_hash` of a mod M
+  ;; return the tree hash of the tree corresponding to
+  ;; `(a (q . M) E)`
+  ;; This is the hash of a new function that adopts the new environment E.
+  ;; This is used to build of the tree hash of a curried function.
+  ;;
+  ;; Note that `(a (q . M) E)` = `(a . ((q . M)  . (E . 0)))`
+
+  (defun-inline tree_hash_of_apply (mod_hash environment_hash)
+    (sha256 (two_sha256_one_a_kw) (hash_expression_F mod_hash environment_hash))
+  )
+
+  ;; This function recursively calls `update_hash_for_parameter_hash`
+
+  (defun calculate_hash_of_curried_parameters (curry_parameter_hashes)
+    (if curry_parameter_hashes
+        (update_hash_for_parameter_hash (f curry_parameter_hashes) (calculate_hash_of_curried_parameters (r curry_parameter_hashes)))
+        (sha256_one_one)
+    )
+  )
+
+  ;; mod_hash:
+  ;;   the hash of a puzzle function, ie. a `mod`
+  ;;
+  ;; curry_parameter_hashes:
+  ;;   a list of pre_hashed trees representing parameters to be curried into the puzzle.
+  ;;
+  ;; we return the hash of the curried expression
+  ;;   (a (q . mod_hash) (c (cp1 (c cp2 (c ... 1)...))))
+  ;;
+  ;; Note that from a user's perspective the hashes passed in here aren't simply
+  ;; the hashes of the desired parameters, but their treehash representation since
+  ;; that's the form we're assuming they take in the acutal curried program.
+
+  ;; inline functions that take varargs don't seem to work, so we can't inline `curry`
+
+  (defun curry_hashes (mod_hash . curry_parameter_hashes)
+    (tree_hash_of_apply mod_hash
+    (calculate_hash_of_curried_parameters curry_parameter_hashes))
+  )
+
+
+  ;; This is the macro version that inlines everything and expects varargs parameters.
+  ;; It may be more efficient in some cases.
+
+  (defmacro curry_hashes_inline (mod_hash . curry_parameter_hashes)
+    (qq
+      (sha256
+        ; apply
+        (two_sha256_one_a_kw)
+        (sha256 TWO
+          ; func
+          (sha256 TWO
+            (sha256_one_one)
+            (unquote mod_hash)
+          )
+          (sha256 TWO
+            ; args
+            (unquote (c build_pre_hashed_environment curry_parameter_hashes))
+            (sha256_one)
+          )
+        )
+      )
+    )
+  )
+
+
+  ;; helper macro
+
+  (defmacro build_pre_hashed_environment curry_parameter_hashes
+    (qq
+      (sha256
+        (two_sha256_one_c_kw)
+        (sha256 TWO
+          (sha256 TWO
+            (sha256_one_one)
+            (unquote (f curry_parameter_hashes))
+          )
+          (sha256 TWO
+            (unquote (if (r curry_parameter_hashes) (c build_pre_hashed_environment (r curry_parameter_hashes)) (q . (sha256_one_one))))
+            (sha256_one)
+          )
+        )
+      )
+    )
+  )
+
+)

chia/wallet/puzzles/curry_by_index.clib

@@ -0,0 +1,16 @@
+(
+  (defun recurry_by_index_ordered (
+      index_value_pairs_list  ; MUST BE ORDERED
+      current_position  ; must be 0 on initial call
+      CURRENT_PARAMS  ; current list of curry params
+    )
+    (if index_value_pairs_list
+        (if (= (f (f index_value_pairs_list)) current_position)
+            (c (r (f index_value_pairs_list)) (recurry_by_index_ordered (r index_value_pairs_list) (+ current_position 1) (r CURRENT_PARAMS)))
+            (c (f CURRENT_PARAMS) (recurry_by_index_ordered index_value_pairs_list (+ current_position 1) (r CURRENT_PARAMS)))
+        )
+        ()
+    )
+  )
+
+)

chia/wallet/puzzles/dao_cat_eve.clsp

@@ -0,0 +1,17 @@
+; This file is what the first form the CAT takes, and then it gets immediately eve spent out of here.
+; This allows the coin to move into its real state already having been eve spent and validated to not be a fake CAT.
+; The trick is that we won't know what the real state puzzlehash reveal is, but we will know what this is.
+; Mint into this, eve spend out of this
+(mod (
+    NEW_PUZZLE_HASH  ; this is the CAT inner_puzzle
+    my_amount
+    tail_reveal
+    tail_solution
+  )
+  (include condition_codes.clib)
+  (list
+    (list CREATE_COIN NEW_PUZZLE_HASH my_amount (list NEW_PUZZLE_HASH))
+    (list ASSERT_MY_AMOUNT my_amount)
+    (list CREATE_COIN 0 -113 tail_reveal tail_solution)  ; this is secure because anything but the real values won't work
+  )
+)

chia/wallet/puzzles/dao_cat_eve.clsp.hex

@@ -0,0 +1 @@
+ff02ffff01ff04ffff04ff06ffff04ff05ffff04ff0bffff04ffff04ff05ff8080ff8080808080ffff04ffff04ff04ffff04ff0bff808080ffff04ffff04ff06ffff04ff80ffff04ffff01818fffff04ff17ffff04ff2fff808080808080ff80808080ffff04ffff01ff4933ff018080

chia/wallet/puzzles/dao_cat_launcher.clsp

@@ -0,0 +1,36 @@
+(mod (
+    TREASURY_SINGLETON_STRUCT
+    treasury_inner_puz_hash
+    parent_parent
+    new_puzzle_hash  ; the full CAT puzzle
+    amount
+  )
+  (include condition_codes.clib)
+  (include curry-and-treehash.clib)
+
+  (defun calculate_singleton_puzzle_hash (PROPOSAL_SINGLETON_STRUCT inner_puzzle_hash)
+    (puzzle-hash-of-curried-function (f PROPOSAL_SINGLETON_STRUCT)
+      inner_puzzle_hash
+      (sha256tree PROPOSAL_SINGLETON_STRUCT)
+    )
+  )
+
+  (defun create_parent_conditions (parent_id new_puzzle_hash amount)
+    (list
+      (list ASSERT_COIN_ANNOUNCEMENT (sha256 parent_id (sha256tree (list 'm' new_puzzle_hash))))
+      (list ASSERT_MY_PARENT_ID parent_id)
+    )
+  )
+
+  (c
+    (list CREATE_COIN new_puzzle_hash amount (list new_puzzle_hash))
+    (c
+      (list ASSERT_MY_AMOUNT amount)
+      (create_parent_conditions
+        (sha256 parent_parent (calculate_singleton_puzzle_hash TREASURY_SINGLETON_STRUCT treasury_inner_puz_hash) ONE)
+        new_puzzle_hash
+        amount
+      )
+    )
+  )
+)

chia/wallet/puzzles/dao_cat_launcher.clsp.hex

@@ -0,0 +1 @@
+ff02ffff01ff04ffff04ff34ffff04ff2fffff04ff5fffff04ffff04ff2fff8080ff8080808080ffff04ffff04ff28ffff04ff5fff808080ffff02ff36ffff04ff02ffff04ffff0bff17ffff02ff26ffff04ff02ffff04ff05ffff04ff0bff8080808080ff3c80ffff04ff2fffff04ff5fff8080808080808080ffff04ffff01ffffff3dff4947ffff0233ff0401ffff01ff02ff02ffff03ff05ffff01ff02ff3affff04ff02ffff04ff0dffff04ffff0bff2affff0bff3cff2c80ffff0bff2affff0bff2affff0bff3cff1280ff0980ffff0bff2aff0bffff0bff3cff8080808080ff8080808080ffff010b80ff0180ffffff02ff2effff04ff02ffff04ff09ffff04ff0bffff04ffff02ff3effff04ff02ffff04ff05ff80808080ff808080808080ff04ffff04ff10ffff04ffff0bff05ffff02ff3effff04ff02ffff04ffff04ffff016dffff04ff0bff808080ff8080808080ff808080ffff04ffff04ff38ffff04ff05ff808080ff808080ffff0bff2affff0bff3cff2480ffff0bff2affff0bff2affff0bff3cff1280ff0580ffff0bff2affff02ff3affff04ff02ffff04ff07ffff04ffff0bff3cff3c80ff8080808080ffff0bff3cff8080808080ff02ffff03ffff07ff0580ffff01ff0bffff0102ffff02ff3effff04ff02ffff04ff09ff80808080ffff02ff3effff04ff02ffff04ff0dff8080808080ffff01ff0bffff0101ff058080ff0180ff018080

chia/wallet/puzzles/dao_finished_state.clsp

@@ -0,0 +1,35 @@
+; This code is the end state of a proposal or a dividend.
+; It is an oracle which simply recreates itself and emits an announcement that it has concluded operation
+
+(mod (SINGLETON_STRUCT DAO_FINISHED_STATE_MOD_HASH my_amount)
+  (include condition_codes.clib)
+  (include curry-and-treehash.clib)
+  (include *standard-cl-21*)
+
+  (defun wrap_in_singleton (SINGLETON_STRUCT my_inner_puzhash)
+    (puzzle-hash-of-curried-function (f SINGLETON_STRUCT)
+      my_inner_puzhash
+      (sha256tree SINGLETON_STRUCT)
+    )
+  )
+
+  (defun recreate_self (SINGLETON_STRUCT DAO_FINISHED_STATE_MOD_HASH)
+    (puzzle-hash-of-curried-function DAO_FINISHED_STATE_MOD_HASH
+      (sha256 ONE DAO_FINISHED_STATE_MOD_HASH)
+      (sha256tree SINGLETON_STRUCT)
+    )
+  )
+
+
+  (let
+    (
+      (my_inner_puzhash (recreate_self SINGLETON_STRUCT DAO_FINISHED_STATE_MOD_HASH))
+    )
+    (list
+      (list ASSERT_MY_PUZZLEHASH (wrap_in_singleton SINGLETON_STRUCT my_inner_puzhash))
+      (list ASSERT_MY_AMOUNT my_amount)
+      (list CREATE_COIN my_inner_puzhash my_amount)
+      (list CREATE_PUZZLE_ANNOUNCEMENT 0)
+    )
+  )
+)

chia/wallet/puzzles/dao_finished_state.clsp.hex

@@ -0,0 +1 @@
+ff02ffff01ff04ffff04ffff0148ffff04ffff02ff16ffff04ff02ffff04ffff05ffff06ff018080ffff04ffff02ff1effff04ff02ffff04ff05ffff04ff0bff8080808080ff8080808080ffff01808080ffff04ffff04ffff0149ffff04ffff05ffff06ffff06ffff06ff0180808080ffff01808080ffff04ffff04ffff0133ffff04ffff02ff1effff04ff02ffff04ff05ffff04ff0bff8080808080ffff04ffff05ffff06ffff06ffff06ff0180808080ffff0180808080ffff04ffff04ffff013effff04ffff0180ffff01808080ffff018080808080ffff04ffff01ffffff02ffff03ff05ffff01ff02ffff01ff02ff08ffff04ff02ffff04ffff06ff0580ffff04ffff0bffff0102ffff0bffff0101ffff010480ffff0bffff0102ffff0bffff0102ffff0bffff0101ffff010180ffff05ff058080ffff0bffff0102ff0bffff0bffff0101ffff018080808080ff8080808080ff0180ffff01ff02ffff010bff018080ff0180ff0bffff0102ffff01a0a12871fee210fb8619291eaea194581cbd2531e4b23759d225f6806923f63222ffff0bffff0102ffff0bffff0102ffff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ff0580ffff0bffff0102ffff02ff08ffff04ff02ffff04ff07ffff01ffa09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b280808080ffff01a04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a808080ffff02ffff03ffff07ff0580ffff01ff02ffff01ff0bffff0102ffff02ff0affff04ff02ffff04ffff05ff0580ff80808080ffff02ff0affff04ff02ffff04ffff06ff0580ff8080808080ff0180ffff01ff02ffff01ff0bffff0101ff0580ff018080ff0180ffff02ff0cffff04ff02ffff04ff09ffff04ff0bffff04ffff02ff0affff04ff02ffff04ff05ff80808080ff808080808080ff02ff0cffff04ff02ffff04ff0bffff04ffff0bffff0101ff0b80ffff04ffff02ff0affff04ff02ffff04ff05ff80808080ff808080808080ff018080

chia/wallet/puzzles/dao_finished_state.clsp.hex.sha256tree

@@ -0,0 +1 @@
+7f3cc356732907933a8f9b1ccf16f71735d07340eb38c847aa402e97d75eb40b

chia/wallet/puzzles/dao_lockup.clsp

@@ -0,0 +1,288 @@
+; This code is the "voting mode" for a DAO CAT.
+; The coin can be spent from this state to vote on a proposal or claim a dividend.
+; It locks the CAT in while it has active votes/dividends going on.
+; Once a vote or dividend closes, then the coin can spend itself to remove that coin from the "active list"
+; If the "active list" is empty the coin can leave the voting mode
+
+(mod (
+    ; this is the first curry
+    SINGLETON_MOD_HASH
+    SINGLETON_LAUNCHER_PUZHASH
+    DAO_FINISHED_STATE_MOD_HASH
+    CAT_MOD_HASH
+    CAT_TAIL_HASH
+    ; this is the second curry
+    SELF_HASH  ; this is the self_hash Optimization
+    ACTIVE_VOTES  ; "active votes" list
+    INNERPUZ
+    ; this is the solution
+    my_id  ; if my_id is 0 we do the return to return_address (exit voting mode) spend case
+    inner_solution
+    my_amount
+    new_proposal_vote_id_or_removal_id  ; removal_id is a list of removal_ids
+    proposal_innerpuzhash  ; list of singleton innerpuzhashes which should match the order of the new_proposal_vote_id list
+    vote_info
+    vote_amount
+    my_inner_puzhash
+    new_innerpuzhash  ; only include this if we're changing owners - secured because coin is still made from inner_puz
+  )
+  (include condition_codes.clib)
+  (include curry-and-treehash.clib)
+  (include *standard-cl-21*)
+
+  (defun calculate_finished_state (singleton_struct dao_finished_state)
+    (puzzle-hash-of-curried-function dao_finished_state
+      (sha256 ONE dao_finished_state)
+      (sha256tree singleton_struct)
+    )
+  )
+
+  ; take two lists and merge them into one
+  (defun merge_list (list_a list_b)
+    (if list_a
+        (c (f list_a) (merge_list (r list_a) list_b))
+        list_b
+    )
+  )
+
+  (defun wrap_in_cat_layer (CAT_MOD_HASH CAT_TAIL_HASH INNERPUZHASH)
+    (puzzle-hash-of-curried-function CAT_MOD_HASH
+      INNERPUZHASH
+      (sha256 ONE CAT_TAIL_HASH)
+      (sha256 ONE CAT_MOD_HASH)
+    )
+  )
+
+  ; loop through conditions and check that they aren't trying to create anything they shouldn't
+  (defun check_conditions (conditions vote_added_puzhash my_amount message vote_amount my_inner_puzhash seen_vote seen_change)
+    (if conditions
+        (if (= (f (f conditions)) CREATE_COIN)  ; this guarantees that the new coin is obeying the rules - other coins are banned to avoid re-voting
+            (if (= (f (r (f conditions))) vote_added_puzhash)
+                (if seen_vote  ; assert we haven't already made a coin with the new vote included
+                    (x)
+                    (if (= (f (r (r (f conditions)))) my_amount)  ; we vote with all our value
+                        (if seen_change  ; assert that we haven't already recreated ourself in some fashion
+                            (x)
+                            (c (f conditions) (check_conditions (r conditions) vote_added_puzhash my_amount message vote_amount my_inner_puzhash 1 1))
+                        )
+                        (if (= (f (r (r (f conditions)))) vote_amount)  ; we vote with part of our power
+                            (c (f conditions) (check_conditions (r conditions) vote_added_puzhash my_amount message vote_amount my_inner_puzhash 1 seen_change))
+                            (x)
+                        )
+                    )
+                )
+                (if (all
+                      (= (f (r (f conditions))) my_inner_puzhash)
+                      (not seen_change)
+                      (= (f (r (r (f conditions)))) (- my_amount vote_amount))
+                    )  ; we recreate ourselves with unused voting power
+                    (c (f conditions) (check_conditions (r conditions) vote_added_puzhash my_amount message vote_amount my_inner_puzhash seen_vote 1))
+                    (x)
+                )
+            )
+            (if (= (f (f conditions)) CREATE_PUZZLE_ANNOUNCEMENT)  ; this secures the values used to generate message - other messages are banned in case of LIES
+                (if (= (f (r (f conditions))) message)
+                    (c (f conditions) (check_conditions (r conditions) vote_added_puzhash my_amount message vote_amount my_inner_puzhash seen_vote seen_change))
+                    (x)
+                )
+                (c (f conditions) (check_conditions (r conditions) vote_added_puzhash my_amount message vote_amount my_inner_puzhash seen_vote seen_change))
+            )
+        )
+        (if (all seen_vote seen_change)  ; check all value is accounted for
+            ()
+            (x)
+        )
+    )
+  )
+
+  ; go through our list of active votes and check that we aren't revoting
+  (defun check_not_previously_voted (
+      SINGLETON_MOD_HASH
+      SINGLETON_LAUNCHER_PUZHASH
+      INNERPUZ
+      my_id
+      new_vote_id
+      active_votes
+      proposal_innerpuzhash
+    )
+    (if active_votes
+        (if (= new_vote_id (f active_votes))  ; check new vote id is not equal to an existent vote id
+            (x)
+            (check_not_previously_voted
+              SINGLETON_MOD_HASH
+              SINGLETON_LAUNCHER_PUZHASH
+              INNERPUZ
+              my_id
+              new_vote_id
+              (r active_votes)
+              proposal_innerpuzhash
+            )
+        )
+        (list ASSERT_PUZZLE_ANNOUNCEMENT
+          (sha256
+            (calculate_singleton_puzzle_hash
+              (c SINGLETON_MOD_HASH (c new_vote_id SINGLETON_LAUNCHER_PUZHASH))
+              proposal_innerpuzhash
+            )
+            my_id
+          )
+        )
+    )
+  )
+
+
+  (defun calculate_singleton_puzzle_hash (PROPOSAL_SINGLETON_STRUCT inner_puzzle_hash)
+    (puzzle-hash-of-curried-function (f PROPOSAL_SINGLETON_STRUCT)
+      inner_puzzle_hash
+      (sha256tree PROPOSAL_SINGLETON_STRUCT)
+    )
+  )
+
+  (defun calculate_lockup_puzzlehash (
+      SELF_HASH
+      active_votes
+      innerpuzhash
+    )
+    (puzzle-hash-of-curried-function SELF_HASH
+      innerpuzhash
+      (sha256tree active_votes)
+      (sha256 ONE SELF_HASH)
+    )
+  )
+
+  (defun for_every_removal_id (
+      SINGLETON_MOD_HASH
+      SINGLETON_LAUNCHER_PUZHASH
+      SELF_HASH
+      DAO_FINISHED_STATE_MOD_HASH
+      CAT_MOD_HASH
+      CAT_TAIL_HASH
+      ACTIVE_VOTES
+      INNERPUZ
+      removal_ids
+      my_amount
+      unused_votes
+    )
+    (if removal_ids
+        (c
+          (list
+            ASSERT_PUZZLE_ANNOUNCEMENT  ; check proposal is actually finished
+            (sha256
+              (calculate_singleton_puzzle_hash
+                (c SINGLETON_MOD_HASH (c (f removal_ids) SINGLETON_LAUNCHER_PUZHASH))
+                (calculate_finished_state
+                  (c SINGLETON_MOD_HASH (c (f removal_ids) SINGLETON_LAUNCHER_PUZHASH))
+                  DAO_FINISHED_STATE_MOD_HASH
+                )
+              )
+              0
+            )
+          )
+          (for_every_removal_id
+            SINGLETON_MOD_HASH
+            SINGLETON_LAUNCHER_PUZHASH
+            SELF_HASH
+            DAO_FINISHED_STATE_MOD_HASH
+            CAT_MOD_HASH
+            CAT_TAIL_HASH
+            ACTIVE_VOTES
+            INNERPUZ
+            (r removal_ids)
+            my_amount
+            (c (f removal_ids) unused_votes)
+          )
+        )
+        (list
+          (list ASSERT_MY_AMOUNT my_amount)  ; assert that we aren't lying about our amount to free up money and re-vote
+          (list
+            CREATE_COIN  ; recreate self with the finished proposal ID removed
+            (calculate_lockup_puzzlehash
+              SELF_HASH
+              (remove_list_one_entries_from_list_two unused_votes ACTIVE_VOTES)
+              (sha256tree INNERPUZ)
+            )
+            my_amount
+          )
+        )
+    )
+  )
+
+  (defun remove_list_one_entries_from_list_two (list_one list_two)
+    (if list_one
+        (remove_item_from_list (f list_one) (remove_list_one_entries_from_list_two (r list_one) list_two))
+        list_two
+    )
+  )
+
+  (defun remove_item_from_list (item list_one)
+    (if list_one
+        (if (= (f list_one) item)
+            (r list_one)  ; assuming there are no duplicates
+            (c (f list_one) (remove_item_from_list item (r list_one)))
+        )
+        ()  ; item was never in list_one, return list_two entirely
+    )
+  )
+
+
+  ; main
+  (if my_id
+      (c (list ASSERT_MY_PUZZLEHASH (wrap_in_cat_layer CAT_MOD_HASH CAT_TAIL_HASH my_inner_puzhash))
+        (c
+          (list ASSERT_MY_AMOUNT my_amount)
+          (c
+            (list ASSERT_MY_COIN_ID my_id)
+            (c
+              (if new_proposal_vote_id_or_removal_id
+                  (check_not_previously_voted  ; this returns a single condition asserting announcement from vote singleton
+                    SINGLETON_MOD_HASH
+                    SINGLETON_LAUNCHER_PUZHASH
+                    INNERPUZ
+                    my_id
+                    new_proposal_vote_id_or_removal_id
+                    ACTIVE_VOTES
+                    proposal_innerpuzhash
+                  )
+                  (list REMARK)
+              )
+
+              ; loop over conditions and check that we aren't trying to leave voting state
+              (check_conditions
+                (a INNERPUZ inner_solution)
+                (calculate_lockup_puzzlehash  ; compare created coin to our own calculation on what the next puzzle should be
+                  SELF_HASH
+                  (if new_proposal_vote_id_or_removal_id (c new_proposal_vote_id_or_removal_id ACTIVE_VOTES) ACTIVE_VOTES)
+                  (if new_innerpuzhash new_innerpuzhash (sha256tree INNERPUZ))
+                )
+                my_amount
+                ; TODO: add namespace to this announcement to allow announcements from the innerpuz
+                (sha256tree (list new_proposal_vote_id_or_removal_id vote_amount vote_info my_id))
+                vote_amount
+                my_inner_puzhash
+                0
+                0
+              )
+            )
+          )
+        )
+      )
+
+      ; return to return_address or remove something from active list - check if our locked list is empty
+      (if ACTIVE_VOTES
+          (for_every_removal_id  ; locked list is not empty, so we must be trying to remove something from it
+            SINGLETON_MOD_HASH
+            SINGLETON_LAUNCHER_PUZHASH
+            SELF_HASH
+            DAO_FINISHED_STATE_MOD_HASH
+            CAT_MOD_HASH
+            CAT_TAIL_HASH
+            ACTIVE_VOTES
+            INNERPUZ
+            new_proposal_vote_id_or_removal_id
+            my_amount
+            ()
+          )
+          (a INNERPUZ inner_solution)
+      )
+  )
+)

chia/wallet/puzzles/dao_lockup.clsp.hex

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

chia/wallet/puzzles/dao_lockup.clsp.hex.sha256tree

@@ -0,0 +1 @@
+9fa63e652e131f89a9f8bb6f7abb5ffc6ac485a78dcfb8710cd9df5c368774d9