chia-blockchain 2.5.1rc1__py3-none-any.whl

chia/wallet/vc_wallet/cr_outer_puzzle.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable, Optional
+
+from clvm_tools.binutils import disassemble
+
+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.util.ints import uint64
+from chia.wallet.puzzle_drivers import PuzzleInfo, Solver
+from chia.wallet.uncurried_puzzle import UncurriedPuzzle, uncurry_puzzle
+from chia.wallet.vc_wallet.cr_cat_drivers import PROOF_FLAGS_CHECKER, construct_cr_layer, match_cr_layer, solve_cr_layer
+
+
+@dataclass(frozen=True)
+class CROuterPuzzle:
+    _match: Callable[[UncurriedPuzzle], Optional[PuzzleInfo]]
+    _construct: Callable[[PuzzleInfo, Program], Program]
+    _solve: Callable[[PuzzleInfo, Solver, Program, Program], Program]
+    _get_inner_puzzle: Callable[[PuzzleInfo, UncurriedPuzzle], Optional[Program]]
+    _get_inner_solution: Callable[[PuzzleInfo, Program], Optional[Program]]
+
+    def match(self, puzzle: UncurriedPuzzle) -> Optional[PuzzleInfo]:
+        args: Optional[tuple[list[bytes32], Program, Program]] = match_cr_layer(puzzle)
+        if args is None:
+            return None
+        authorized_providers, proofs_checker, inner_puzzle = args
+        constructor_dict: dict[str, Any] = {
+            "type": "credential restricted",
+            "authorized_providers": ["0x" + ap.hex() for ap in authorized_providers],
+            "proofs_checker": disassemble(proofs_checker),
+        }
+        next_constructor = self._match(uncurry_puzzle(inner_puzzle))
+        if next_constructor is not None:
+            constructor_dict["also"] = next_constructor.info
+        return PuzzleInfo(constructor_dict)
+
+    def get_inner_puzzle(self, constructor: PuzzleInfo, puzzle_reveal: UncurriedPuzzle) -> Optional[Program]:
+        args: Optional[tuple[list[bytes32], Program, Program]] = match_cr_layer(puzzle_reveal)
+        if args is None:
+            raise ValueError("This driver is not for the specified puzzle reveal")  # pragma: no cover
+        _, _, inner_puzzle = args
+        also = constructor.also()
+        if also is not None:
+            deep_inner_puzzle: Optional[Program] = self._get_inner_puzzle(also, uncurry_puzzle(inner_puzzle))
+            return deep_inner_puzzle
+        else:
+            return inner_puzzle
+
+    def get_inner_solution(self, constructor: PuzzleInfo, solution: Program) -> Optional[Program]:
+        my_inner_solution: Program = solution.at("rrrrrrf")
+        also = constructor.also()
+        if also:
+            deep_inner_solution: Optional[Program] = self._get_inner_solution(also, my_inner_solution)
+            return deep_inner_solution
+        else:
+            return my_inner_solution
+
+    def asset_id(self, constructor: PuzzleInfo) -> Optional[bytes32]:
+        return None
+
+    def construct(self, constructor: PuzzleInfo, inner_puzzle: Program) -> Program:
+        also = constructor.also()
+        if also is not None:
+            inner_puzzle = self._construct(also, inner_puzzle)
+        return construct_cr_layer(
+            constructor["authorized_providers"],
+            constructor["proofs_checker"] if "proofs_checker" in constructor else PROOF_FLAGS_CHECKER,
+            inner_puzzle,
+        )
+
+    def solve(self, constructor: PuzzleInfo, solver: Solver, inner_puzzle: Program, inner_solution: Program) -> Program:
+        coin_bytes: bytes = solver["coin"]
+        coin = Coin(bytes32(coin_bytes[0:32]), bytes32(coin_bytes[32:64]), uint64.from_bytes(coin_bytes[64:72]))
+        coin_name: str = coin.name().hex()
+        if "vc_authorizations" in solver.info:
+            vc_info = solver["vc_authorizations"][coin_name]
+        else:
+            vc_info = [
+                # TODO: This is something of a hack here, doesn't really work for proofs checkers generally.
+                # The problem is that the CAT driver above us is running its inner puzzle (us) in order to get the
+                # conditions that are output. This is bad practice on the CAT driver's part, the protocol should support
+                # asking inner drivers for what conditions they return. Alas, since this is not supported, we have to
+                # do a hack that we know will work for the one known proof checker we currently have.
+                uncurry_puzzle(constructor["proofs_checker"]).args.at("f"),
+                None,
+                constructor["authorized_providers"][0],  # Hack for similar reasons as above, we need a valid provider
+                None,
+                None,
+            ]
+
+        also = constructor.also()
+        if also is not None:
+            inner_solution = self._solve(also, solver, inner_puzzle, inner_solution)
+
+        return solve_cr_layer(  # type: ignore[call-arg]
+            *vc_info,
+            coin.name(),
+            inner_solution,
+        )

