chia-blockchain 2.4.4__py3-none-any.whl

chia/wallet/transaction_sorting.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+import enum
+
+
+class SortKey(enum.Enum):
+    CONFIRMED_AT_HEIGHT = "ORDER BY confirmed_at_height {ASC}"
+    RELEVANCE = "ORDER BY confirmed {ASC}, confirmed_at_height {DESC}, created_at_time {DESC}"
+
+    def ascending(self) -> str:
+        return self.value.format(ASC="ASC", DESC="DESC")
+
+    def descending(self) -> str:
+        return self.value.format(ASC="DESC", DESC="ASC")

chia/wallet/uncurried_puzzle.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Union
+
+from chia.types.blockchain_format.program import Program
+from chia.types.blockchain_format.serialized_program import SerializedProgram
+
+
+@dataclass(frozen=True)
+class UncurriedPuzzle:
+    mod: Program
+    args: Program
+
+
+def uncurry_puzzle(puzzle: Union[Program, SerializedProgram]) -> UncurriedPuzzle:
+    return UncurriedPuzzle(*puzzle.uncurry())

chia/wallet/util/address_type.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+from enum import Enum
+from typing import Any, Dict, Set
+
+from chia.util.bech32m import bech32_decode, convertbits
+from chia.util.config import selected_network_address_prefix
+
+
+class AddressType(Enum):
+    XCH = "xch"
+    NFT = "nft"
+    DID = "did:chia:"
+
+    def hrp(self, config: Dict[str, Any]) -> str:
+        if self == AddressType.XCH:
+            # Special case to map XCH to the current network's address prefix
+            return selected_network_address_prefix(config)
+        return str(self.value)
+
+    def expected_decoded_length(self) -> int:
+        # Current address types encode 32 bytes. If future address types vary in
+        # their length, this will need to be updated.
+        return 32
+
+
+def is_valid_address(address: str, allowed_types: Set[AddressType], config: Dict[str, Any]) -> bool:
+    try:
+        ensure_valid_address(address, allowed_types=allowed_types, config=config)
+        return True
+    except ValueError:
+        return False
+
+
+def ensure_valid_address(address: str, *, allowed_types: Set[AddressType], config: Dict[str, Any]) -> str:
+    hrp, b32data = bech32_decode(address)
+    if not b32data or not hrp:
+        raise ValueError(f"Invalid address: {address}")
+    # Match by prefix (hrp) and return the corresponding address type
+    address_type = next(
+        (addr_type for (addr_type, addr_hrp) in ((a, a.hrp(config)) for a in allowed_types) if addr_hrp == hrp),
+        None,
+    )
+    if address_type is None:
+        raise ValueError(
+            f"Invalid address: {address}. "
+            f"Expected an address with one of the following prefixes: {[t.hrp(config) for t in allowed_types]}"
+        )
+    decoded_data = convertbits(b32data, 5, 8, False)
+    if len(decoded_data) != address_type.expected_decoded_length():
+        raise ValueError(
+            f"Invalid address: {address}. "
+            f"Expected {address_type.expected_decoded_length()} bytes, got {len(decoded_data)}"
+        )
+    return address

