chia-blockchain 2.5.2rc2__py3-none-any.whl → 2.5.3rc2__py3-none-any.whl

chia/wallet/did_wallet/puzzles/did_innerpuz.clsp

@@ -1,135 +0,0 @@
-; The DID innerpuzzle is designed to sit inside the singleton layer and provide functionality related to being an identity.
-; At the moment the two pieces of functionality are recovery and message creation.
-; A DID's ID is it's Singleton ID
-; Recovery is based around having a list of known other DIDs which can send messages approving you change the innerpuzzle of your DID singleton
-
-(mod
-  (
-    INNER_PUZZLE  ; Standard P2 inner puzzle, used to record the ownership of the DID.
-    RECOVERY_DID_LIST_HASH  ; the list of DIDs that can send messages to you for recovery we store only the hash so that we don't have to reveal every time we make a message spend
-    NUM_VERIFICATIONS_REQUIRED  ; how many of the above list are required for a recovery
-    SINGLETON_STRUCT  ; my singleton_struct, formerly a Truth - ((SINGLETON_MOD_HASH, (LAUNCHER_ID, LAUNCHER_PUZZLE_HASH)))
-    METADATA  ; Customized metadata, e.g KYC info
-    mode  ; this indicates which spend mode we want. 0. Recovery mode 1. Run INNER_PUZZLE with p2_solution
-    my_amount_or_inner_solution  ; In mode 0, we use this to recover our coin and assert it is our actual amount
-    ; In mode 1 this is the solution of the inner P2 puzzle, only required in the create message mode and transfer mode.
-    new_inner_puzhash  ; In recovery mode, this will be the new wallet DID puzzle hash
-    parent_innerpuzhash_amounts_for_recovery_ids  ; during a recovery we need extra information about our recovery list coins
-    pubkey  ; this is the new pubkey used for a recovery
-    recovery_list_reveal  ; this is the reveal of the stored list of DIDs approved for recovery
-    my_id  ; my coin ID
-  )
-  ;message is the new puzzle in the recovery and standard spend cases
-
-  ;MOD_HASH, MY_PUBKEY, RECOVERY_DID_LIST_HASH are curried into the puzzle
-  ;EXAMPLE SOLUTION (0xcafef00d 0x12341234 0x923bf9a7856b19d335a65f12d68957d497e1f0c16c0e14baf6d120e60753a1ce 2 1 100 (q "source code") 0xdeadbeef 0xcafef00d ((0xdadadada 0xdad5dad5 200) () (0xfafafafa 0xfaf5faf5 200)) 0xfadeddab (0x22222222 0x33333333 0x44444444))
-
-  (include condition_codes.clib)
-  (include curry-and-treehash.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)
-    )
-  )
-
-  ; recovery message module - gets values curried in to make the puzzle
-  (defun make_message_puzzle (recovering_coin newpuz pubkey)
-    (qq (q . (((unquote CREATE_COIN_ANNOUNCEMENT) (unquote recovering_coin)) ((unquote AGG_SIG_UNSAFE) (unquote pubkey) (unquote newpuz)))))
-  )
-
-  ; this function creates the assert announcement for each message coin approving a recovery
-  (defun-inline create_consume_message (coin_id my_id new_innerpuz pubkey)
-    (list ASSERT_COIN_ANNOUNCEMENT (sha256 (sha256 coin_id (sha256tree1 (make_message_puzzle my_id new_innerpuz pubkey))) my_id))
-  )
-
-  ; this function calculates a coin ID given the inner puzzle and singleton information
-  (defun create_coin_ID_for_recovery (SINGLETON_STRUCT launcher_id parent innerpuzhash amount)
-    (sha256 parent (calculate_full_puzzle_hash (c (f SINGLETON_STRUCT) (c launcher_id (r (r SINGLETON_STRUCT)))) innerpuzhash) amount)
-  )
-
-
-  ; 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 (f SINGLETON_STRUCT)
-      inner_puzzle_hash
-      (sha256tree1 SINGLETON_STRUCT)
-    )
-  )
-
-  ; this loops over our identities to check list, and checks if we have been given parent information for this identity
-  ; the reason for this is because we might only require 3/5 of the IDs give approval messages for a recovery
-  ; if we have the information for an identity then we create a consume message using that information
-
-  (defun check_messages_from_identities (SINGLETON_STRUCT num_verifications_required identities my_id  new_puz parent_innerpuzhash_amounts_for_recovery_ids pubkey num_verifications)
-    (if identities
-        (if (f parent_innerpuzhash_amounts_for_recovery_ids)
-            ; if we have parent information then we should create a consume coin condition
-            (c
-              (create_consume_message
-                ; create coin_id from DID
-                (create_coin_ID_for_recovery
-                  SINGLETON_STRUCT
-                  (f identities)
-                  (f (f parent_innerpuzhash_amounts_for_recovery_ids))
-                  (f (r (f parent_innerpuzhash_amounts_for_recovery_ids)))
-                (f (r (r (f parent_innerpuzhash_amounts_for_recovery_ids)))))
-                my_id
-                new_puz
-                pubkey
-              )
-              (check_messages_from_identities
-                SINGLETON_STRUCT
-                num_verifications_required
-                (r identities)
-                my_id
-                new_puz
-                (r parent_innerpuzhash_amounts_for_recovery_ids)
-                pubkey
-                (+ num_verifications 1)
-              )
-            )
-            ; if no parent information found for this identity, move on to next in list
-            (check_messages_from_identities
-              SINGLETON_STRUCT
-              (r identities)
-              my_id
-              new_puz
-              (r parent_innerpuzhash_amounts_for_recovery_ids)
-              pubkey
-              num_verifications
-            )
-        )
-        ;if we're out of identites to check for, check we have enough
-        (if (> num_verifications (- num_verifications_required 1))
-            (list (list AGG_SIG_UNSAFE pubkey new_puz) )
-            (x)
-        )
-    )
-  )
-
-  ;Spend modes:
-  ;0 = recovery
-  ;1 = run the INNER_PUZZLE
-
-  ;MAIN
-  (if mode
-      ; mode 1 - run INNER_PUZZLE
-      (a INNER_PUZZLE my_amount_or_inner_solution)
-
-      ; mode 0 - recovery
-      (if (all (= (sha256tree1 recovery_list_reveal) RECOVERY_DID_LIST_HASH) (> NUM_VERIFICATIONS_REQUIRED 0))
-          (c (list ASSERT_MY_AMOUNT my_amount_or_inner_solution)
-            (c (list CREATE_COIN new_inner_puzhash my_amount_or_inner_solution (list new_inner_puzhash))
-              (c (list ASSERT_MY_COIN_ID my_id)
-                (check_messages_from_identities SINGLETON_STRUCT NUM_VERIFICATIONS_REQUIRED recovery_list_reveal my_id new_inner_puzhash parent_innerpuzhash_amounts_for_recovery_ids pubkey 0)
-              )
-            )
-          )
-          (x)
-      )
-  )
-)