chia/wallet/vc_wallet/cr_puzzles/conditions_w_fee_announce.clsp

@@ -0,0 +1,3 @@
+(mod (CONDITIONS nonce)
+  (c (list 60 nonce) CONDITIONS)
+)

chia/wallet/vc_wallet/cr_puzzles/conditions_w_fee_announce.clsp.hex

@@ -0,0 +1 @@
+ff04ffff04ffff013cffff04ff05ff808080ff0280

chia/wallet/vc_wallet/cr_puzzles/credential_restriction.clsp

@@ -0,0 +1,304 @@
+; This is an outer puzzle for a coin that imposes a restriction that the coin can only be spent with an
+; announcement from a "verified credential" whose proofs are present due to a DID in a list of authorized providers.
+
+; A "verified credential" is defined as the following puzzle stack:
+;  - singleton top layer
+;    |_exigent metadata layer
+;      |_eml transfer program covenant adapter
+;      | |_covenant layer
+;      |   |_initial puzzle (hashed)
+;      |   | |_singleton top layer
+;      |   |   |_exigent metadata layer
+;      |   |     |_(mod (_ _ (provider tp)) (list (c provider ()) tp ())) (guaranteed metadata to be nil)
+;      |   |     |_p2 announced delegated puzzle
+;      |   |_eml covenant morpher
+;      |   |_eml update metadata with DID
+;      |_<inner puzzle>
+; The information to construct a VC is contained in a highly optimized way within CREDENTIAL_STRUCT
+;
+; This puzzle does many things:
+;  - Tree hash of a partially revealed tree to come to a proof hash present in the accompanying VC singleton
+;  - Validate the revealed proofs with a curried proofs checker
+;  - Assert an announcement from a VC with a message of 0xca which signals this spend is ok
+;  - Wrap all of its children in this layer
+;  - Create an announcement in the 0xcd namespace of each output it is creating (for a VC to assert if it wishes)
+;  - Block any announcements coming from the inner puzzle in the 0xcd namespace
+(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 (x INNER_PUZZLE 1)))
+    ; curried first
+    CREDENTIAL_STRUCT
+    AUTHORIZED_PROVIDERS
+    PROOFS_CHECKER
+    ; curried second
+    SELF_HASH
+    INNER_PUZZLE
+    proof_of_inclusions  ; Proof that key/value pairs exist in a tree (the root of the tree is implicit from this)
+    proof_checker_solution  ; solution to PROOFS_CHECKER program
+    provider_id  ; the DID that is curried into the metadata of the VC that is authorizing this coin
+    credential_id  ; the launcher ID of the VC that is authorizing this coin
+    credential_inner_puzhash  ; The <inner puzzle> (see above) of the VC that is authorizing this coin
+    my_coin_id  ; This coin's ID
+    inner_solution
+  )
+
+  (include curry.clib)
+  (include condition_codes.clib)
+  (include utility_macros.clib)
+
+  ; 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
+    )
+  )
+
+  (defconstant announcement_namespace 0xcd)
+  (defconstant ONE 1)
+
+  (defun-inline wrap_puzhash
+    (
+      SELF_HASH
+      puzhash
+    )
+
+    (curry_hashes SELF_HASH
+      (sha256 ONE SELF_HASH)
+      puzhash
+    )
+  )
+
+  ; Does three things:
+  ; 1) Wraps create coins with this layer
+  ; 2) Announces those create coins in a namespace
+  ; 3) Raises on announcements from the inner puzzle that could possibly be in the namespace
+  (defun process_conditions
+    (
+      SELF_HASH
+      conditions
+    )
+    (if conditions
+        (if (= (f (f conditions)) CREATE_COIN)
+            (c
+              (list
+                CREATE_COIN_ANNOUNCEMENT
+                (concat
+                  announcement_namespace
+                  (sha256 (f (r (f conditions))) (f (r (r (f conditions)))))
+                )
+              )
+              (c
+                (c
+                  CREATE_COIN
+                  (c
+                    (wrap_puzhash SELF_HASH (f (r (f conditions))))
+                    (r (r (f conditions)))
+                  )
+                )
+                (process_conditions SELF_HASH (r conditions))
+              )
+            )
+            ; else - not a create coin
+            (assert (or
+                (not (= (f (f conditions)) CREATE_COIN_ANNOUNCEMENT))  ; some coin announcements should be blocked
+                (not (= 33 (strlen (f (r (f conditions))))))  ; we only care about blocking 0xcd + some_hash
+                (not (= announcement_namespace (substr (f (r (f conditions))) 0 ONE)))  ; block prefix 0xcd
+              )
+              ; then
+              (c
+                (f conditions)
+                (process_conditions SELF_HASH (r conditions))
+              )
+            )
+        )
+        ; else - end of list
+        ()
+    )
+  )
+
+  (defun create_vc_puzhash_stage_2
+    (
+      (
+        (
+          (
+            SINGLETON_MOD_HASH
+            .
+            SINGLETON_LAUNCHER_HASH
+          )
+          .
+          (
+            OWNERSHIP_LAYER_MOD_HASH
+            .
+            ADAPTER_MOD_HASH
+          )
+        )
+        .
+        (
+          INITIAL_SINGLETON_INNER_PUZHASH
+          .
+          (
+            TWO_AND_COVENANT_MOD_HASH  ; (concat 2 COVENANT_MOD_HASH)
+            .
+            REST_COVENANT_ARGS_HASH  ; ((c PARENT_MORPHER (c EML_DID_TP 1)) . ()) hashed
+          )
+        )
+      )
+      provider_id
+      credential_singleton_struct_hash
+      proof_hash
+      credential_inner_puzhash
+      tp_hash
+    )
+
+    (curry_hashes SINGLETON_MOD_HASH
+      credential_singleton_struct_hash
+      (curry_hashes OWNERSHIP_LAYER_MOD_HASH
+        (sha256 ONE OWNERSHIP_LAYER_MOD_HASH)
+        (sha256 TWO
+          (sha256 ONE provider_id)
+          (sha256 ONE proof_hash)
+        )
+        tp_hash
+        (sha256 ONE tp_hash)
+        credential_inner_puzhash
+      )
+    )
+  )
+
+  (defun create_vc_puzhash
+    (
+      CREDENTIAL_STRUCT
+      provider_id
+      credential_singleton_struct_hash
+      proof_hash
+      credential_inner_puzhash
+    )
+
+    (create_vc_puzhash_stage_2
+      CREDENTIAL_STRUCT
+      provider_id
+      credential_singleton_struct_hash
+      proof_hash
+      credential_inner_puzhash
+      (curry_hashes (r (r (f CREDENTIAL_STRUCT)))  ; ADAPTER_MOD_HASH
+        (sha256
+          ; apply
+          (two_sha256_one_a_kw)
+          (sha256
+            ; func
+            (f (r (r CREDENTIAL_STRUCT)))  ; TWO_AND_COVENANT_MOD_HASH
+            (sha256 TWO
+              ; args
+              (sha256
+                (two_sha256_one_c_kw)
+                (sha256 TWO
+                  (sha256 TWO
+                    (sha256_one_one)
+                    (sha256 ONE (curry_hashes (f (f (f CREDENTIAL_STRUCT)))  ; SINGLETON_MOD_HASH
+                        credential_singleton_struct_hash
+                        (f (r CREDENTIAL_STRUCT))  ; INITIAL_SINGLETON_INNER_PUZHASH
+                    ))
+                  )
+                  (r (r (r CREDENTIAL_STRUCT)))  ; REST_COVENANT_ARGS_HASH
+                )
+              )
+              (sha256_one)
+            )
+          )
+        )
+      )
+    )
+  )
+
+  ; utility function that turns the output of two calls to collapse_tree_and_note_leaf_info into a single return value
+  (defun branch_hash_and_merge_info ((TREE1 PROOFS1) (TREE2 PROOFS2))
+    (list
+      (sha256 TWO TREE1 TREE2)
+      (merge_list PROOFS1 PROOFS2)
+    )
+  )
+
+  (defun collapse_tree_and_note_leaf_info (TREE PROOFS)
+    (if (l TREE)
+        (if (or (l (f TREE)) (l (r TREE)))  ; If either side is a cons, we have not reached a leaf pair yet
+            (branch_hash_and_merge_info
+              (collapse_tree_and_note_leaf_info (f TREE) ())
+              ; we favor right because merge_list merges from left
+              (collapse_tree_and_note_leaf_info (r TREE) PROOFS)
+            )
+            ; else - both first and rest are atoms, we are at a key/value pair
+            (branch_hash_and_merge_info
+              (list (sha256 ONE (f TREE)) ())
+              (list (sha256 ONE (r TREE)) (c TREE PROOFS))
+            )
+        )
+        (list TREE PROOFS)  ; All atoms that we reach must be pre-hashed subtrees
+    )
+  )
+
+  (defun main
+    (
+      CREDENTIAL_STRUCT
+      AUTHORIZED_PROVIDERS
+      PROOFS_CHECKER
+      SELF_HASH
+      proof_checker_solution
+      provider_id
+      credential_id
+      credential_inner_puzhash
+      my_coin_id
+      conditions
+      (tree_hash proofs)
+    )
+
+    (assert
+      ; Run proof checker to make sure it doesn't return () (fail)
+      (a PROOFS_CHECKER (list proofs proof_checker_solution))
+      (in provider_id AUTHORIZED_PROVIDERS)  ; VC needs to be in authorized list
+      ; then
+      (c
+        (list ASSERT_MY_COIN_ID my_coin_id)
+        (c
+          (list ASSERT_PUZZLE_ANNOUNCEMENT
+            (sha256
+              (create_vc_puzhash
+                CREDENTIAL_STRUCT
+                provider_id
+                (sha256 TWO
+                  (sha256 ONE (f (f (f CREDENTIAL_STRUCT))))  ; SINGLETON_MOD_HASH
+                  (sha256 TWO
+                    (sha256 ONE credential_id)
+                    (sha256 ONE (r (f (f CREDENTIAL_STRUCT))))  ; SINGLETON_LAUNCHER_HASH
+                  )
+                )
+                tree_hash
+                credential_inner_puzhash
+              )
+              (sha256 my_coin_id 0xca)  ; my_coin_id because VC must announce specifically to us
+            )
+          )
+          (process_conditions
+            SELF_HASH
+            conditions
+          )
+        )
+      )
+    )
+  )
+
+  (main
+    CREDENTIAL_STRUCT
+    AUTHORIZED_PROVIDERS
+    PROOFS_CHECKER
+    SELF_HASH
+    proof_checker_solution
+    provider_id
+    credential_id
+    credential_inner_puzhash
+    my_coin_id
+    (a INNER_PUZZLE inner_solution)
+    (collapse_tree_and_note_leaf_info proof_of_inclusions ())
+  )
+)