chia/wallet/util/blind_signer_tl.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import List
+
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.util.ints import uint64
+from chia.util.streamable import Streamable
+from chia.wallet.signer_protocol import (
+    KeyHints,
+    PathHint,
+    SigningInstructions,
+    SigningResponse,
+    SigningTarget,
+    SumHint,
+    TransactionInfo,
+    UnsignedTransaction,
+)
+from chia.wallet.util.clvm_streamable import TranslationLayer, TranslationLayerMapping, clvm_streamable
+
+# Pylint doesn't understand that these classes are in fact dataclasses
+# pylint: disable=invalid-field-call
+
+
+@clvm_streamable
+@dataclass(frozen=True)
+class BSTLSigningTarget(Streamable):
+    fingerprint: bytes = field(metadata=dict(key="f"))
+    message: bytes = field(metadata=dict(key="m"))
+    hook: bytes32 = field(metadata=dict(key="h"))
+
+    @staticmethod
+    def from_wallet_api(_from: SigningTarget) -> BSTLSigningTarget:
+        return BSTLSigningTarget(**_from.__dict__)
+
+    @staticmethod
+    def to_wallet_api(_from: BSTLSigningTarget) -> SigningTarget:
+        return SigningTarget(**_from.__dict__)
+
+
+@clvm_streamable
+@dataclass(frozen=True)
+class BSTLSumHint(Streamable):
+    fingerprints: List[bytes] = field(metadata=dict(key="f"))
+    synthetic_offset: bytes = field(metadata=dict(key="o"))
+    final_pubkey: bytes = field(metadata=dict(key="p"))
+
+    @staticmethod
+    def from_wallet_api(_from: SumHint) -> BSTLSumHint:
+        return BSTLSumHint(**_from.__dict__)
+
+    @staticmethod
+    def to_wallet_api(_from: BSTLSumHint) -> SumHint:
+        return SumHint(**_from.__dict__)
+
+
+@clvm_streamable
+@dataclass(frozen=True)
+class BSTLPathHint(Streamable):
+    root_fingerprint: bytes = field(metadata=dict(key="f"))
+    path: List[uint64] = field(metadata=dict(key="p"))
+
+    @staticmethod
+    def from_wallet_api(_from: PathHint) -> BSTLPathHint:
+        return BSTLPathHint(**_from.__dict__)
+
+    @staticmethod
+    def to_wallet_api(_from: BSTLPathHint) -> PathHint:
+        return PathHint(**_from.__dict__)
+
+
+@clvm_streamable
+@dataclass(frozen=True)
+class BSTLSigningInstructions(Streamable):
+    sum_hints: List[BSTLSumHint] = field(metadata=dict(key="s"))
+    path_hints: List[BSTLPathHint] = field(metadata=dict(key="p"))
+    targets: List[BSTLSigningTarget] = field(metadata=dict(key="t"))
+
+    @staticmethod
+    def from_wallet_api(_from: SigningInstructions) -> BSTLSigningInstructions:
+        return BSTLSigningInstructions(
+            [BSTLSumHint.from_wallet_api(sum_hint) for sum_hint in _from.key_hints.sum_hints],
+            [BSTLPathHint.from_wallet_api(path_hint) for path_hint in _from.key_hints.path_hints],
+            [BSTLSigningTarget.from_wallet_api(signing_target) for signing_target in _from.targets],
+        )
+
+    @staticmethod
+    def to_wallet_api(_from: BSTLSigningInstructions) -> SigningInstructions:
+        return SigningInstructions(
+            KeyHints(
+                [BSTLSumHint.to_wallet_api(sum_hint) for sum_hint in _from.sum_hints],
+                [BSTLPathHint.to_wallet_api(path_hint) for path_hint in _from.path_hints],
+            ),
+            [BSTLSigningTarget.to_wallet_api(signing_target) for signing_target in _from.targets],
+        )
+
+
+@clvm_streamable
+@dataclass(frozen=True)
+class BSTLUnsignedTransaction(Streamable):
+    sum_hints: List[BSTLSumHint] = field(metadata=dict(key="s"))
+    path_hints: List[BSTLPathHint] = field(metadata=dict(key="p"))
+    targets: List[BSTLSigningTarget] = field(metadata=dict(key="t"))
+
+    @staticmethod
+    def from_wallet_api(_from: UnsignedTransaction) -> BSTLUnsignedTransaction:
+        return BSTLUnsignedTransaction(
+            [BSTLSumHint.from_wallet_api(sum_hint) for sum_hint in _from.signing_instructions.key_hints.sum_hints],
+            [BSTLPathHint.from_wallet_api(path_hint) for path_hint in _from.signing_instructions.key_hints.path_hints],
+            [
+                BSTLSigningTarget.from_wallet_api(signing_target)
+                for signing_target in _from.signing_instructions.targets
+            ],
+        )
+
+    @staticmethod
+    def to_wallet_api(_from: BSTLUnsignedTransaction) -> UnsignedTransaction:
+        return UnsignedTransaction(
+            TransactionInfo([]),
+            SigningInstructions(
+                KeyHints(
+                    [BSTLSumHint.to_wallet_api(sum_hint) for sum_hint in _from.sum_hints],
+                    [BSTLPathHint.to_wallet_api(path_hint) for path_hint in _from.path_hints],
+                ),
+                [BSTLSigningTarget.to_wallet_api(signing_target) for signing_target in _from.targets],
+            ),
+        )
+
+
+@clvm_streamable
+@dataclass(frozen=True)
+class BSTLSigningResponse(Streamable):
+    signature: bytes = field(metadata=dict(key="s"))
+    hook: bytes32 = field(metadata=dict(key="h"))
+
+    @staticmethod
+    def from_wallet_api(_from: SigningResponse) -> BSTLSigningResponse:
+        return BSTLSigningResponse(**_from.__dict__)
+
+    @staticmethod
+    def to_wallet_api(_from: BSTLSigningResponse) -> SigningResponse:
+        return SigningResponse(**_from.__dict__)
+
+
+BLIND_SIGNER_TRANSLATION = TranslationLayer(
+    [
+        TranslationLayerMapping(
+            SigningTarget, BSTLSigningTarget, BSTLSigningTarget.from_wallet_api, BSTLSigningTarget.to_wallet_api
+        ),
+        TranslationLayerMapping(SumHint, BSTLSumHint, BSTLSumHint.from_wallet_api, BSTLSumHint.to_wallet_api),
+        TranslationLayerMapping(PathHint, BSTLPathHint, BSTLPathHint.from_wallet_api, BSTLPathHint.to_wallet_api),
+        TranslationLayerMapping(
+            SigningInstructions,
+            BSTLSigningInstructions,
+            BSTLSigningInstructions.from_wallet_api,
+            BSTLSigningInstructions.to_wallet_api,
+        ),
+        TranslationLayerMapping(
+            SigningResponse, BSTLSigningResponse, BSTLSigningResponse.from_wallet_api, BSTLSigningResponse.to_wallet_api
+        ),
+        TranslationLayerMapping(
+            UnsignedTransaction,
+            BSTLUnsignedTransaction,
+            BSTLUnsignedTransaction.from_wallet_api,
+            BSTLUnsignedTransaction.to_wallet_api,
+        ),
+    ]
+)