chia/wallet/did_wallet/puzzles/did_innerpuz.clsp.hex

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

chia/wallet/payment.py

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

chia/wallet/puzzles/augmented_condition.clsp

@@ -1,13 +0,0 @@
-(mod
-  (
-    CONDITION
-    INNER_PUZZLE
-    inner_solution
-  )
-
-  (c
-    CONDITION
-    (a INNER_PUZZLE inner_solution)
-  )
-
-)

chia/wallet/puzzles/augmented_condition.clsp.hex

@@ -1 +0,0 @@
-ff04ff02ffff02ff05ff0b8080

chia/wallet/puzzles/condition_codes.clib

@@ -1,77 +0,0 @@
-; See chia/types/condition_opcodes.py
-
-(
-
-  ; Unavailable until after 2.0 hard fork
-  (defconstant AGG_SIG_PARENT 43)
-  (defconstant AGG_SIG_PUZZLE 44)
-  (defconstant AGG_SIG_AMOUNT 45)
-  (defconstant AGG_SIG_PUZZLE_AMOUNT 46)
-  (defconstant AGG_SIG_PARENT_AMOUNT 47)
-  (defconstant AGG_SIG_PARENT_PUZZLE 48)
-  ;
-
-  (defconstant AGG_SIG_UNSAFE 49)
-  (defconstant AGG_SIG_ME 50)
-
-  ; the conditions below reserve coin amounts and have to be accounted for in output totals
-
-  (defconstant CREATE_COIN 51)
-  (defconstant RESERVE_FEE 52)
-
-  ; the conditions below deal with announcements, for inter-coin communication
-
-  ; coin announcements
-  (defconstant CREATE_COIN_ANNOUNCEMENT 60)
-  (defconstant ASSERT_COIN_ANNOUNCEMENT 61)
-
-  ; puzzle announcements
-  (defconstant CREATE_PUZZLE_ANNOUNCEMENT 62)
-  (defconstant ASSERT_PUZZLE_ANNOUNCEMENT 63)
-
-  ; coin-id
-  (defconstant ASSERT_CONCURRENT_SPEND 64)
-  ; puzzle-hash
-  (defconstant ASSERT_CONCURRENT_PUZZLE 65)
-
-  ; mask message ...
-  (defconstant SEND_MESSAGE 66)
-  (defconstant RECEIVE_MESSAGE 67)
-
-  ; the conditions below let coins inquire about themselves
-
-  (defconstant ASSERT_MY_COIN_ID 70)
-  (defconstant ASSERT_MY_PARENT_ID 71)
-  (defconstant ASSERT_MY_PUZZLEHASH 72)
-  (defconstant ASSERT_MY_AMOUNT 73)
-  (defconstant ASSERT_MY_BIRTH_SECONDS 74)
-  (defconstant ASSERT_MY_BIRTH_HEIGHT 75)
-  (defconstant ASSERT_EPHEMERAL 76)
-
-  ; the conditions below ensure that we're "far enough" in the future
-
-  ; wall-clock time
-  (defconstant ASSERT_SECONDS_RELATIVE 80)
-  (defconstant ASSERT_SECONDS_ABSOLUTE 81)
-
-  ; block index
-  (defconstant ASSERT_HEIGHT_RELATIVE 82)
-  (defconstant ASSERT_HEIGHT_ABSOLUTE 83)
-
-  ; the conditions below ensure that we're "not too far" in the future
-
-  ; wall-clock time
-  (defconstant ASSERT_BEFORE_SECONDS_RELATIVE 84)
-  (defconstant ASSERT_BEFORE_SECONDS_ABSOLUTE 85)
-
-  ; block index
-  (defconstant ASSERT_BEFORE_HEIGHT_RELATIVE 86)
-  (defconstant ASSERT_BEFORE_HEIGHT_ABSOLUTE 87)
-
-  ; A condition that is always true and always ignore all arguments
-  (defconstant REMARK 1)
-
-  ; A condition whose first argument specifies its cost, but is unkown otherwise
-  ; It's a place-holder for soft-forking in new conditions
-  (defconstant SOFTFORK 90)
-)

