chia-blockchain 2.4.4__py3-none-any.whl

chia/wallet/puzzles/load_clvm.py

@@ -0,0 +1,162 @@
+from __future__ import annotations
+
+import importlib
+import inspect
+import os
+import pathlib
+import sys
+import tempfile
+from typing import List
+
+import importlib_resources
+from clvm_tools_rs import compile_clvm as compile_clvm_rust
+
+from chia.types.blockchain_format.program import Program
+from chia.types.blockchain_format.serialized_program import SerializedProgram
+from chia.util.lock import Lockfile
+
+compile_clvm_py = None
+
+recompile_requested = (
+    (os.environ.get("CHIA_DEV_COMPILE_CLVM_ON_IMPORT", "") != "") or ("pytest" in sys.modules)
+) and os.environ.get("CHIA_DEV_COMPILE_CLVM_DISABLED", None) is None
+
+here_name = __name__.rpartition(".")[0]
+
+
+def translate_path(p_):
+    p = str(p_)
+    if os.path.isdir(p):
+        return p
+    else:
+        module_object = importlib.import_module(p)
+        return os.path.dirname(inspect.getfile(module_object))
+
+
+# Handle optional use of python clvm_tools if available and requested
+if "CLVM_TOOLS" in os.environ:
+    from clvm_tools.clvmc import compile_clvm as compile_clvm_py_candidate
+
+    compile_clvm_py = compile_clvm_py_candidate
+
+
+def compile_clvm_in_lock(full_path: pathlib.Path, output: pathlib.Path, search_paths: List[pathlib.Path]):
+    # Compile using rust (default)
+
+    # Ensure path translation is done in the idiomatic way currently
+    # expected.  It can use either a filesystem path or name a python
+    # module.
+    treated_include_paths = list(map(translate_path, search_paths))
+    res = compile_clvm_rust(str(full_path), str(output), treated_include_paths)
+
+    if "CLVM_TOOLS" in os.environ and os.environ["CLVM_TOOLS"] == "check" and compile_clvm_py is not None:
+        # Simple helper to read the compiled output
+        def sha256file(f):
+            import hashlib
+
+            m = hashlib.sha256()
+            with open(f) as open_file:
+                m.update(open_file.read().strip().encode("utf8"))
+            return m.hexdigest()
+
+        orig = f"{output}.orig"
+
+        compile_clvm_py(full_path, orig, search_paths=search_paths)
+        orig256 = sha256file(orig)
+        rs256 = sha256file(output)
+
+        if orig256 != rs256:
+            print(f"Compiled original {full_path}: {orig256} vs rust {rs256}\n")
+            print("Aborting compilation due to mismatch with rust")
+            assert orig256 == rs256
+        else:
+            print(f"Compilation match {full_path}: {orig256}\n")
+
+    return res
+
+
+def compile_clvm(full_path: pathlib.Path, output: pathlib.Path, search_paths: List[pathlib.Path] = []):
+    with Lockfile.create(pathlib.Path(tempfile.gettempdir()) / "clvm_compile" / full_path.name):
+        compile_clvm_in_lock(full_path, output, search_paths)
+
+
+def load_serialized_clvm(
+    clvm_filename, package_or_requirement=here_name, include_standard_libraries: bool = True, recompile: bool = True
+) -> SerializedProgram:
+    """
+    This function takes a .clsp file in the given package and compiles it to a
+    .clsp.hex file if the .hex file is missing or older than the .clsp file, then
+    returns the contents of the .hex file as a `Program`.
+
+    clvm_filename: file name
+    package_or_requirement: usually `__name__` if the clvm file is in the same package
+    """
+    hex_filename = f"{clvm_filename}.hex"
+
+    # Set the CHIA_DEV_COMPILE_CLVM_ON_IMPORT environment variable to anything except
+    # "" or "0" to trigger automatic recompilation of the Chialisp on load.
+    resources = importlib_resources.files(package_or_requirement)
+    if recompile and not getattr(sys, "frozen", False):
+        full_path = resources.joinpath(clvm_filename)
+        if full_path.exists():
+            # Establish whether the size is zero on entry
+            output = full_path.parent / hex_filename
+            if not output.exists() or os.stat(full_path).st_mtime > os.stat(output).st_mtime:
+                search_paths = [full_path.parent]
+                if include_standard_libraries:
+                    # we can't get the dir, but we can get a file then get its parent.
+                    chia_puzzles_path = pathlib.Path(__file__).parent
+                    search_paths.append(chia_puzzles_path)
+                compile_clvm(full_path, output, search_paths=search_paths)
+
+    clvm_path = resources.joinpath(hex_filename)
+    clvm_hex = clvm_path.read_text(encoding="utf-8")
+    assert len(clvm_hex.strip()) != 0
+    clvm_blob = bytes.fromhex(clvm_hex)
+    return SerializedProgram.from_bytes(clvm_blob)
+
+
+def load_clvm(
+    clvm_filename,
+    package_or_requirement=here_name,
+    include_standard_libraries: bool = True,
+    recompile: bool = True,
+) -> Program:
+    return Program.from_bytes(
+        bytes(
+            load_serialized_clvm(
+                clvm_filename,
+                package_or_requirement=package_or_requirement,
+                include_standard_libraries=include_standard_libraries,
+                recompile=recompile,
+            )
+        )
+    )
+
+
+def load_clvm_maybe_recompile(
+    clvm_filename,
+    package_or_requirement=here_name,
+    include_standard_libraries: bool = True,
+    recompile: bool = recompile_requested,
+) -> Program:
+    return load_clvm(
+        clvm_filename=clvm_filename,
+        package_or_requirement=package_or_requirement,
+        include_standard_libraries=include_standard_libraries,
+        recompile=recompile,
+    )
+
+
+def load_serialized_clvm_maybe_recompile(
+    clvm_filename,
+    package_or_requirement=here_name,
+    include_standard_libraries: bool = True,
+    recompile: bool = recompile_requested,
+) -> SerializedProgram:
+    return load_serialized_clvm(
+        clvm_filename=clvm_filename,
+        package_or_requirement=package_or_requirement,
+        include_standard_libraries=include_standard_libraries,
+        recompile=recompile,
+    )