chia/wallet/util/clvm_streamable.py

@@ -0,0 +1,203 @@
+from __future__ import annotations
+
+import dataclasses
+import functools
+from types import MappingProxyType
+from typing import Any, Callable, Dict, Generic, List, Optional, Type, TypeVar, Union, get_args, get_type_hints
+
+from hsms.clvm_serde import from_program_for_type, to_program_for_type
+from typing_extensions import TypeGuard
+
+from chia.types.blockchain_format.program import Program
+from chia.util.streamable import (
+    Streamable,
+    function_to_convert_one_item,
+    is_type_List,
+    is_type_SpecificOptional,
+    is_type_Tuple,
+    recurse_jsonify,
+    streamable,
+)
+
+_T_Streamable = TypeVar("_T_Streamable", bound=Streamable)
+
+
+def clvm_streamable(cls: Type[Streamable]) -> Type[Streamable]:
+    wrapped_cls: Type[Streamable] = streamable(cls)
+    setattr(wrapped_cls, "_clvm_streamable", True)
+
+    hints = get_type_hints(cls)
+    # no way to hint that wrapped_cls is a dataclass here but @streamable checks that
+    for field in dataclasses.fields(wrapped_cls):  # type: ignore[arg-type]
+        field.metadata = MappingProxyType({"key": field.name, **field.metadata})
+        if is_type_Tuple(hints[field.name]):
+            raise ValueError("@clvm_streamable does not support tuples")
+
+    return wrapped_cls
+
+
+def program_serialize_clvm_streamable(
+    clvm_streamable: Streamable, translation_layer: Optional[TranslationLayer] = None
+) -> Program:
+    if translation_layer is not None:
+        mapping = translation_layer.get_mapping(clvm_streamable.__class__)
+        if mapping is not None:
+            clvm_streamable = translation_layer.serialize_for_translation(clvm_streamable, mapping)
+    # Underlying hinting problem with clvm_serde
+    return to_program_for_type(type(clvm_streamable))(clvm_streamable)  # type: ignore[no-any-return]
+
+
+def byte_serialize_clvm_streamable(
+    clvm_streamable: Streamable, translation_layer: Optional[TranslationLayer] = None
+) -> bytes:
+    return bytes(program_serialize_clvm_streamable(clvm_streamable, translation_layer=translation_layer))
+
+
+def json_serialize_with_clvm_streamable(
+    streamable: object,
+    next_recursion_step: Optional[Callable[..., Dict[str, Any]]] = None,
+    translation_layer: Optional[TranslationLayer] = None,
+    **next_recursion_env: Any,
+) -> Union[str, Dict[str, Any]]:
+    if next_recursion_step is None:
+        next_recursion_step = recurse_jsonify
+    if is_clvm_streamable(streamable):
+        # If we are using clvm_serde, we stop JSON serialization at this point and instead return the clvm blob
+        return byte_serialize_clvm_streamable(streamable, translation_layer=translation_layer).hex()
+    else:
+        return next_recursion_step(
+            streamable, json_serialize_with_clvm_streamable, translation_layer=translation_layer, **next_recursion_env
+        )
+
+
+def program_deserialize_clvm_streamable(
+    program: Program, clvm_streamable_type: Type[_T_Streamable], translation_layer: Optional[TranslationLayer] = None
+) -> _T_Streamable:
+    type_to_deserialize_from: Type[Streamable] = clvm_streamable_type
+    if translation_layer is not None:
+        mapping = translation_layer.get_mapping(clvm_streamable_type)
+        if mapping is not None:
+            type_to_deserialize_from = mapping.to_type
+    as_instance = from_program_for_type(type_to_deserialize_from)(program)
+    if translation_layer is not None and mapping is not None:
+        return translation_layer.deserialize_from_translation(as_instance, mapping)
+    else:
+        # Underlying hinting problem with clvm_serde
+        return as_instance  # type: ignore[no-any-return]
+
+
+def byte_deserialize_clvm_streamable(
+    blob: bytes, clvm_streamable_type: Type[_T_Streamable], translation_layer: Optional[TranslationLayer] = None
+) -> _T_Streamable:
+    return program_deserialize_clvm_streamable(
+        Program.from_bytes(blob), clvm_streamable_type, translation_layer=translation_layer
+    )
+
+
+def is_compound_type(typ: Any) -> bool:
+    return is_type_SpecificOptional(typ) or is_type_Tuple(typ) or is_type_List(typ)
+
+
+# TODO: this is more than _just_ a Streamable, but it is also a Streamable and that's
+#       useful for now
+def is_clvm_streamable_type(v: Type[object]) -> TypeGuard[Type[Streamable]]:
+    return issubclass(v, Streamable) and hasattr(v, "_clvm_streamable")
+
+
+# TODO: this is more than _just_ a Streamable, but it is also a Streamable and that's
+#       useful for now
+def is_clvm_streamable(v: object) -> TypeGuard[Streamable]:
+    return isinstance(v, Streamable) and hasattr(v, "_clvm_streamable")
+
+
+def json_deserialize_with_clvm_streamable(
+    json_dict: Union[str, Dict[str, Any]],
+    streamable_type: Type[_T_Streamable],
+    translation_layer: Optional[TranslationLayer] = None,
+) -> _T_Streamable:
+    if isinstance(json_dict, str):
+        return byte_deserialize_clvm_streamable(
+            bytes.fromhex(json_dict), streamable_type, translation_layer=translation_layer
+        )
+    else:
+        old_streamable_fields = streamable_type.streamable_fields()
+        new_streamable_fields = []
+        for old_field in old_streamable_fields:
+            if is_compound_type(old_field.type):
+                inner_type = get_args(old_field.type)[0]
+                if is_clvm_streamable_type(inner_type):
+                    new_streamable_fields.append(
+                        dataclasses.replace(
+                            old_field,
+                            convert_function=function_to_convert_one_item(
+                                old_field.type,
+                                functools.partial(
+                                    json_deserialize_with_clvm_streamable,
+                                    streamable_type=inner_type,
+                                    translation_layer=translation_layer,
+                                ),
+                            ),
+                        )
+                    )
+                else:
+                    new_streamable_fields.append(old_field)
+            elif is_clvm_streamable_type(old_field.type):
+                new_streamable_fields.append(
+                    dataclasses.replace(
+                        old_field,
+                        convert_function=functools.partial(
+                            json_deserialize_with_clvm_streamable,
+                            streamable_type=old_field.type,
+                            translation_layer=translation_layer,
+                        ),
+                    )
+                )
+            else:
+                new_streamable_fields.append(old_field)
+
+        setattr(streamable_type, "_streamable_fields", tuple(new_streamable_fields))
+        return streamable_type.from_json_dict(json_dict)
+
+
+_T_ClvmStreamable = TypeVar("_T_ClvmStreamable", bound="Streamable")
+_T_TLClvmStreamable = TypeVar("_T_TLClvmStreamable", bound="Streamable")
+
+
+@dataclasses.dataclass(frozen=True)
+class TranslationLayerMapping(Generic[_T_ClvmStreamable, _T_TLClvmStreamable]):
+    from_type: Type[_T_ClvmStreamable]
+    to_type: Type[_T_TLClvmStreamable]
+    serialize_function: Callable[[_T_ClvmStreamable], _T_TLClvmStreamable]
+    deserialize_function: Callable[[_T_TLClvmStreamable], _T_ClvmStreamable]
+
+
+@dataclasses.dataclass(frozen=True)
+class TranslationLayer:
+    type_mappings: List[TranslationLayerMapping[Any, Any]]
+
+    def get_mapping(
+        self, _type: Type[_T_ClvmStreamable]
+    ) -> Optional[TranslationLayerMapping[_T_ClvmStreamable, Streamable]]:
+        mappings = [m for m in self.type_mappings if m.from_type == _type]
+        if len(mappings) == 1:
+            return mappings[0]
+        elif len(mappings) == 0:
+            return None
+        else:  # pragma: no cover
+            raise RuntimeError("Malformed TranslationLayer")
+
+    def serialize_for_translation(
+        self, instance: _T_ClvmStreamable, mapping: TranslationLayerMapping[_T_ClvmStreamable, _T_TLClvmStreamable]
+    ) -> _T_TLClvmStreamable:
+        if mapping is None:
+            return instance
+        else:
+            return mapping.serialize_function(instance)
+
+    def deserialize_from_translation(
+        self, instance: _T_TLClvmStreamable, mapping: TranslationLayerMapping[_T_ClvmStreamable, _T_TLClvmStreamable]
+    ) -> _T_ClvmStreamable:
+        if mapping is None:
+            return instance
+        else:
+            return mapping.deserialize_function(instance)