chia/wallet/vc_wallet/cr_puzzles/credential_restriction.clsp.hex

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

chia/wallet/vc_wallet/cr_puzzles/flag_proofs_checker.clsp

@@ -0,0 +1,45 @@
+; This is a PROOFS_CHECKER for use with credential_restriction.clsp
+;
+; In an attempt to be as simple as possible, this puzzle is curried a list of key/value pairs sorted by keys. This sort
+; is crucial to the program functioning as the key/value pairs of the proofs will be sorted before being compared to
+; the curried list.
+(mod
+  (
+    FLAGS  ; must be sorted
+    proofs  ; will be sorted
+    solution  ; unused
+  )
+
+  (include utility_macros.clib)
+
+  (defun insertion_sort_by_keys (sorted insertions)
+    (if insertions
+        (if (or (not sorted) (>s (f (f insertions)) (f (f sorted))))
+            (insertion_sort_by_keys (c (f insertions) sorted) (r insertions))
+            (insertion_sort_by_keys (c (f sorted) (insertion_sort_by_keys (r sorted) (list (f insertions)))) (r insertions))
+        )
+        sorted
+    )
+  )
+
+  (defun merge_insertion_sort (proofs)
+    (if (r proofs)
+        (insertion_sort_by_keys (merge_insertion_sort (r proofs)) (merge_insertion_sort (list (f proofs))))
+        proofs
+    )
+  )
+
+  ; This function checks that the revealed proofs START WITH the same key/value pairs as are in FLAGS. This is not for
+  ; any particular reason except optimization. We don't really care if EXTRA proof pairs are revealed.
+  (defun compare_first_pairs_against_flags (subject comp)
+    (if subject
+        (if (logand (= (f (f subject)) (f (f comp))) (= (r (f subject)) (r (f comp))))
+            (compare_first_pairs_against_flags (r subject) (r comp))
+            ()
+        )
+        1
+    )
+  )
+
+  (compare_first_pairs_against_flags FLAGS (merge_insertion_sort proofs))
+)