chia/wallet/puzzles/merkle_utils.clib

@@ -0,0 +1,18 @@
+(
+  (defun simplify_merkle_proof_after_leaf (leaf_hash (bitpath . hashes_path))
+    (if hashes_path
+        (simplify_merkle_proof_after_leaf
+          (if (logand 1 bitpath)
+              (sha256 0x02 (f hashes_path) leaf_hash)
+              (sha256 0x02 leaf_hash (f hashes_path))
+          )
+          (c (lsh bitpath -1) (r hashes_path))
+        )
+        leaf_hash
+    )
+  )
+
+  (defun-inline simplify_merkle_proof (leaf proof)
+    (simplify_merkle_proof_after_leaf (sha256 0x01 leaf) proof)
+  )
+)

chia/wallet/puzzles/notification.clsp

@@ -0,0 +1,7 @@
+(mod (
+    TARGET
+    AMOUNT
+  )
+  (include condition_codes.clib)
+  (list (list CREATE_COIN TARGET AMOUNT) (list CREATE_COIN_ANNOUNCEMENT ()))
+)

chia/wallet/puzzles/notification.clsp.hex

@@ -0,0 +1 @@
+ff02ffff01ff04ffff04ff04ffff04ff05ffff04ff0bff80808080ffff04ffff04ff06ffff01ff808080ff808080ffff04ffff01ff333cff018080

chia/wallet/puzzles/p2_1_of_n.clsp

@@ -0,0 +1,22 @@
+(mod
+  (
+    MERKLE_ROOT
+    merkle_proof
+    puzzle_to_execute
+    inner_solution
+  )
+
+  (include utility_macros.clib)
+  (include merkle_utils.clib)
+
+  ; 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)))
+
+  (assert (= MERKLE_ROOT (simplify_merkle_proof (sha256tree puzzle_to_execute) merkle_proof))
+    (a puzzle_to_execute inner_solution)
+  )
+
+)

