chia-blockchain 2.5.1rc1__py3-none-any.whl

chia/wallet/puzzle_drivers.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Optional
+
+from clvm.casts import int_from_bytes
+from clvm.SExp import SExp
+from clvm_tools.binutils import assemble, type_for_atom
+from ir.Type import Type
+
+from chia.types.blockchain_format.program import Program
+
+"""
+The following two classes act as wrapper classes around dictionaries of strings.
+Values in the dictionary are assumed to be strings in CLVM format (0x for bytes, etc.)
+When you access a value in the dictionary, it will be deserialized to a str, int, bytes, or Program appropriately.
+"""
+
+
+@dataclass(frozen=True)
+class PuzzleInfo:
+    """
+    There are two 'magic' keys in a PuzzleInfo object:
+      - 'type' must be an included key (for easy lookup of drivers)
+      - 'also' gets its own method as it's the supported way to do recursion of PuzzleInfos
+    """
+
+    info: dict[str, Any]
+
+    def __post_init__(self) -> None:
+        if "type" not in self.info:
+            raise ValueError("A type is required to initialize a puzzle driver")
+
+    def __getitem__(self, item: str) -> Any:
+        value = self.info[item]
+        return decode_info_value(PuzzleInfo, value)
+
+    def __eq__(self, other: object) -> bool:
+        for key, value in self.info.items():
+            try:
+                if self[key] != other[key]:  # type: ignore
+                    return False
+            except Exception:
+                return False
+        return True
+
+    def __contains__(self, item: str) -> bool:
+        if item in self.info:
+            return True
+        else:
+            return False
+
+    def type(self) -> str:
+        return str(self.info["type"])
+
+    def also(self) -> Optional[PuzzleInfo]:
+        if "also" in self.info:
+            return PuzzleInfo(self.info["also"])
+        else:
+            return None
+
+    def check_type(self, types: list[str]) -> bool:
+        if types == []:
+            if self.also() is None:
+                return True
+            else:
+                return False
+        else:
+            if self.type() == types[0]:
+                types.pop(0)
+                if self.also():
+                    return self.also().check_type(types)  # type: ignore
+                else:
+                    return self.check_type(types)
+            else:
+                return False
+
+
+@dataclass(frozen=True)
+class Solver:
+    info: dict[str, Any]
+
+    def __getitem__(self, item: str) -> Any:
+        value = self.info[item]
+        return decode_info_value(Solver, value)
+
+    def __eq__(self, other: object) -> bool:
+        for key, value in self.info.items():
+            try:
+                if self[key] != other[key]:  # type: ignore
+                    return False
+            except Exception:
+                return False
+        return True
+
+
+def decode_info_value(cls: Any, value: Any) -> Any:
+    if isinstance(value, dict):
+        return cls(value)
+    elif isinstance(value, list):
+        return [decode_info_value(cls, v) for v in value]
+    elif isinstance(value, Program) and value.atom is None:
+        return value
+    else:
+        if value == "()":  # special case
+            return Program.to([])
+        expression: SExp = assemble(value)
+        if expression.atom is None:
+            return Program(expression)
+        else:
+            atom: bytes = expression.atom
+            typ = type_for_atom(atom)
+            if typ == Type.QUOTES and value[0:2] != "0x":
+                return bytes(atom).decode("utf8")
+            elif typ == Type.INT:
+                return int_from_bytes(atom)
+            else:
+                return atom

chia/wallet/puzzles/augmented_condition.clsp

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

chia/wallet/puzzles/augmented_condition.clsp.hex

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

chia/wallet/puzzles/clawback/drivers.py