chia/wallet/util/compute_hints.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict, Optional, Tuple
+
+from chia.consensus.condition_costs import ConditionCost
+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.sized_bytes import bytes32
+from chia.types.coin_spend import CoinSpend
+from chia.types.condition_opcodes import ConditionOpcode
+from chia.util.errors import Err, ValidationError
+from chia.util.ints import uint64
+
+
+@dataclass(frozen=True)
+class HintedCoin:
+    coin: Coin
+    hint: Optional[bytes32]
+
+
+def compute_spend_hints_and_additions(
+    cs: CoinSpend,
+    *,
+    max_cost: int = DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM,
+) -> Tuple[Dict[bytes32, HintedCoin], int]:
+    cost, result_program = cs.puzzle_reveal.run_with_cost(max_cost, cs.solution)
+
+    hinted_coins: Dict[bytes32, HintedCoin] = {}
+    for condition in result_program.as_iter():
+        if cost > max_cost:
+            raise ValidationError(Err.BLOCK_COST_EXCEEDS_MAX, "compute_spend_hints_and_additions() for CoinSpend")
+        atoms = condition.as_iter()
+        op = next(atoms).atom
+        if op in [
+            ConditionOpcode.AGG_SIG_PARENT,
+            ConditionOpcode.AGG_SIG_PUZZLE,
+            ConditionOpcode.AGG_SIG_AMOUNT,
+            ConditionOpcode.AGG_SIG_PUZZLE_AMOUNT,
+            ConditionOpcode.AGG_SIG_PARENT_AMOUNT,
+            ConditionOpcode.AGG_SIG_PARENT_PUZZLE,
+            ConditionOpcode.AGG_SIG_UNSAFE,
+            ConditionOpcode.AGG_SIG_ME,
+        ]:
+            cost += ConditionCost.AGG_SIG.value
+            continue
+        if op != ConditionOpcode.CREATE_COIN.value:
+            continue
+        cost += ConditionCost.CREATE_COIN.value
+
+        rf = condition.at("rf").atom
+        assert rf is not None
+
+        coin: Coin = Coin(cs.coin.name(), bytes32(rf), uint64(condition.at("rrf").as_int()))
+        hint: Optional[bytes32] = None
+        if (
+            condition.at("rrr") != Program.to(None)  # There's more than two arguments
+            and condition.at("rrrf").atom is None  # The 3rd argument is a cons
+        ):
+            potential_hint: Optional[bytes] = condition.at("rrrff").atom
+            if potential_hint is not None and len(potential_hint) == 32:
+                hint = bytes32(potential_hint)
+        hinted_coins[bytes32(coin.name())] = HintedCoin(coin, hint)
+
+    return hinted_coins, cost