chia/wallet/puzzles/p2_1_of_n.clsp.hex

@@ -0,0 +1 @@
+ff02ffff01ff02ffff03ffff09ff05ffff02ff06ffff04ff02ffff04ffff0bffff0101ffff02ff04ffff04ff02ffff04ff17ff8080808080ffff04ff0bff808080808080ffff01ff02ff17ff2f80ffff01ff088080ff0180ffff04ffff01ffff02ffff03ffff07ff0580ffff01ff0bffff0102ffff02ff04ffff04ff02ffff04ff09ff80808080ffff02ff04ffff04ff02ffff04ff0dff8080808080ffff01ff0bffff0101ff058080ff0180ff02ffff03ff1bffff01ff02ff06ffff04ff02ffff04ffff02ffff03ffff18ffff0101ff1380ffff01ff0bffff0102ff2bff0580ffff01ff0bffff0102ff05ff2b8080ff0180ffff04ffff04ffff17ff13ffff0181ff80ff3b80ff8080808080ffff010580ff0180ff018080

chia/wallet/puzzles/p2_conditions.clsp

@@ -0,0 +1,3 @@
+(mod (conditions)
+  (qq (q . (unquote conditions)))
+)

chia/wallet/puzzles/p2_conditions.clsp.hex

@@ -0,0 +1 @@
+ff04ffff0101ff0280

chia/wallet/puzzles/p2_conditions.py

@@ -0,0 +1,27 @@
+"""
+Pay to conditions
+
+In this puzzle program, the solution is ignored. The reveal of the puzzle
+returns a fixed list of conditions. This roughly corresponds to OP_SECURETHEBAG
+in bitcoin.
+
+This is a pretty useless most of the time. But some (most?) solutions
+require a delegated puzzle program, so in those cases, this is just what
+the doctor ordered.
+"""
+
+from __future__ import annotations
+
+from chia.types.blockchain_format.program import Program
+
+from .load_clvm import load_clvm_maybe_recompile
+
+MOD = load_clvm_maybe_recompile("p2_conditions.clsp")
+
+
+def puzzle_for_conditions(conditions) -> Program:
+    return MOD.run([conditions])
+
+
+def solution_for_conditions(conditions) -> Program:
+    return Program.to([puzzle_for_conditions(conditions), 0])

chia/wallet/puzzles/p2_delegated_conditions.clsp

@@ -0,0 +1,18 @@
+(mod
+  (public_key conditions)
+
+  (include condition_codes.clib)
+
+  ;; hash a tree
+  ;; This is used to calculate a puzzle hash given a puzzle program.
+  (defun sha256tree1
+    (TREE)
+    (if (l TREE)
+        (sha256 2 (sha256tree1 (f TREE)) (sha256tree1 (r TREE)))
+        (sha256 1 TREE)
+    )
+  )
+
+  (c (list AGG_SIG_ME public_key (sha256tree1 conditions)) conditions)
+
+)

chia/wallet/puzzles/p2_delegated_conditions.clsp.hex

@@ -0,0 +1 @@
+ff02ffff01ff04ffff04ff04ffff04ff05ffff04ffff02ff06ffff04ff02ffff04ff0bff80808080ff80808080ff0b80ffff04ffff01ff32ff02ffff03ffff07ff0580ffff01ff0bffff0102ffff02ff06ffff04ff02ffff04ff09ff80808080ffff02ff06ffff04ff02ffff04ff0dff8080808080ffff01ff0bffff0101ff058080ff0180ff018080

chia/wallet/puzzles/p2_delegated_conditions.py