chia/wallet/puzzles/curry-and-treehash.clib

@@ -1,102 +0,0 @@
-;;
-;; THIS FILE IS DEPRECATED and is only for legacy contracts.
-;; Please use `curry.clib` going forward. It has a less stupid API.
-;;
-
-(
-  ;; 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 ONE 1)
-  (defconstant TWO 2)
-  (defconstant A_KW #a)
-  (defconstant Q_KW #q)
-  (defconstant C_KW #c)
-
-  ;; 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)
-      (sha256 TWO (sha256 TWO (sha256 ONE Q_KW) parameter-hash)
-    (sha256 TWO environment-hash (sha256 ONE 0))))
-  )
-
-  ;; This function recursively calls `update-hash-for-parameter-hash`, updating `environment-hash`
-  ;; along the way.
-
-  (defun build-curry-list (reversed-curry-parameter-hashes environment-hash)
-    (if reversed-curry-parameter-hashes
-        (build-curry-list (r reversed-curry-parameter-hashes)
-        (update-hash-for-parameter-hash (f reversed-curry-parameter-hashes) environment-hash))
-        environment-hash
-    )
-  )
-
-  ;; Given the tree hash `environment-hash` of an environment tree E
-  ;; and the tree hash `function-hash` of a function tree F
-  ;; return the tree hash of the tree corresponding to
-  ;; `(a (q . F) 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 . F) E)` = `(a . ((q . F)  . (E . 0)))`
-
-  (defun-inline tree-hash-of-apply (function-hash environment-hash)
-    (sha256 TWO (sha256 ONE A_KW)
-      (sha256 TWO (sha256 TWO (sha256 ONE Q_KW) function-hash)
-    (sha256 TWO environment-hash (sha256 ONE 0))))
-  )
-
-  ;; DO NOT USE THIS FUNCTION GOING FORWARD. Having to pass the arguments in reverse order is stupid.
-  ;; When I (RK) wrote this, I thought it was necessary, but of course, I was just being dumb
-  ;; and it is not necessary. It's very confusing.
-  ;;
-  ;; function-hash:
-  ;;   the hash of a puzzle function, ie. a `mod`
-  ;;
-  ;; reversed-curry-parameter-hashes:
-  ;;   a list of pre-hashed trees representing parameters to be curried into the puzzle.
-  ;;   Note that this must be applied in REVERSED order. This may seem strange, but it greatly simplifies
-  ;;   the underlying code, since we calculate the tree hash from the bottom nodes up, and the last
-  ;;   parameters curried must have their hashes calculated first.
-  ;;
-  ;; we return the hash of the curried expression
-  ;;   (a (q . function-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 actual curried program.
-
-  ;; DO NOT USE
-  (defun puzzle-hash-of-curried-function (function-hash . reversed-curry-parameter-hashes)
-    (tree-hash-of-apply function-hash
-    (build-curry-list reversed-curry-parameter-hashes (sha256 ONE ONE)))
-  )
-
-  (defconstant b32 32)
-
-  (defun-inline size_b32 (var)
-    (= (strlen var) b32)
-  )
-
-  (defun calculate_coin_id (parent puzzlehash amount)
-    (if (all (size_b32 parent) (size_b32 puzzlehash) (> amount -1))
-        (sha256 parent puzzlehash amount)
-        (x)
-    )
-  )
-
-  ; takes a lisp tree and returns the hash of it
-  (defun sha256tree (TREE)
-    (if (l TREE)
-        (sha256 2 (sha256tree (f TREE)) (sha256tree (r TREE)))
-  (sha256 1 TREE)))
-
-)

chia/wallet/puzzles/curry.clib

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

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

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

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

chia/wallet/puzzles/dao_cat_launcher.clsp

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

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

chia/wallet/puzzles/dao_finished_state.clsp

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

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

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

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