chia/wallet/util/compute_memos.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from typing import Dict, List
+
+from clvm.casts import int_from_bytes
+
+from chia.types.blockchain_format.coin import Coin
+from chia.types.blockchain_format.program import INFINITE_COST
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.coin_spend import CoinSpend
+from chia.types.condition_opcodes import ConditionOpcode
+from chia.util.ints import uint64
+from chia.wallet.wallet_spend_bundle import WalletSpendBundle
+
+
+def compute_memos_for_spend(coin_spend: CoinSpend) -> Dict[bytes32, List[bytes]]:
+    _, result = coin_spend.puzzle_reveal.run_with_cost(INFINITE_COST, coin_spend.solution)
+    memos: Dict[bytes32, List[bytes]] = {}
+    for condition in result.as_python():
+        if condition[0] == ConditionOpcode.CREATE_COIN and len(condition) >= 4:
+            # If only 3 elements (opcode + 2 args), there is no memo, this is ph, amount
+            coin_added = Coin(coin_spend.coin.name(), bytes32(condition[1]), uint64(int_from_bytes(condition[2])))
+            if type(condition[3]) is not list:
+                # If it's not a list, it's not the correct format
+                continue
+            memos[coin_added.name()] = condition[3]
+    return memos
+
+
+def compute_memos(bundle: WalletSpendBundle) -> Dict[bytes32, List[bytes]]:
+    """
+    Retrieves the memos for additions in this spend_bundle, which are formatted as a list in the 3rd parameter of
+    CREATE_COIN. If there are no memos, the addition coin_id is not included. If they are not formatted as a list
+    of bytes, they are not included. This is expensive to call, it should not be used in full node code.
+    """
+    memos: Dict[bytes32, List[bytes]] = {}
+    for coin_spend in bundle.coin_spends:
+        spend_memos = compute_memos_for_spend(coin_spend)
+        for coin_name, coin_memos in spend_memos.items():
+            existing_memos = memos.get(coin_name)
+            if existing_memos is None:
+                memos[coin_name] = coin_memos
+            else:
+                memos[coin_name] = existing_memos + coin_memos
+    return memos