@@ -0,0 +1,22 @@
+"""
+Pay to delegated conditions
+
+In this puzzle program, the solution must be a signed list of conditions, which
+is returned literally.
+"""
+
+from __future__ import annotations
+
+from chia.types.blockchain_format.program import Program
+
+from .load_clvm import load_clvm_maybe_recompile
+
+MOD = load_clvm_maybe_recompile("p2_delegated_conditions.clsp")
+
+
+def puzzle_for_pk(public_key: Program) -> Program:
+    return MOD.curry(public_key)
+
+
+def solution_for_conditions(conditions: Program) -> Program:
+    return conditions.to([conditions])

chia/wallet/puzzles/p2_delegated_puzzle.clsp

@@ -0,0 +1,19 @@
+(mod
+
+  (public_key delegated_puzzle delegated_puzzle_solution)
+
+  (include condition_codes.clib)
+
+  ;; hash a tree
+  ;; This is used to calculate a puzzle hash given a puzzle program.
+  (defun sha256tree1
+    (TREE)
+    (if (l TREE)
+        (sha256 2 (sha256tree1 (f TREE)) (sha256tree1 (r TREE)))
+        (sha256 1 TREE)
+    )
+  )
+
+  (c (list AGG_SIG_ME public_key (sha256tree1 delegated_puzzle))
+  (a delegated_puzzle delegated_puzzle_solution))
+)

chia/wallet/puzzles/p2_delegated_puzzle.clsp.hex

@@ -0,0 +1 @@
+ff02ffff01ff04ffff04ff04ffff04ff05ffff04ffff02ff06ffff04ff02ffff04ff0bff80808080ff80808080ffff02ff0bff178080ffff04ffff01ff32ff02ffff03ffff07ff0580ffff01ff0bffff0102ffff02ff06ffff04ff02ffff04ff09ff80808080ffff02ff06ffff04ff02ffff04ff0dff8080808080ffff01ff0bffff0101ff058080ff0180ff018080

chia/wallet/puzzles/p2_delegated_puzzle.py

@@ -0,0 +1,35 @@
+"""
+Pay to delegated puzzle
+
+In this puzzle program, the solution must be a signed delegated puzzle, along with
+its (unsigned) solution. The delegated puzzle is executed, passing in the solution.
+This obviously could be done recursively, arbitrarily deep (as long as the maximum
+cost is not exceeded).
+
+If you want to specify the conditions directly (thus terminating the potential recursion),
+you can use p2_conditions.
+
+This roughly corresponds to bitcoin's graftroot.
+"""
+
+from __future__ import annotations
+
+from chia.types.blockchain_format.program import Program
+
+from . import p2_conditions
+from .load_clvm import load_clvm_maybe_recompile
+
+MOD = load_clvm_maybe_recompile("p2_delegated_puzzle.clsp")
+
+
+def puzzle_for_pk(public_key: bytes) -> Program:
+    return MOD.curry(public_key)
+
+
+def solution_for_conditions(conditions) -> Program:
+    delegated_puzzle = p2_conditions.puzzle_for_conditions(conditions)
+    return solution_for_delegated_puzzle(delegated_puzzle, Program.to(0))
+
+
+def solution_for_delegated_puzzle(delegated_puzzle: Program, delegated_solution: Program) -> Program:
+    return delegated_puzzle.to([delegated_puzzle, delegated_solution])

chia/wallet/puzzles/p2_delegated_puzzle_or_hidden_puzzle.clsp