chia/wallet/vc_wallet/cr_puzzles/flag_proofs_checker.clsp.hex

@@ -0,0 +1 @@
+ff02ffff01ff02ff04ffff04ff02ffff04ff05ffff04ffff02ff0effff04ff02ffff04ff0bff80808080ff8080808080ffff04ffff01ffff02ffff03ff05ffff01ff02ffff03ffff18ffff09ff11ff2380ffff09ff19ff338080ffff01ff02ff04ffff04ff02ffff04ff0dffff04ff1bff8080808080ff8080ff0180ffff01ff010180ff0180ffff02ffff03ff0bffff01ff02ffff03ffff02ffff03ffff20ff0580ffff01ff0101ffff01ff02ffff03ffff0aff23ff1180ffff01ff0101ff8080ff018080ff0180ffff01ff02ff0affff04ff02ffff04ffff04ff13ff0580ffff04ff1bff8080808080ffff01ff02ff0affff04ff02ffff04ffff04ff09ffff02ff0affff04ff02ffff04ff0dffff04ffff04ff13ff8080ff808080808080ffff04ff1bff808080808080ff0180ffff010580ff0180ff02ffff03ff0dffff01ff02ff0affff04ff02ffff04ffff02ff0effff04ff02ffff04ff0dff80808080ffff04ffff02ff0effff04ff02ffff04ffff04ff09ff8080ff80808080ff8080808080ffff010580ff0180ff018080