@@ -0,0 +1,188 @@
+from __future__ import annotations
+
+import logging
+from typing import Any, Optional, Union
+
+from chia.consensus.default_constants import DEFAULT_CONSTANTS
+from chia.types.blockchain_format.coin import Coin
+from chia.types.blockchain_format.program import Program
+from chia.types.blockchain_format.serialized_program import SerializedProgram
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.coin_spend import CoinSpend, make_spend
+from chia.types.condition_opcodes import ConditionOpcode
+from chia.util.condition_tools import conditions_for_solution
+from chia.util.ints import uint64
+from chia.util.streamable import VersionedBlob
+from chia.wallet.puzzles.clawback.metadata import ClawbackMetadata
+from chia.wallet.puzzles.load_clvm import load_clvm_maybe_recompile
+from chia.wallet.puzzles.p2_delegated_puzzle_or_hidden_puzzle import MOD
+from chia.wallet.uncurried_puzzle import UncurriedPuzzle
+from chia.wallet.util.curry_and_treehash import calculate_hash_of_quoted_mod_hash, curry_and_treehash
+from chia.wallet.util.merkle_tree import MerkleTree
+from chia.wallet.util.wallet_types import RemarkDataType
+
+P2_1_OF_N = load_clvm_maybe_recompile("p2_1_of_n.clsp")
+P2_CURRIED_PUZZLE_MOD = load_clvm_maybe_recompile("p2_puzzle_hash.clsp")
+P2_CURRIED_PUZZLE_MOD_HASH_QUOTED = calculate_hash_of_quoted_mod_hash(P2_CURRIED_PUZZLE_MOD.get_tree_hash())
+AUGMENTED_CONDITION = load_clvm_maybe_recompile("augmented_condition.clsp")
+AUGMENTED_CONDITION_HASH = AUGMENTED_CONDITION.get_tree_hash()
+log = logging.getLogger(__name__)
+
+
+def create_augmented_cond_puzzle(condition: list[Union[int, uint64]], puzzle: Program) -> Program:
+    return AUGMENTED_CONDITION.curry(condition, puzzle)
+
+
+def create_augmented_cond_puzzle_hash(condition: list[Any], puzzle_hash: bytes32) -> bytes32:
+    hash_of_quoted_mod_hash = calculate_hash_of_quoted_mod_hash(AUGMENTED_CONDITION_HASH)
+    hashed_args = [Program.to(condition).get_tree_hash(), puzzle_hash]
+    return curry_and_treehash(hash_of_quoted_mod_hash, *hashed_args)
+
+
+def create_augmented_cond_solution(inner_solution: Program) -> Program:
+    solution: Program = Program.to([inner_solution])
+    return solution
+
+
+def create_p2_puzzle_hash_puzzle(puzzle_hash: bytes32) -> Program:
+    return P2_CURRIED_PUZZLE_MOD.curry(puzzle_hash)
+
+
+def create_p2_puzzle_hash_solution(inner_puzzle: Program, inner_solution: Program) -> Program:
+    solution: Program = Program.to([inner_puzzle, inner_solution])
+    return solution
+
+
+def create_clawback_merkle_tree(timelock: uint64, sender_ph: bytes32, recipient_ph: bytes32) -> MerkleTree:
+    """
+    Returns a merkle tree object
+    For clawbacks there are only 2 puzzles in the merkle tree, claim puzzle and clawback puzzle
+    """
+    if timelock < 1:
+        raise ValueError("Timelock must be at least 1 second")
+    timelock_condition = [ConditionOpcode.ASSERT_SECONDS_RELATIVE, timelock]
+    augmented_cond_puz_hash = create_augmented_cond_puzzle_hash(timelock_condition, recipient_ph)
+    merkle_tree = MerkleTree(
+        [
+            augmented_cond_puz_hash,
+            curry_and_treehash(P2_CURRIED_PUZZLE_MOD_HASH_QUOTED, Program.to(sender_ph).get_tree_hash()),
+        ]
+    )
+    return merkle_tree
+
+
+def create_merkle_proof(merkle_tree: MerkleTree, puzzle_hash: bytes32) -> Program:
+    """
+    To spend a p2_1_of_n clawback we recreate the full merkle tree
+    The required proof is then selected from the merkle tree based on the puzzle_hash of the puzzle we
+    want to execute
+    Returns a proof: (int, list[bytes32]) which can be provided to the p2_1_of_n solution
+    """
+    proof = merkle_tree.generate_proof(puzzle_hash)
+    program: Program = Program.to((proof[0], proof[1][0]))
+    return program
+
+
+def create_merkle_puzzle(timelock: uint64, sender_ph: bytes32, recipient_ph: bytes32) -> Program:
+    merkle_tree = create_clawback_merkle_tree(timelock, sender_ph, recipient_ph)
+    puzzle: Program = P2_1_OF_N.curry(merkle_tree.calculate_root())
+    return puzzle
+
+
+def create_merkle_solution(
+    timelock: uint64,
+    sender_ph: bytes32,
+    recipient_ph: bytes32,
+    inner_puzzle: Program,
+    inner_solution: Program,
+) -> Program:
+    """
+    Recreates the full merkle tree of a p2_1_of_n clawback coin. It uses the timelock and each party's
+    puzhash to create the tree.
+    The provided inner puzzle must hash to match either the sender or recipient puzhash
+    If it's the sender, then create the clawback solution. If it's the recipient then create the claim
+    solution.
+    Returns a program which is the solution to a p2_1_of_n clawback.
+    """
+    merkle_tree = create_clawback_merkle_tree(timelock, sender_ph, recipient_ph)
+    inner_puzzle_hash = inner_puzzle.get_tree_hash()
+    if inner_puzzle_hash == sender_ph:
+        cb_inner_puz = create_p2_puzzle_hash_puzzle(sender_ph)
+        merkle_proof = create_merkle_proof(merkle_tree, cb_inner_puz.get_tree_hash())
+        cb_inner_solution = create_p2_puzzle_hash_solution(inner_puzzle, inner_solution)
+    elif inner_puzzle_hash == recipient_ph:
+        condition = [80, timelock]
+        cb_inner_puz = create_augmented_cond_puzzle(condition, inner_puzzle)
+        merkle_proof = create_merkle_proof(merkle_tree, cb_inner_puz.get_tree_hash())
+        cb_inner_solution = create_augmented_cond_solution(inner_solution)
+    else:
+        raise ValueError("Invalid Clawback inner puzzle.")
+    solution: Program = Program.to([merkle_proof, cb_inner_puz, cb_inner_solution])
+    return solution
+
+
+def match_clawback_puzzle(
+    uncurried: UncurriedPuzzle,
+    inner_puzzle: Union[Program, SerializedProgram],
+    inner_solution: Union[Program, SerializedProgram],
+) -> Optional[ClawbackMetadata]:
+    # Check if the inner puzzle is a P2 puzzle
+    if MOD != uncurried.mod:
+        return None
+    if not isinstance(inner_puzzle, SerializedProgram):
+        inner_puzzle = SerializedProgram.from_program(inner_puzzle)
+    if not isinstance(inner_solution, SerializedProgram):
+        inner_solution = SerializedProgram.from_program(inner_solution)
+    # Fetch Remark condition
+    conditions = conditions_for_solution(
+        inner_puzzle,
+        inner_solution,
+        DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM // 8,
+    )
+    metadata: Optional[ClawbackMetadata] = None
+    new_puzhash: set[bytes32] = set()
+    if conditions is not None:
+        for condition in conditions:
+            if (
+                condition.opcode == ConditionOpcode.REMARK
+                and len(condition.vars) == 2
+                and int.from_bytes(condition.vars[0], "big") == RemarkDataType.CLAWBACK
+            ):
+                try:
+                    metadata = ClawbackMetadata.from_bytes(VersionedBlob.from_bytes(condition.vars[1]).blob)
+                except Exception:
+                    # Invalid Clawback metadata
+                    log.error(f"Invalid Clawback metadata {condition.vars[1].hex()}")
+                    return None
+            if condition.opcode == ConditionOpcode.CREATE_COIN:
+                new_puzhash.add(bytes32.from_bytes(condition.vars[0]))
+    # Check if the inner puzzle matches the coin puzzle hash
+    if metadata is None:
+        return metadata
+    puzzle: Program = create_merkle_puzzle(
+        metadata.time_lock, metadata.sender_puzzle_hash, metadata.recipient_puzzle_hash
+    )
+    if puzzle.get_tree_hash() not in new_puzhash:
+        # The metadata doesn't match the inner puzzle, ignore it
+        log.error(
+            f"Clawback metadata {metadata} doesn't match inner puzzle {inner_puzzle.get_tree_hash().hex()}"
+        )  # pragma: no cover
+        return None  # pragma: no cover
+    return metadata
+
+
+def generate_clawback_spend_bundle(
+    coin: Coin, metadata: ClawbackMetadata, inner_puzzle: Program, inner_solution: Program
+) -> CoinSpend:
+    time_lock: uint64 = metadata.time_lock
+    puzzle: Program = create_merkle_puzzle(time_lock, metadata.sender_puzzle_hash, metadata.recipient_puzzle_hash)
+    if puzzle.get_tree_hash() != coin.puzzle_hash:
+        raise ValueError(
+            f"Cannot spend merkle coin {coin.name()}, "
+            f"recreate puzzle hash {puzzle.get_tree_hash().hex()}, actual puzzle hash {coin.puzzle_hash.hex()}"
+        )
+
+    solution: Program = create_merkle_solution(
+        time_lock, metadata.sender_puzzle_hash, metadata.recipient_puzzle_hash, inner_puzzle, inner_solution
+    )
+    return make_spend(coin, puzzle, solution)