@@ -0,0 +1,91 @@
+; build a pay-to delegated puzzle or hidden puzzle
+; coins can be unlocked by signing a delegated puzzle and its solution
+; OR by revealing the hidden puzzle and the underlying original key
+
+; glossary of parameter names:
+
+; hidden_puzzle: a "hidden puzzle" that can be revealed and used as an alternate
+;   way to unlock the underlying funds
+;
+; synthetic_key_offset: a private key cryptographically generated using the hidden
+;   puzzle and as inputs `original_public_key`
+;
+; SYNTHETIC_PUBLIC_KEY: the public key that is the sum of `original_public_key` and the
+;   public key corresponding to `synthetic_key_offset`
+;
+; original_public_key: a public key, where knowledge of the corresponding private key
+;   represents ownership of the file
+;
+; delegated_puzzle: a delegated puzzle, as in "graftroot", which should return the
+;   desired conditions.
+;
+; solution: the solution to the delegated puzzle
+
+
+(mod
+  ; A puzzle should commit to `SYNTHETIC_PUBLIC_KEY`
+  ;
+  ; The solution should pass in 0 for `original_public_key` if it wants to use
+  ; an arbitrary `delegated_puzzle` (and `solution`) signed by the
+  ; `SYNTHETIC_PUBLIC_KEY` (whose corresponding private key can be calculated
+  ; if you know the private key for `original_public_key`)
+  ;
+  ; Or you can solve the hidden puzzle by revealing the `original_public_key`,
+  ; the hidden puzzle in `delegated_puzzle`, and a solution to the hidden puzzle.
+
+  (SYNTHETIC_PUBLIC_KEY original_public_key delegated_puzzle solution)
+
+  ; "assert" is a macro that wraps repeated instances of "if"
+  ; usage: (assert A0 A1 ... An R)
+  ; all of A0, A1, ... An must evaluate to non-null, or an exception is raised
+  ; return the value of R (if we get that far)
+
+  (defmacro assert items
+    (if (r items)
+        (list if (f items) (c assert (r items)) (q . (x)))
+        (f items)
+    )
+  )
+
+  (include condition_codes.clib)
+
+  ;; hash a tree
+  ;; This is used to calculate a puzzle hash given a puzzle program.
+  (defun sha256tree1
+    (TREE)
+    (if (l TREE)
+        (sha256 2 (sha256tree1 (f TREE)) (sha256tree1 (r TREE)))
+        (sha256 1 TREE)
+    )
+  )
+
+  ; "is_hidden_puzzle_correct" returns true iff the hidden puzzle is correctly encoded
+
+  (defun-inline is_hidden_puzzle_correct (SYNTHETIC_PUBLIC_KEY original_public_key delegated_puzzle)
+    (=
+      SYNTHETIC_PUBLIC_KEY
+      (point_add
+        original_public_key
+        (pubkey_for_exp (sha256 original_public_key (sha256tree1 delegated_puzzle)))
+      )
+    )
+  )
+
+  ; "possibly_prepend_aggsig" is the main entry point
+
+  (defun-inline possibly_prepend_aggsig (SYNTHETIC_PUBLIC_KEY original_public_key delegated_puzzle conditions)
+    (if original_public_key
+        (assert
+          (is_hidden_puzzle_correct SYNTHETIC_PUBLIC_KEY original_public_key delegated_puzzle)
+          conditions
+        )
+        (c (list AGG_SIG_ME SYNTHETIC_PUBLIC_KEY (sha256tree1 delegated_puzzle)) conditions)
+    )
+  )
+
+  ; main entry point
+
+  (possibly_prepend_aggsig
+    SYNTHETIC_PUBLIC_KEY original_public_key delegated_puzzle
+  (a delegated_puzzle solution))
+)

chia/wallet/puzzles/p2_delegated_puzzle_or_hidden_puzzle.clsp.hex

@@ -0,0 +1 @@
+ff02ffff01ff02ffff03ff0bffff01ff02ffff03ffff09ff05ffff1dff0bffff1effff0bff0bffff02ff06ffff04ff02ffff04ff17ff8080808080808080ffff01ff02ff17ff2f80ffff01ff088080ff0180ffff01ff04ffff04ff04ffff04ff05ffff04ffff02ff06ffff04ff02ffff04ff17ff80808080ff80808080ffff02ff17ff2f808080ff0180ffff04ffff01ff32ff02ffff03ffff07ff0580ffff01ff0bffff0102ffff02ff06ffff04ff02ffff04ff09ff80808080ffff02ff06ffff04ff02ffff04ff0dff8080808080ffff01ff0bffff0101ff058080ff0180ff018080

chia/wallet/puzzles/p2_delegated_puzzle_or_hidden_puzzle.py