chia/wallet/util/curry_and_treehash.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from hashlib import sha256
+from typing import Callable, List, Sequence
+
+from clvm.casts import int_to_bytes
+
+from chia.types.blockchain_format.sized_bytes import bytes32
+
+CurryHashFunction = Callable[..., bytes32]
+
+
+NULL = bytes.fromhex("")
+ONE = bytes.fromhex("01")
+TWO = bytes.fromhex("02")
+Q_KW = bytes.fromhex("01")
+A_KW = bytes.fromhex("02")
+C_KW = bytes.fromhex("04")
+
+
+def shatree_atom(atom: bytes) -> bytes32:
+    s = sha256()
+    s.update(ONE)
+    s.update(atom)
+    return bytes32(s.digest())
+
+
+def shatree_pair(left_hash: bytes32, right_hash: bytes32) -> bytes32:
+    s = sha256()
+    s.update(TWO)
+    s.update(left_hash)
+    s.update(right_hash)
+    return bytes32(s.digest())
+
+
+Q_KW_TREEHASH = shatree_atom(Q_KW)
+A_KW_TREEHASH = shatree_atom(A_KW)
+C_KW_TREEHASH = shatree_atom(C_KW)
+ONE_TREEHASH = shatree_atom(ONE)
+NIL_TREEHASH = shatree_atom(NULL)
+
+
+def shatree_atom_list(li: Sequence[bytes]) -> bytes32:
+    ret = NIL_TREEHASH
+    for item in reversed(li):
+        ret = shatree_pair(shatree_atom(item), ret)
+    return ret
+
+
+def shatree_int(val: int) -> bytes32:
+    return shatree_atom(int_to_bytes(val))
+
+
+# The environment `E = (F . R)` recursively expands out to
+# `(c . ((q . F) . EXPANSION(R)))` if R is not 0
+# `1` if R is 0
+
+
+def curried_values_tree_hash(arguments: List[bytes32]) -> bytes32:
+    if len(arguments) == 0:
+        return ONE_TREEHASH
+
+    return shatree_pair(
+        C_KW_TREEHASH,
+        shatree_pair(
+            shatree_pair(Q_KW_TREEHASH, arguments[0]),
+            shatree_pair(curried_values_tree_hash(arguments[1:]), NIL_TREEHASH),
+        ),
+    )
+
+
+# The curry pattern is `(a . ((q . F)  . (E . 0)))` == `(a (q . F) E)
+# where `F` is the `mod` and `E` is the curried environment
+
+
+def curry_and_treehash(hash_of_quoted_mod_hash: bytes32, *hashed_arguments: bytes32) -> bytes32:
+    """
+    `hash_of_quoted_mod_hash` : tree hash of `(q . MOD)` where `MOD` is template to be curried
+    `arguments` : tree hashes of arguments to be curried
+    """
+
+    curried_values = curried_values_tree_hash(list(hashed_arguments))
+    return shatree_pair(
+        A_KW_TREEHASH,
+        shatree_pair(hash_of_quoted_mod_hash, shatree_pair(curried_values, NIL_TREEHASH)),
+    )
+
+
+def calculate_hash_of_quoted_mod_hash(mod_hash: bytes32) -> bytes32:
+    return shatree_pair(Q_KW_TREEHASH, mod_hash)