chia/wallet/puzzles/clawback/metadata.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import IntEnum
+
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.util.ints import uint16, uint64
+from chia.util.streamable import Streamable, streamable
+from chia.wallet.wallet_puzzle_store import WalletPuzzleStore
+
+
+@streamable
+@dataclass(frozen=True)
+class ClawbackMetadata(Streamable):
+    time_lock: uint64
+    sender_puzzle_hash: bytes32
+    recipient_puzzle_hash: bytes32
+
+    async def is_recipient(self, puzzle_store: WalletPuzzleStore) -> bool:
+        if await puzzle_store.puzzle_hash_exists(self.sender_puzzle_hash):
+            return False
+        elif await puzzle_store.puzzle_hash_exists(self.recipient_puzzle_hash):
+            return True
+        else:
+            raise ValueError("Both sender and recipient puzzle hashes not found in puzzle store")
+
+
+class ClawbackVersion(IntEnum):
+    V1 = uint16(1)
+
+
+@streamable
+@dataclass(frozen=True)
+class AutoClaimSettings(Streamable):
+    enabled: bool = False
+    tx_fee: uint64 = uint64(0)
+    min_amount: uint64 = uint64(0)
+    batch_size: uint16 = uint16(50)

chia/wallet/puzzles/clawback/puzzle_decorator.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from typing import Any
+
+from chia.types.blockchain_format.program import Program
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.condition_opcodes import ConditionOpcode
+from chia.util.ints import uint64
+from chia.util.streamable import VersionedBlob
+from chia.wallet.payment import Payment
+from chia.wallet.puzzles.clawback.drivers import create_merkle_puzzle
+from chia.wallet.puzzles.clawback.metadata import ClawbackMetadata, ClawbackVersion
+from chia.wallet.util.wallet_types import RemarkDataType
+
+
+class ClawbackPuzzleDecorator:
+    """
+    This class is a wrapper for clawback puzzles. It allows us to add Clawback characteristics to the inner puzzle.
+    """
+
+    time_lock: uint64
+
+    @staticmethod
+    def create(config: dict[str, Any]) -> ClawbackPuzzleDecorator:
+        self = ClawbackPuzzleDecorator()
+        self.time_lock = uint64(config.get("clawback_timelock", 0))
+        return self
+
+    def decorate(self, inner_puzzle: Program) -> Program:
+        # We don't wrap anything for the Clawback
+        return inner_puzzle
+
+    def decorate_target_puzzle_hash(
+        self,
+        inner_puzzle: Program,
+        target_puzzle_hash: bytes32,
+    ) -> tuple[Program, bytes32]:
+        return (
+            self.decorate(inner_puzzle),
+            create_merkle_puzzle(self.time_lock, inner_puzzle.get_tree_hash(), target_puzzle_hash).get_tree_hash(),
+        )
+
+    def solve(
+        self, inner_puzzle: Program, primaries: list[Payment], inner_solution: Program
+    ) -> tuple[Program, Program]:
+        # Append REMARK condition [1, "CLAWBACK", TIME_LOCK, SENDER_PUZHSAH, RECIPIENT_PUZHSAH]
+        if len(primaries) == 1:
+            recipient_puzhash = primaries[0].puzzle_hash
+            metadata = ClawbackMetadata(self.time_lock, inner_puzzle.get_tree_hash(), recipient_puzhash)
+            remark_condition = Program.to(
+                [
+                    ConditionOpcode.REMARK.value,
+                    RemarkDataType.CLAWBACK,
+                    bytes(VersionedBlob(ClawbackVersion.V1.value, bytes(metadata))),
+                ]
+            )
+            # Insert the REMARK condition into the condition list
+            conditions = remark_condition.cons(inner_solution.rest().first().rest())
+            conditions = inner_solution.rest().first().first().cons(conditions)
+            inner_solution = inner_solution.replace(rf=conditions)
+        return self.decorate(inner_puzzle), inner_solution
+
+    def decorate_memos(
+        self, inner_puzzle: Program, target_puzzle_hash: bytes32, memos: list[bytes]
+    ) -> tuple[Program, list[bytes]]:
+        memos.insert(0, target_puzzle_hash)
+        return self.decorate(inner_puzzle), memos

chia/wallet/puzzles/condition_codes.clib

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

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