@@ -0,0 +1,161 @@
+"""
+Pay to delegated puzzle or hidden puzzle
+
+In this puzzle program, the solution must choose either a hidden puzzle or a
+delegated puzzle on a given public key.
+
+The given public key is morphed by adding an offset from the hash of the hidden puzzle
+and itself, giving a new so-called "synthetic" public key which has the hidden puzzle
+hidden inside of it.
+
+If the hidden puzzle path is taken, the hidden puzzle and original public key will be revealed
+which proves that it was hidden there in the first place.
+
+This roughly corresponds to bitcoin's taproot.
+
+Note:
+
+p2_delegated_puzzle_or_hidden_puzzle is essentially the "standard coin" in chia.
+DEFAULT_HIDDEN_PUZZLE_HASH from this puzzle is used with
+calculate_synthetic_secret_key in the wallet's standard pk_to_sk finder.
+
+This is important because it allows sign_coin_spends to function properly via the
+following mechanism:
+
+- A 'standard coin' coin exists in the blockchain with some puzzle hash.
+
+- The user's wallet contains a primary sk/pk pair which are used to derive to one
+  level a set of auxiliary sk/pk pairs which are used for specific coins. These
+  can be used for signing in AGG_SIG_ME, but the standard coin uses a key further
+  derived from one of these via calculate_synthetic_secret_key as described in
+  https://chialisp.com/docs/standard_transaction. Therefore, when a wallet needs
+  to find a secret key for signing based on a public key, it needs to try repeating
+  this derivation as well and see if the G1Element (pk) associated with any of the
+  derived secret keys matches the pk requested by the coin.
+
+- Python code previously appeared which was written like:
+
+    delegated_puzzle_solution = Program.to((1, condition_args))
+    solutions = Program.to([[], delgated_puzzle_solution, []])
+
+  In context, delegated_puzzle_solution here is any *chialisp program*, here one
+  simply quoting a list of conditions, and the following argument is the arguments
+  to this program, which here are unused. Secondly, the actual arguments to the
+  p2_delegated_puzzle_or_hidden_puzzle are given. The first argument determines
+  whether a hidden or revealed puzzle is used. If the puzzle is hidden, then what
+  is required is a signature given a specific synthetic key since the key cannot be
+  derived inline without the puzzle. In that case, the first argument is this key.
+  In most cases, the puzzle will be revealed, and this argument will be the nil object,
+  () (represented here by an empty python list).
+
+  The second and third arguments are a chialisp program and its corresponding
+  arguments, which will be run inside the standard coin puzzle. This interacts with
+  sign_coin_spend in that the AGG_SIG_ME condition added by the inner puzzle asks the
+  surrounding system to provide a signature over the provided program with a synthetic
+  key whose derivation is within. Any wallets which intend to use standard coins in
+  this way must try to resolve a public key to a secret key via this derivation.
+"""
+
+from __future__ import annotations
+
+import hashlib
+from functools import lru_cache
+from typing import Union
+
+from chia_rs import G1Element, PrivateKey
+from clvm.casts import int_from_bytes
+
+from chia.types.blockchain_format.program import Program
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.wallet.util.curry_and_treehash import calculate_hash_of_quoted_mod_hash, curry_and_treehash, shatree_atom
+
+from .load_clvm import load_clvm_maybe_recompile
+from .p2_conditions import puzzle_for_conditions
+
+DEFAULT_HIDDEN_PUZZLE = Program.from_bytes(bytes.fromhex("ff0980"))
+
+DEFAULT_HIDDEN_PUZZLE_HASH = DEFAULT_HIDDEN_PUZZLE.get_tree_hash()  # this puzzle `(x)` always fails
+
+MOD = load_clvm_maybe_recompile("p2_delegated_puzzle_or_hidden_puzzle.clsp")
+
+QUOTED_MOD_HASH = calculate_hash_of_quoted_mod_hash(MOD.get_tree_hash())
+
+PublicKeyProgram = Union[bytes, Program]
+
+GROUP_ORDER = 0x73EDA753299D7D483339D80809A1D80553BDA402FFFE5BFEFFFFFFFF00000001
+
+
+def calculate_synthetic_offset(public_key: G1Element, hidden_puzzle_hash: bytes32) -> int:
+    blob = hashlib.sha256(bytes(public_key) + hidden_puzzle_hash).digest()
+    offset = int_from_bytes(blob)
+    offset %= GROUP_ORDER
+    return offset
+
+
+@lru_cache(maxsize=1000)
+def calculate_synthetic_public_key(public_key: G1Element, hidden_puzzle_hash: bytes32) -> G1Element:
+    synthetic_offset: PrivateKey = PrivateKey.from_bytes(
+        calculate_synthetic_offset(public_key, hidden_puzzle_hash).to_bytes(32, "big")
+    )
+    return public_key + synthetic_offset.get_g1()
+
+
+@lru_cache(maxsize=1000)
+def calculate_synthetic_secret_key(secret_key: PrivateKey, hidden_puzzle_hash: bytes32) -> PrivateKey:
+    secret_exponent = int.from_bytes(bytes(secret_key), "big")
+    public_key = secret_key.get_g1()
+    synthetic_offset = calculate_synthetic_offset(public_key, hidden_puzzle_hash)
+    synthetic_secret_exponent = (secret_exponent + synthetic_offset) % GROUP_ORDER
+    blob = synthetic_secret_exponent.to_bytes(32, "big")
+    synthetic_secret_key = PrivateKey.from_bytes(blob)
+    return synthetic_secret_key
+
+
+def puzzle_for_synthetic_public_key(synthetic_public_key: G1Element) -> Program:
+    return MOD.curry(bytes(synthetic_public_key))
+
+
+def puzzle_hash_for_synthetic_public_key(synthetic_public_key: G1Element) -> bytes32:
+    public_key_hash = shatree_atom(bytes(synthetic_public_key))
+    return curry_and_treehash(QUOTED_MOD_HASH, public_key_hash)
+
+
+def puzzle_for_public_key_and_hidden_puzzle_hash(public_key: G1Element, hidden_puzzle_hash: bytes32) -> Program:
+    synthetic_public_key = calculate_synthetic_public_key(public_key, hidden_puzzle_hash)
+
+    return puzzle_for_synthetic_public_key(synthetic_public_key)
+
+
+def puzzle_hash_for_public_key_and_hidden_puzzle_hash(public_key: G1Element, hidden_puzzle_hash: bytes32) -> bytes32:
+    synthetic_public_key = calculate_synthetic_public_key(public_key, hidden_puzzle_hash)
+
+    return puzzle_hash_for_synthetic_public_key(synthetic_public_key)
+
+
+def puzzle_for_public_key_and_hidden_puzzle(public_key: G1Element, hidden_puzzle: Program) -> Program:
+    return puzzle_for_public_key_and_hidden_puzzle_hash(public_key, hidden_puzzle.get_tree_hash())
+
+
+def puzzle_for_pk(public_key: G1Element) -> Program:
+    return puzzle_for_public_key_and_hidden_puzzle_hash(public_key, DEFAULT_HIDDEN_PUZZLE_HASH)
+
+
+def puzzle_hash_for_pk(public_key: G1Element) -> bytes32:
+    return puzzle_hash_for_public_key_and_hidden_puzzle_hash(public_key, DEFAULT_HIDDEN_PUZZLE_HASH)
+
+
+def solution_for_delegated_puzzle(delegated_puzzle: Program, solution: Program) -> Program:
+    return Program.to([[], delegated_puzzle, solution])
+
+
+def solution_for_hidden_puzzle(
+    hidden_public_key: G1Element,
+    hidden_puzzle: Program,
+    solution_to_hidden_puzzle: Program,
+) -> Program:
+    return Program.to([hidden_public_key, hidden_puzzle, solution_to_hidden_puzzle])
+
+
+def solution_for_conditions(conditions) -> Program:
+    delegated_puzzle = puzzle_for_conditions(conditions)
+    return solution_for_delegated_puzzle(delegated_puzzle, Program.to(0))