Chialisp file extensions (#14996)
* Rename chialisp file extensions * Add pre-commit check for .clvm files * Delete sha256tree files * remove hash files in favor of central dictionary * Add check for missing files like hex and hash entries * Enhance clsp pre-commit check * Actually check hash matches * Update tools/manage_clvm.py Co-authored-by: Kyle Altendorf <sda@fstab.net> * Update tools/manage_clvm.py Co-authored-by: Kyle Altendorf <sda@fstab.net> * Fix Windows file writing * Fix setup.py package_data fields * Load hash dict at runtime * Move away from exception pattern * Bad equality check * Minor fixes * remove trailing whitespace fix --------- Co-authored-by: Kyle Altendorf <sda@fstab.net>
This commit is contained in:
Matt Hauff
GitHub
parent
d9be2004c7
commit
e5b94d34a0
|
|
@ -23,7 +23,7 @@ repos:
|
|||
hooks:
|
||||
- id: check-yaml
|
||||
- id: end-of-file-fixer
|
||||
exclude: ".*?(.hex|.clvm|.clib)"
|
||||
exclude: ".*?(.hex|.clsp|.clvm|.clib)"
|
||||
- id: trailing-whitespace
|
||||
- id: check-merge-conflict
|
||||
- id: check-ast
|
||||
|
|
@ -31,7 +31,7 @@ repos:
|
|||
- repo: local
|
||||
hooks:
|
||||
- id: clvm_hex
|
||||
name: .clvm.hex files
|
||||
name: .clsp.hex files
|
||||
entry: ./activated.py python tools/manage_clvm.py check
|
||||
language: python
|
||||
pass_filenames: false
|
||||
|
|
|
|||
|
|
@ -2,6 +2,6 @@ from __future__ import annotations
|
|||
|
||||
from chia.wallet.puzzles.load_clvm import load_clvm_maybe_recompile
|
||||
|
||||
P2_SINGLETON_MOD = load_clvm_maybe_recompile("p2_singleton.clvm")
|
||||
SINGLETON_TOP_LAYER_MOD = load_clvm_maybe_recompile("singleton_top_layer.clvm")
|
||||
SINGLETON_LAUNCHER = load_clvm_maybe_recompile("singleton_launcher.clvm")
|
||||
P2_SINGLETON_MOD = load_clvm_maybe_recompile("p2_singleton.clsp")
|
||||
SINGLETON_TOP_LAYER_MOD = load_clvm_maybe_recompile("singleton_top_layer.clsp")
|
||||
SINGLETON_LAUNCHER = load_clvm_maybe_recompile("singleton_launcher.clsp")
|
||||
|
|
|
|||
|
|
@ -12,15 +12,15 @@ from chia.wallet.puzzles.rom_bootstrap_generator import get_generator
|
|||
|
||||
GENERATOR_MOD = get_generator()
|
||||
|
||||
DECOMPRESS_BLOCK = load_clvm_maybe_recompile("block_program_zero.clvm", package_or_requirement="chia.wallet.puzzles")
|
||||
DECOMPRESS_PUZZLE = load_clvm_maybe_recompile("decompress_puzzle.clvm", package_or_requirement="chia.wallet.puzzles")
|
||||
DECOMPRESS_BLOCK = load_clvm_maybe_recompile("block_program_zero.clsp", package_or_requirement="chia.wallet.puzzles")
|
||||
DECOMPRESS_PUZZLE = load_clvm_maybe_recompile("decompress_puzzle.clsp", package_or_requirement="chia.wallet.puzzles")
|
||||
# DECOMPRESS_CSE = load_clvm_maybe_recompile(
|
||||
# "decompress_coin_spend_entry.clvm",
|
||||
# "decompress_coin_spend_entry.clsp",
|
||||
# package_or_requirement="chia.wallet.puzzles",
|
||||
# )
|
||||
|
||||
DECOMPRESS_CSE_WITH_PREFIX = load_clvm_maybe_recompile(
|
||||
"decompress_coin_spend_entry_with_prefix.clvm", package_or_requirement="chia.wallet.puzzles"
|
||||
"decompress_coin_spend_entry_with_prefix.clsp", package_or_requirement="chia.wallet.puzzles"
|
||||
)
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
|
|
|
|||
|
|
@ -27,7 +27,7 @@ from chia.wallet.puzzles.rom_bootstrap_generator import get_generator
|
|||
GENERATOR_MOD = get_generator()
|
||||
|
||||
DESERIALIZE_MOD = load_serialized_clvm_maybe_recompile(
|
||||
"chialisp_deserialisation.clvm", package_or_requirement="chia.wallet.puzzles"
|
||||
"chialisp_deserialisation.clsp", package_or_requirement="chia.wallet.puzzles"
|
||||
)
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
|
|
|||
|
|
@ -21,10 +21,10 @@ from chia.wallet.puzzles.singleton_top_layer import puzzle_for_singleton
|
|||
|
||||
log = logging.getLogger(__name__)
|
||||
# "Full" is the outer singleton, with the inner puzzle filled in
|
||||
SINGLETON_MOD = load_clvm_maybe_recompile("singleton_top_layer.clvm")
|
||||
POOL_WAITING_ROOM_MOD = load_clvm_maybe_recompile("pool_waitingroom_innerpuz.clvm")
|
||||
POOL_MEMBER_MOD = load_clvm_maybe_recompile("pool_member_innerpuz.clvm")
|
||||
P2_SINGLETON_MOD = load_clvm_maybe_recompile("p2_singleton_or_delayed_puzhash.clvm")
|
||||
SINGLETON_MOD = load_clvm_maybe_recompile("singleton_top_layer.clsp")
|
||||
POOL_WAITING_ROOM_MOD = load_clvm_maybe_recompile("pool_waitingroom_innerpuz.clsp")
|
||||
POOL_MEMBER_MOD = load_clvm_maybe_recompile("pool_member_innerpuz.clsp")
|
||||
P2_SINGLETON_MOD = load_clvm_maybe_recompile("p2_singleton_or_delayed_puzhash.clsp")
|
||||
POOL_OUTER_MOD = SINGLETON_MOD
|
||||
|
||||
POOL_MEMBER_HASH = POOL_MEMBER_MOD.get_tree_hash()
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@ import enum
|
|||
from typing import Any
|
||||
|
||||
|
||||
# See chia/wallet/puzzles/condition_codes.clvm
|
||||
# See chia/wallet/puzzles/condition_codes.clib
|
||||
class ConditionOpcode(bytes, enum.Enum):
|
||||
# AGG_SIG is ascii "1"
|
||||
|
||||
|
|
|
|||
|
|
@ -14,10 +14,10 @@ from chia.wallet.puzzles.load_clvm import load_clvm_maybe_recompile
|
|||
|
||||
ACS_MU = Program.to(11) # returns the third argument a.k.a the full solution
|
||||
ACS_MU_PH = ACS_MU.get_tree_hash()
|
||||
SINGLETON_TOP_LAYER_MOD = load_clvm_maybe_recompile("singleton_top_layer_v1_1.clvm")
|
||||
SINGLETON_LAUNCHER = load_clvm_maybe_recompile("singleton_launcher.clvm")
|
||||
GRAFTROOT_DL_OFFERS = load_clvm_maybe_recompile("graftroot_dl_offers.clvm")
|
||||
P2_PARENT = load_clvm_maybe_recompile("p2_parent.clvm")
|
||||
SINGLETON_TOP_LAYER_MOD = load_clvm_maybe_recompile("singleton_top_layer_v1_1.clsp")
|
||||
SINGLETON_LAUNCHER = load_clvm_maybe_recompile("singleton_launcher.clsp")
|
||||
GRAFTROOT_DL_OFFERS = load_clvm_maybe_recompile("graftroot_dl_offers.clsp")
|
||||
P2_PARENT = load_clvm_maybe_recompile("p2_parent.clsp")
|
||||
|
||||
|
||||
def create_host_fullpuz(innerpuz: Union[Program, bytes32], current_root: bytes32, genesis_id: bytes32) -> Program:
|
||||
|
|
|
|||
|
|
@ -19,9 +19,9 @@ from chia.wallet.singleton import (
|
|||
)
|
||||
from chia.wallet.util.curry_and_treehash import calculate_hash_of_quoted_mod_hash, curry_and_treehash
|
||||
|
||||
DID_INNERPUZ_MOD = load_clvm_maybe_recompile("did_innerpuz.clvm")
|
||||
DID_INNERPUZ_MOD = load_clvm_maybe_recompile("did_innerpuz.clsp")
|
||||
DID_INNERPUZ_MOD_HASH = DID_INNERPUZ_MOD.get_tree_hash()
|
||||
INTERMEDIATE_LAUNCHER_MOD = load_clvm_maybe_recompile("nft_intermediate_launcher.clvm")
|
||||
INTERMEDIATE_LAUNCHER_MOD = load_clvm_maybe_recompile("nft_intermediate_launcher.clsp")
|
||||
|
||||
|
||||
def create_innerpuz(
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ from chia.wallet.puzzle_drivers import PuzzleInfo, Solver
|
|||
from chia.wallet.puzzles.load_clvm import load_clvm_maybe_recompile
|
||||
from chia.wallet.uncurried_puzzle import UncurriedPuzzle, uncurry_puzzle
|
||||
|
||||
NFT_STATE_LAYER_MOD = load_clvm_maybe_recompile("nft_state_layer.clvm")
|
||||
NFT_STATE_LAYER_MOD = load_clvm_maybe_recompile("nft_state_layer.clsp")
|
||||
NFT_STATE_LAYER_MOD_HASH = NFT_STATE_LAYER_MOD.get_tree_hash()
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ from chia.util.streamable import Streamable, streamable
|
|||
from chia.wallet.lineage_proof import LineageProof
|
||||
from chia.wallet.puzzles.load_clvm import load_clvm_maybe_recompile
|
||||
|
||||
LAUNCHER_PUZZLE = load_clvm_maybe_recompile("singleton_launcher.clvm")
|
||||
LAUNCHER_PUZZLE = load_clvm_maybe_recompile("singleton_launcher.clsp")
|
||||
IN_TRANSACTION_STATUS = "IN_TRANSACTION"
|
||||
DEFAULT_STATUS = "DEFAULT"
|
||||
|
||||
|
|
|
|||
|
|
@ -18,26 +18,26 @@ from chia.wallet.puzzles.p2_delegated_puzzle_or_hidden_puzzle import solution_fo
|
|||
from chia.wallet.util.address_type import AddressType
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
SINGLETON_TOP_LAYER_MOD = load_clvm_maybe_recompile("singleton_top_layer_v1_1.clvm")
|
||||
LAUNCHER_PUZZLE = load_clvm_maybe_recompile("singleton_launcher.clvm")
|
||||
NFT_STATE_LAYER_MOD = load_clvm_maybe_recompile("nft_state_layer.clvm")
|
||||
SINGLETON_TOP_LAYER_MOD = load_clvm_maybe_recompile("singleton_top_layer_v1_1.clsp")
|
||||
LAUNCHER_PUZZLE = load_clvm_maybe_recompile("singleton_launcher.clsp")
|
||||
NFT_STATE_LAYER_MOD = load_clvm_maybe_recompile("nft_state_layer.clsp")
|
||||
LAUNCHER_PUZZLE_HASH = LAUNCHER_PUZZLE.get_tree_hash()
|
||||
SINGLETON_MOD_HASH = SINGLETON_TOP_LAYER_MOD.get_tree_hash()
|
||||
NFT_STATE_LAYER_MOD_HASH = NFT_STATE_LAYER_MOD.get_tree_hash()
|
||||
NFT_METADATA_UPDATER = load_clvm_maybe_recompile("nft_metadata_updater_default.clvm")
|
||||
NFT_OWNERSHIP_LAYER = load_clvm_maybe_recompile("nft_ownership_layer.clvm")
|
||||
NFT_METADATA_UPDATER = load_clvm_maybe_recompile("nft_metadata_updater_default.clsp")
|
||||
NFT_OWNERSHIP_LAYER = load_clvm_maybe_recompile("nft_ownership_layer.clsp")
|
||||
NFT_OWNERSHIP_LAYER_HASH = NFT_OWNERSHIP_LAYER.get_tree_hash()
|
||||
NFT_TRANSFER_PROGRAM_DEFAULT = load_clvm_maybe_recompile(
|
||||
"nft_ownership_transfer_program_one_way_claim_with_royalties.clvm",
|
||||
"nft_ownership_transfer_program_one_way_claim_with_royalties.clsp",
|
||||
)
|
||||
STANDARD_PUZZLE_MOD = load_clvm_maybe_recompile("p2_delegated_puzzle_or_hidden_puzzle.clvm")
|
||||
INTERMEDIATE_LAUNCHER_MOD = load_clvm_maybe_recompile("nft_intermediate_launcher.clvm")
|
||||
STANDARD_PUZZLE_MOD = load_clvm_maybe_recompile("p2_delegated_puzzle_or_hidden_puzzle.clsp")
|
||||
INTERMEDIATE_LAUNCHER_MOD = load_clvm_maybe_recompile("nft_intermediate_launcher.clsp")
|
||||
|
||||
|
||||
def create_nft_layer_puzzle_with_curry_params(
|
||||
metadata: Program, metadata_updater_hash: bytes32, inner_puzzle: Program
|
||||
) -> Program:
|
||||
"""Curries params into nft_state_layer.clvm
|
||||
"""Curries params into nft_state_layer.clsp
|
||||
|
||||
Args to curry:
|
||||
NFT_STATE_LAYER_MOD_HASH
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ from chia.wallet.puzzle_drivers import PuzzleInfo, Solver
|
|||
from chia.wallet.puzzles.load_clvm import load_clvm_maybe_recompile
|
||||
from chia.wallet.uncurried_puzzle import UncurriedPuzzle, uncurry_puzzle
|
||||
|
||||
OWNERSHIP_LAYER_MOD = load_clvm_maybe_recompile("nft_ownership_layer.clvm")
|
||||
OWNERSHIP_LAYER_MOD = load_clvm_maybe_recompile("nft_ownership_layer.clsp")
|
||||
|
||||
|
||||
def match_ownership_layer_puzzle(puzzle: UncurriedPuzzle) -> Tuple[bool, List[Program]]:
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ from chia.wallet.puzzles.load_clvm import load_clvm_maybe_recompile
|
|||
from chia.wallet.puzzles.singleton_top_layer_v1_1 import SINGLETON_LAUNCHER_HASH, SINGLETON_MOD_HASH
|
||||
from chia.wallet.uncurried_puzzle import UncurriedPuzzle
|
||||
|
||||
TRANSFER_PROGRAM_MOD = load_clvm_maybe_recompile("nft_ownership_transfer_program_one_way_claim_with_royalties.clvm")
|
||||
TRANSFER_PROGRAM_MOD = load_clvm_maybe_recompile("nft_ownership_transfer_program_one_way_claim_with_royalties.clsp")
|
||||
|
||||
|
||||
def match_transfer_program_puzzle(puzzle: UncurriedPuzzle) -> Tuple[bool, List[Program]]:
|
||||
|
|
|
|||
|
|
@ -10,9 +10,9 @@ from chia.util.ints import uint16
|
|||
from chia.wallet.puzzles.load_clvm import load_clvm_maybe_recompile
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
SINGLETON_TOP_LAYER_MOD = load_clvm_maybe_recompile("singleton_top_layer_v1_1.clvm")
|
||||
NFT_MOD = load_clvm_maybe_recompile("nft_state_layer.clvm")
|
||||
NFT_OWNERSHIP_LAYER = load_clvm_maybe_recompile("nft_ownership_layer.clvm")
|
||||
SINGLETON_TOP_LAYER_MOD = load_clvm_maybe_recompile("singleton_top_layer_v1_1.clsp")
|
||||
NFT_MOD = load_clvm_maybe_recompile("nft_state_layer.clsp")
|
||||
NFT_OWNERSHIP_LAYER = load_clvm_maybe_recompile("nft_ownership_layer.clsp")
|
||||
|
||||
_T_UncurriedNFT = TypeVar("_T_UncurriedNFT", bound="UncurriedNFT")
|
||||
|
||||
|
|
|
|||
|
|
@ -1 +0,0 @@
|
|||
f0a38c8efe58895ae527c65c37f700a4238504691b83990e5dd91bd8b3c30eae
|
||||
|
|
@ -1 +0,0 @@
|
|||
624c5d5704d0decadfc0503e71bbffb6cdfe45025bce7cf3e6864d1eafe8f65e
|
||||
|
|
@ -2,7 +2,6 @@ from __future__ import annotations
|
|||
|
||||
from chia.wallet.puzzles.load_clvm import load_clvm_maybe_recompile
|
||||
|
||||
CAT_MOD = load_clvm_maybe_recompile("cat_v2.clvm", package_or_requirement=__name__)
|
||||
LOCK_INNER_PUZZLE = load_clvm_maybe_recompile("lock.inner.puzzle.clvm", package_or_requirement=__name__)
|
||||
CAT_MOD = load_clvm_maybe_recompile("cat_v2.clsp", package_or_requirement=__name__)
|
||||
|
||||
CAT_MOD_HASH = CAT_MOD.get_tree_hash()
|
||||
|
|
|
|||
|
|
@ -1,397 +1,397 @@
|
|||
; Coins locked with this puzzle are spendable cats.
|
||||
;
|
||||
; Choose a list of n inputs (n>=1), I_1, ... I_n with amounts A_1, ... A_n.
|
||||
;
|
||||
; We put them in a ring, so "previous" and "next" have intuitive k-1 and k+1 semantics,
|
||||
; wrapping so {n} and 0 are the same, ie. all indices are mod n.
|
||||
;
|
||||
; Each coin creates 0 or more coins with total output value O_k.
|
||||
; Let D_k = the "debt" O_k - A_k contribution of coin I_k, ie. how much debt this input accumulates.
|
||||
; Some coins may spend more than they contribute and some may spend less, ie. D_k need
|
||||
; not be zero. That's okay. It's enough for the total of all D_k in the ring to be 0.
|
||||
;
|
||||
; A coin can calculate its own D_k since it can verify A_k (it's hashed into the coin id)
|
||||
; and it can sum up `CREATE_COIN` conditions for O_k.
|
||||
;
|
||||
; Defines a "subtotal of debts" S_k for each coin as follows:
|
||||
;
|
||||
; S_1 = 0
|
||||
; S_k = S_{k-1} + D_{k-1}
|
||||
;
|
||||
; Here's the main trick that shows the ring sums to 0.
|
||||
; You can prove by induction that S_{k+1} = D_1 + D_2 + ... + D_k.
|
||||
; But it's a ring, so S_{n+1} is also S_1, which is 0. So D_1 + D_2 + ... + D_k = 0.
|
||||
; So the total debts must be 0, ie. no coins are created or destroyed.
|
||||
;
|
||||
; Each coin's solution includes I_{k-1}, I_k, and I_{k+1} along with proofs that I_{k}, and I_{k+1} are CATs of the same type.
|
||||
; Each coin's solution includes S_{k-1}. It calculates D_k = O_k - A_k, and then S_k = S_{k-1} + D_{k-1}
|
||||
;
|
||||
; Announcements are used to ensure that each S_k follows the pattern is valid.
|
||||
; Announcements automatically commit to their own coin id.
|
||||
; Coin I_k creates an announcement that further commits to I_{k-1} and S_{k-1}.
|
||||
;
|
||||
; Coin I_k gets a proof that I_{k+1} is a cat, so it knows it must also create an announcement
|
||||
; when spent. It checks that I_{k+1} creates an announcement committing to I_k and S_k.
|
||||
;
|
||||
; So S_{k+1} is correct iff S_k is correct.
|
||||
;
|
||||
; Coins also receive proofs that their neighbours are CATs, ensuring the announcements aren't forgeries.
|
||||
; Inner puzzles and the CAT layer prepend `CREATE_COIN_ANNOUNCEMENT` with different prefixes to avoid forgeries.
|
||||
; Ring announcements use 0xcb, and inner puzzles are given 0xca
|
||||
;
|
||||
; In summary, I_k generates a coin_announcement Y_k ("Y" for "yell") as follows:
|
||||
;
|
||||
; Y_k: hash of I_k (automatically), I_{k-1}, S_k
|
||||
;
|
||||
; Each coin creates an assert_coin_announcement to ensure that the next coin's announcement is as expected:
|
||||
; Y_{k+1} : hash of I_{k+1}, I_k, S_{k+1}
|
||||
;
|
||||
; TLDR:
|
||||
; I_k : coins
|
||||
; A_k : amount coin k contributes
|
||||
; O_k : amount coin k spend
|
||||
; D_k : difference/delta that coin k incurs (A - O)
|
||||
; S_k : subtotal of debts D_1 + D_2 ... + D_k
|
||||
; Y_k : announcements created by coin k committing to I_{k-1}, I_k, S_k
|
||||
;
|
||||
; All conditions go through a "transformer" that looks for CREATE_COIN conditions
|
||||
; generated by the inner solution, and wraps the puzzle hash ensuring the output is a cat.
|
||||
;
|
||||
; Three output conditions are prepended to the list of conditions for each I_k:
|
||||
; (ASSERT_MY_ID I_k) to ensure that the passed in value for I_k is correct
|
||||
; (CREATE_COIN_ANNOUNCEMENT I_{k-1} S_k) to create this coin's announcement
|
||||
; (ASSERT_COIN_ANNOUNCEMENT hashed_announcement(Y_{k+1})) to ensure the next coin really is next and
|
||||
; the relative values of S_k and S_{k+1} are correct
|
||||
;
|
||||
; This is all we need to do to ensure cats exactly balance in the inputs and outputs.
|
||||
;
|
||||
; Proof:
|
||||
; Consider n, k, I_k values, O_k values, S_k and A_k as above.
|
||||
; For the (CREATE_COIN_ANNOUNCEMENT Y_{k+1}) (created by the next coin)
|
||||
; and (ASSERT_COIN_ANNOUNCEMENT hashed(Y_{k+1})) to match,
|
||||
; we see that I_k can ensure that is has the correct value for S_{k+1}.
|
||||
;
|
||||
; By induction, we see that S_{m+1} = sum(i, 1, m) [O_i - A_i] = sum(i, 1, m) O_i - sum(i, 1, m) A_i
|
||||
; So S_{n+1} = sum(i, 1, n) O_i - sum(i, 1, n) A_i. But S_{n+1} is actually S_1 = 0,
|
||||
; so thus sum(i, 1, n) O_i = sum (i, 1, n) A_i, ie. output total equals input total.
|
||||
|
||||
;; GLOSSARY:
|
||||
;; MOD_HASH: this code's sha256 tree hash
|
||||
;; TAIL_PROGRAM_HASH: the program that determines if a coin can mint new cats, burn cats, and check if its lineage is valid if its parent is not a CAT
|
||||
;; INNER_PUZZLE: an independent puzzle protecting the coins. Solutions to this puzzle are expected to generate `AGG_SIG` conditions and possibly `CREATE_COIN` conditions.
|
||||
;; ---- items above are curried into the puzzle hash ----
|
||||
;; inner_puzzle_solution: the solution to the inner puzzle
|
||||
;; prev_coin_id: the id for the previous coin
|
||||
;; tail_program_reveal: reveal of TAIL_PROGRAM_HASH required to run the program if desired
|
||||
;; tail_solution: optional solution passed into tail_program
|
||||
;; lineage_proof: optional proof that our coin's parent is a CAT
|
||||
;; this_coin_info: (parent_id puzzle_hash amount)
|
||||
;; next_coin_proof: (parent_id inner_puzzle_hash amount)
|
||||
;; prev_subtotal: the subtotal between prev-coin and this-coin
|
||||
;; extra_delta: an amount that is added to our delta and checked by the TAIL program
|
||||
;;
|
||||
|
||||
(mod (
|
||||
MOD_HASH ;; curried into puzzle
|
||||
TAIL_PROGRAM_HASH ;; curried into puzzle
|
||||
INNER_PUZZLE ;; curried into puzzle
|
||||
inner_puzzle_solution ;; if invalid, INNER_PUZZLE will fail
|
||||
lineage_proof ;; This is the parent's coin info, used to check if the parent was a CAT. Optional if using tail_program.
|
||||
prev_coin_id ;; used in this coin's announcement, prev_coin ASSERT_COIN_ANNOUNCEMENT will fail if wrong
|
||||
this_coin_info ;; verified with ASSERT_MY_COIN_ID
|
||||
next_coin_proof ;; used to generate ASSERT_COIN_ANNOUNCEMENT
|
||||
prev_subtotal ;; included in announcement, prev_coin ASSERT_COIN_ANNOUNCEMENT will fail if wrong
|
||||
extra_delta ;; this is the "legal discrepancy" between your real delta and what you're announcing your delta is
|
||||
)
|
||||
|
||||
;;;;; start library code
|
||||
|
||||
(include condition_codes.clvm)
|
||||
(include curry-and-treehash.clinc)
|
||||
(include cat_truths.clib)
|
||||
(include utility_macros.clib)
|
||||
|
||||
(defconstant RING_MORPH_BYTE 0xcb)
|
||||
|
||||
|
||||
; 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
|
||||
)
|
||||
)
|
||||
|
||||
; cat_mod_struct = (MOD_HASH MOD_HASH_hash GENESIS_COIN_CHECKER GENESIS_COIN_CHECKER_hash)
|
||||
|
||||
(defun-inline mod_hash_from_cat_mod_struct (cat_mod_struct) (f cat_mod_struct))
|
||||
(defun-inline mod_hash_hash_from_cat_mod_struct (cat_mod_struct) (f (r cat_mod_struct)))
|
||||
(defun-inline tail_program_hash_from_cat_mod_struct (cat_mod_struct) (f (r (r cat_mod_struct))))
|
||||
|
||||
;;;;; end library code
|
||||
|
||||
;; return the puzzle hash for a cat with the given `GENESIS_COIN_CHECKER_hash` & `INNER_PUZZLE`
|
||||
(defun-inline cat_puzzle_hash (cat_mod_struct inner_puzzle_hash)
|
||||
(puzzle-hash-of-curried-function (mod_hash_from_cat_mod_struct cat_mod_struct)
|
||||
inner_puzzle_hash
|
||||
(sha256 ONE (tail_program_hash_from_cat_mod_struct cat_mod_struct))
|
||||
(mod_hash_hash_from_cat_mod_struct cat_mod_struct)
|
||||
)
|
||||
)
|
||||
|
||||
;; assert `CREATE_COIN_ANNOUNCEMENT` doesn't contain the RING_MORPH_BYTE bytes so it cannot be used to cheat the coin ring
|
||||
|
||||
(defun-inline morph_condition (condition cat_mod_struct)
|
||||
(if (= (f condition) CREATE_COIN)
|
||||
(c CREATE_COIN
|
||||
(c (cat_puzzle_hash cat_mod_struct (f (r condition)))
|
||||
(r (r condition)))
|
||||
)
|
||||
(if (= (f condition) CREATE_COIN_ANNOUNCEMENT)
|
||||
(assert (not (and
|
||||
(= 33 (strlen (f (r condition))))
|
||||
(= (substr (f (r condition)) 0 ONE) RING_MORPH_BYTE) ; lazy eval
|
||||
))
|
||||
; then
|
||||
condition
|
||||
)
|
||||
condition
|
||||
)
|
||||
)
|
||||
)
|
||||
|
||||
;; given a coin's parent, inner_puzzle and amount, and the cat_mod_struct, calculate the id of the coin
|
||||
(defun-inline coin_id_for_proof (coin cat_mod_struct)
|
||||
(calculate_coin_id (f coin) (cat_puzzle_hash cat_mod_struct (f (r coin))) (f (r (r coin))))
|
||||
)
|
||||
|
||||
;; utility to fetch coin amount from coin
|
||||
(defun-inline input_amount_for_coin (coin)
|
||||
(f (r (r coin)))
|
||||
)
|
||||
|
||||
;; calculate the hash of an announcement
|
||||
;; we add 0xcb so ring announcements exist in a different namespace to announcements from inner_puzzles
|
||||
(defun-inline calculate_annoucement_id (this_coin_id this_subtotal next_coin_id cat_mod_struct)
|
||||
(sha256 next_coin_id RING_MORPH_BYTE (sha256tree (list this_coin_id this_subtotal)))
|
||||
)
|
||||
|
||||
;; create the `ASSERT_COIN_ANNOUNCEMENT` condition that ensures the next coin's announcement is correct
|
||||
(defun-inline create_assert_next_announcement_condition (this_coin_id this_subtotal next_coin_id cat_mod_struct)
|
||||
(list ASSERT_COIN_ANNOUNCEMENT
|
||||
(calculate_annoucement_id this_coin_id
|
||||
this_subtotal
|
||||
next_coin_id
|
||||
cat_mod_struct
|
||||
)
|
||||
)
|
||||
)
|
||||
|
||||
;; here we commit to I_{k-1} and S_k
|
||||
;; we add 0xcb so ring announcements exist in a different namespace to announcements from inner_puzzles
|
||||
(defun-inline create_announcement_condition (prev_coin_id prev_subtotal)
|
||||
(list CREATE_COIN_ANNOUNCEMENT
|
||||
(concat RING_MORPH_BYTE (sha256tree (list prev_coin_id prev_subtotal)))
|
||||
)
|
||||
)
|
||||
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
|
||||
;; this function takes a condition and returns an integer indicating
|
||||
;; the value of all output coins created with CREATE_COIN. If it's not
|
||||
;; a CREATE_COIN condition, it returns 0.
|
||||
|
||||
(defun-inline output_value_for_condition (condition)
|
||||
(if (= (f condition) CREATE_COIN)
|
||||
(f (r (r condition)))
|
||||
0
|
||||
)
|
||||
)
|
||||
|
||||
;; add two conditions to the list of morphed conditions:
|
||||
;; CREATE_COIN_ANNOUNCEMENT for my announcement
|
||||
;; ASSERT_COIN_ANNOUNCEMENT for the next coin's announcement
|
||||
(defun-inline generate_final_output_conditions
|
||||
(
|
||||
prev_subtotal
|
||||
this_subtotal
|
||||
morphed_conditions
|
||||
prev_coin_id
|
||||
this_coin_id
|
||||
next_coin_id
|
||||
cat_mod_struct
|
||||
)
|
||||
(c (create_announcement_condition prev_coin_id prev_subtotal)
|
||||
(c (create_assert_next_announcement_condition this_coin_id this_subtotal next_coin_id cat_mod_struct)
|
||||
morphed_conditions)
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
;; This next section of code loops through all of the conditions to do three things:
|
||||
;; 1) Look for a "magic" value of -113 and, if one exists, filter it, and take note of the tail reveal and solution
|
||||
;; 2) Morph any CREATE_COIN or CREATE_COIN_ANNOUNCEMENT conditions
|
||||
;; 3) Sum the total output amount of all of the CREATE_COINs that are output by the inner puzzle
|
||||
;;
|
||||
;; After everything return a struct in the format (morphed_conditions . (output_sum . tail_reveal_and_solution))
|
||||
;; If multiple magic conditions are specified, the later one will take precedence
|
||||
|
||||
(defun-inline condition_tail_reveal (condition) (f (r (r (r condition)))))
|
||||
(defun-inline condition_tail_solution (condition) (f (r (r (r (r condition))))))
|
||||
|
||||
(defun cons_onto_first_and_add_to_second (morphed_condition output_value struct)
|
||||
(c (c morphed_condition (f struct)) (c (+ output_value (f (r struct))) (r (r struct))))
|
||||
)
|
||||
|
||||
(defun find_and_strip_tail_info (inner_conditions cat_mod_struct tail_reveal_and_solution)
|
||||
(if inner_conditions
|
||||
(if (= (output_value_for_condition (f inner_conditions)) -113) ; Checks this is a CREATE_COIN of value -113
|
||||
(find_and_strip_tail_info
|
||||
(r inner_conditions)
|
||||
cat_mod_struct
|
||||
(c (condition_tail_reveal (f inner_conditions)) (condition_tail_solution (f inner_conditions)))
|
||||
)
|
||||
(cons_onto_first_and_add_to_second
|
||||
(morph_condition (f inner_conditions) cat_mod_struct)
|
||||
(output_value_for_condition (f inner_conditions))
|
||||
(find_and_strip_tail_info
|
||||
(r inner_conditions)
|
||||
cat_mod_struct
|
||||
tail_reveal_and_solution
|
||||
)
|
||||
)
|
||||
)
|
||||
(c () (c 0 tail_reveal_and_solution))
|
||||
)
|
||||
)
|
||||
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;; lineage checking
|
||||
|
||||
;; return true iff parent of `this_coin_info` is provably a cat
|
||||
;; A 'lineage proof' consists of (parent_parent_id parent_INNER_puzzle_hash parent_amount)
|
||||
;; We use this information to construct a coin who's puzzle has been wrapped in this MOD and verify that,
|
||||
;; once wrapped, it matches our parent coin's ID.
|
||||
(defun-inline is_parent_cat (
|
||||
cat_mod_struct
|
||||
parent_id
|
||||
lineage_proof
|
||||
)
|
||||
(= parent_id
|
||||
(calculate_coin_id (f lineage_proof)
|
||||
(cat_puzzle_hash cat_mod_struct (f (r lineage_proof)))
|
||||
(f (r (r lineage_proof)))
|
||||
)
|
||||
)
|
||||
)
|
||||
|
||||
(defun check_lineage_or_run_tail_program
|
||||
(
|
||||
this_coin_info
|
||||
tail_reveal_and_solution
|
||||
parent_is_cat ; flag which says whether or not the parent CAT check ran and passed
|
||||
lineage_proof
|
||||
Truths
|
||||
extra_delta
|
||||
inner_conditions
|
||||
)
|
||||
(if tail_reveal_and_solution
|
||||
(assert (= (sha256tree (f tail_reveal_and_solution)) (cat_tail_program_hash_truth Truths))
|
||||
(merge_list
|
||||
(a (f tail_reveal_and_solution)
|
||||
(list
|
||||
Truths
|
||||
parent_is_cat
|
||||
lineage_proof ; Lineage proof is only guaranteed to be true if parent_is_cat
|
||||
extra_delta
|
||||
inner_conditions
|
||||
(r tail_reveal_and_solution)
|
||||
)
|
||||
)
|
||||
inner_conditions
|
||||
)
|
||||
)
|
||||
(assert parent_is_cat (not extra_delta)
|
||||
inner_conditions
|
||||
)
|
||||
)
|
||||
)
|
||||
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
|
||||
(defun stager_two (
|
||||
Truths
|
||||
(inner_conditions . (output_sum . tail_reveal_and_solution))
|
||||
lineage_proof
|
||||
prev_coin_id
|
||||
this_coin_info
|
||||
next_coin_id
|
||||
prev_subtotal
|
||||
extra_delta
|
||||
)
|
||||
(check_lineage_or_run_tail_program
|
||||
this_coin_info
|
||||
tail_reveal_and_solution
|
||||
(if lineage_proof (is_parent_cat (cat_struct_truth Truths) (my_parent_cat_truth Truths) lineage_proof) ())
|
||||
lineage_proof
|
||||
Truths
|
||||
extra_delta
|
||||
(generate_final_output_conditions
|
||||
prev_subtotal
|
||||
; the expression on the next line calculates `this_subtotal` by adding the delta to `prev_subtotal`
|
||||
(+ prev_subtotal (- (input_amount_for_coin this_coin_info) output_sum) extra_delta)
|
||||
inner_conditions
|
||||
prev_coin_id
|
||||
(my_id_cat_truth Truths)
|
||||
next_coin_id
|
||||
(cat_struct_truth Truths)
|
||||
)
|
||||
)
|
||||
)
|
||||
|
||||
; CAT TRUTHS struct is: ; CAT Truths is: ((Inner puzzle hash . (MOD hash . (MOD hash hash . TAIL hash))) . (my_id . (my_parent_info my_puzhash my_amount)))
|
||||
; create truths - this_coin_info verified true because we calculated my ID from it!
|
||||
; lineage proof is verified later by cat parent check or tail_program
|
||||
|
||||
(defun stager (
|
||||
cat_mod_struct
|
||||
inner_conditions
|
||||
lineage_proof
|
||||
inner_puzzle_hash
|
||||
my_id
|
||||
prev_coin_id
|
||||
this_coin_info
|
||||
next_coin_proof
|
||||
prev_subtotal
|
||||
extra_delta
|
||||
)
|
||||
(c (list ASSERT_MY_COIN_ID my_id) (stager_two
|
||||
(cat_truth_data_to_truth_struct
|
||||
inner_puzzle_hash
|
||||
cat_mod_struct
|
||||
my_id
|
||||
this_coin_info
|
||||
)
|
||||
(find_and_strip_tail_info inner_conditions cat_mod_struct ())
|
||||
lineage_proof
|
||||
prev_coin_id
|
||||
this_coin_info
|
||||
(coin_id_for_proof next_coin_proof cat_mod_struct)
|
||||
prev_subtotal
|
||||
extra_delta
|
||||
))
|
||||
)
|
||||
|
||||
(stager
|
||||
;; calculate cat_mod_struct, inner_puzzle_hash, coin_id
|
||||
(list MOD_HASH (sha256 ONE MOD_HASH) TAIL_PROGRAM_HASH)
|
||||
(a INNER_PUZZLE inner_puzzle_solution)
|
||||
lineage_proof
|
||||
(sha256tree INNER_PUZZLE)
|
||||
(calculate_coin_id (f this_coin_info) (f (r this_coin_info)) (f (r (r this_coin_info))))
|
||||
prev_coin_id ; ID
|
||||
this_coin_info ; (parent_id puzzle_hash amount)
|
||||
next_coin_proof ; (parent_id innerpuzhash amount)
|
||||
prev_subtotal
|
||||
extra_delta
|
||||
)
|
||||
)
|
||||
; Coins locked with this puzzle are spendable cats.
|
||||
;
|
||||
; Choose a list of n inputs (n>=1), I_1, ... I_n with amounts A_1, ... A_n.
|
||||
;
|
||||
; We put them in a ring, so "previous" and "next" have intuitive k-1 and k+1 semantics,
|
||||
; wrapping so {n} and 0 are the same, ie. all indices are mod n.
|
||||
;
|
||||
; Each coin creates 0 or more coins with total output value O_k.
|
||||
; Let D_k = the "debt" O_k - A_k contribution of coin I_k, ie. how much debt this input accumulates.
|
||||
; Some coins may spend more than they contribute and some may spend less, ie. D_k need
|
||||
; not be zero. That's okay. It's enough for the total of all D_k in the ring to be 0.
|
||||
;
|
||||
; A coin can calculate its own D_k since it can verify A_k (it's hashed into the coin id)
|
||||
; and it can sum up `CREATE_COIN` conditions for O_k.
|
||||
;
|
||||
; Defines a "subtotal of debts" S_k for each coin as follows:
|
||||
;
|
||||
; S_1 = 0
|
||||
; S_k = S_{k-1} + D_{k-1}
|
||||
;
|
||||
; Here's the main trick that shows the ring sums to 0.
|
||||
; You can prove by induction that S_{k+1} = D_1 + D_2 + ... + D_k.
|
||||
; But it's a ring, so S_{n+1} is also S_1, which is 0. So D_1 + D_2 + ... + D_k = 0.
|
||||
; So the total debts must be 0, ie. no coins are created or destroyed.
|
||||
;
|
||||
; Each coin's solution includes I_{k-1}, I_k, and I_{k+1} along with proofs that I_{k}, and I_{k+1} are CATs of the same type.
|
||||
; Each coin's solution includes S_{k-1}. It calculates D_k = O_k - A_k, and then S_k = S_{k-1} + D_{k-1}
|
||||
;
|
||||
; Announcements are used to ensure that each S_k follows the pattern is valid.
|
||||
; Announcements automatically commit to their own coin id.
|
||||
; Coin I_k creates an announcement that further commits to I_{k-1} and S_{k-1}.
|
||||
;
|
||||
; Coin I_k gets a proof that I_{k+1} is a cat, so it knows it must also create an announcement
|
||||
; when spent. It checks that I_{k+1} creates an announcement committing to I_k and S_k.
|
||||
;
|
||||
; So S_{k+1} is correct iff S_k is correct.
|
||||
;
|
||||
; Coins also receive proofs that their neighbours are CATs, ensuring the announcements aren't forgeries.
|
||||
; Inner puzzles and the CAT layer prepend `CREATE_COIN_ANNOUNCEMENT` with different prefixes to avoid forgeries.
|
||||
; Ring announcements use 0xcb, and inner puzzles are given 0xca
|
||||
;
|
||||
; In summary, I_k generates a coin_announcement Y_k ("Y" for "yell") as follows:
|
||||
;
|
||||
; Y_k: hash of I_k (automatically), I_{k-1}, S_k
|
||||
;
|
||||
; Each coin creates an assert_coin_announcement to ensure that the next coin's announcement is as expected:
|
||||
; Y_{k+1} : hash of I_{k+1}, I_k, S_{k+1}
|
||||
;
|
||||
; TLDR:
|
||||
; I_k : coins
|
||||
; A_k : amount coin k contributes
|
||||
; O_k : amount coin k spend
|
||||
; D_k : difference/delta that coin k incurs (A - O)
|
||||
; S_k : subtotal of debts D_1 + D_2 ... + D_k
|
||||
; Y_k : announcements created by coin k committing to I_{k-1}, I_k, S_k
|
||||
;
|
||||
; All conditions go through a "transformer" that looks for CREATE_COIN conditions
|
||||
; generated by the inner solution, and wraps the puzzle hash ensuring the output is a cat.
|
||||
;
|
||||
; Three output conditions are prepended to the list of conditions for each I_k:
|
||||
; (ASSERT_MY_ID I_k) to ensure that the passed in value for I_k is correct
|
||||
; (CREATE_COIN_ANNOUNCEMENT I_{k-1} S_k) to create this coin's announcement
|
||||
; (ASSERT_COIN_ANNOUNCEMENT hashed_announcement(Y_{k+1})) to ensure the next coin really is next and
|
||||
; the relative values of S_k and S_{k+1} are correct
|
||||
;
|
||||
; This is all we need to do to ensure cats exactly balance in the inputs and outputs.
|
||||
;
|
||||
; Proof:
|
||||
; Consider n, k, I_k values, O_k values, S_k and A_k as above.
|
||||
; For the (CREATE_COIN_ANNOUNCEMENT Y_{k+1}) (created by the next coin)
|
||||
; and (ASSERT_COIN_ANNOUNCEMENT hashed(Y_{k+1})) to match,
|
||||
; we see that I_k can ensure that is has the correct value for S_{k+1}.
|
||||
;
|
||||
; By induction, we see that S_{m+1} = sum(i, 1, m) [O_i - A_i] = sum(i, 1, m) O_i - sum(i, 1, m) A_i
|
||||
; So S_{n+1} = sum(i, 1, n) O_i - sum(i, 1, n) A_i. But S_{n+1} is actually S_1 = 0,
|
||||
; so thus sum(i, 1, n) O_i = sum (i, 1, n) A_i, ie. output total equals input total.
|
||||
|
||||
;; GLOSSARY:
|
||||
;; MOD_HASH: this code's sha256 tree hash
|
||||
;; TAIL_PROGRAM_HASH: the program that determines if a coin can mint new cats, burn cats, and check if its lineage is valid if its parent is not a CAT
|
||||
;; INNER_PUZZLE: an independent puzzle protecting the coins. Solutions to this puzzle are expected to generate `AGG_SIG` conditions and possibly `CREATE_COIN` conditions.
|
||||
;; ---- items above are curried into the puzzle hash ----
|
||||
;; inner_puzzle_solution: the solution to the inner puzzle
|
||||
;; prev_coin_id: the id for the previous coin
|
||||
;; tail_program_reveal: reveal of TAIL_PROGRAM_HASH required to run the program if desired
|
||||
;; tail_solution: optional solution passed into tail_program
|
||||
;; lineage_proof: optional proof that our coin's parent is a CAT
|
||||
;; this_coin_info: (parent_id puzzle_hash amount)
|
||||
;; next_coin_proof: (parent_id inner_puzzle_hash amount)
|
||||
;; prev_subtotal: the subtotal between prev-coin and this-coin
|
||||
;; extra_delta: an amount that is added to our delta and checked by the TAIL program
|
||||
;;
|
||||
|
||||
(mod (
|
||||
MOD_HASH ;; curried into puzzle
|
||||
TAIL_PROGRAM_HASH ;; curried into puzzle
|
||||
INNER_PUZZLE ;; curried into puzzle
|
||||
inner_puzzle_solution ;; if invalid, INNER_PUZZLE will fail
|
||||
lineage_proof ;; This is the parent's coin info, used to check if the parent was a CAT. Optional if using tail_program.
|
||||
prev_coin_id ;; used in this coin's announcement, prev_coin ASSERT_COIN_ANNOUNCEMENT will fail if wrong
|
||||
this_coin_info ;; verified with ASSERT_MY_COIN_ID
|
||||
next_coin_proof ;; used to generate ASSERT_COIN_ANNOUNCEMENT
|
||||
prev_subtotal ;; included in announcement, prev_coin ASSERT_COIN_ANNOUNCEMENT will fail if wrong
|
||||
extra_delta ;; this is the "legal discrepancy" between your real delta and what you're announcing your delta is
|
||||
)
|
||||
|
||||
;;;;; start library code
|
||||
|
||||
(include condition_codes.clib)
|
||||
(include curry-and-treehash.clib)
|
||||
(include cat_truths.clib)
|
||||
(include utility_macros.clib)
|
||||
|
||||
(defconstant RING_MORPH_BYTE 0xcb)
|
||||
|
||||
|
||||
; 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
|
||||
)
|
||||
)
|
||||
|
||||
; cat_mod_struct = (MOD_HASH MOD_HASH_hash GENESIS_COIN_CHECKER GENESIS_COIN_CHECKER_hash)
|
||||
|
||||
(defun-inline mod_hash_from_cat_mod_struct (cat_mod_struct) (f cat_mod_struct))
|
||||
(defun-inline mod_hash_hash_from_cat_mod_struct (cat_mod_struct) (f (r cat_mod_struct)))
|
||||
(defun-inline tail_program_hash_from_cat_mod_struct (cat_mod_struct) (f (r (r cat_mod_struct))))
|
||||
|
||||
;;;;; end library code
|
||||
|
||||
;; return the puzzle hash for a cat with the given `GENESIS_COIN_CHECKER_hash` & `INNER_PUZZLE`
|
||||
(defun-inline cat_puzzle_hash (cat_mod_struct inner_puzzle_hash)
|
||||
(puzzle-hash-of-curried-function (mod_hash_from_cat_mod_struct cat_mod_struct)
|
||||
inner_puzzle_hash
|
||||
(sha256 ONE (tail_program_hash_from_cat_mod_struct cat_mod_struct))
|
||||
(mod_hash_hash_from_cat_mod_struct cat_mod_struct)
|
||||
)
|
||||
)
|
||||
|
||||
;; assert `CREATE_COIN_ANNOUNCEMENT` doesn't contain the RING_MORPH_BYTE bytes so it cannot be used to cheat the coin ring
|
||||
|
||||
(defun-inline morph_condition (condition cat_mod_struct)
|
||||
(if (= (f condition) CREATE_COIN)
|
||||
(c CREATE_COIN
|
||||
(c (cat_puzzle_hash cat_mod_struct (f (r condition)))
|
||||
(r (r condition)))
|
||||
)
|
||||
(if (= (f condition) CREATE_COIN_ANNOUNCEMENT)
|
||||
(assert (not (and
|
||||
(= 33 (strlen (f (r condition))))
|
||||
(= (substr (f (r condition)) 0 ONE) RING_MORPH_BYTE) ; lazy eval
|
||||
))
|
||||
; then
|
||||
condition
|
||||
)
|
||||
condition
|
||||
)
|
||||
)
|
||||
)
|
||||
|
||||
;; given a coin's parent, inner_puzzle and amount, and the cat_mod_struct, calculate the id of the coin
|
||||
(defun-inline coin_id_for_proof (coin cat_mod_struct)
|
||||
(calculate_coin_id (f coin) (cat_puzzle_hash cat_mod_struct (f (r coin))) (f (r (r coin))))
|
||||
)
|
||||
|
||||
;; utility to fetch coin amount from coin
|
||||
(defun-inline input_amount_for_coin (coin)
|
||||
(f (r (r coin)))
|
||||
)
|
||||
|
||||
;; calculate the hash of an announcement
|
||||
;; we add 0xcb so ring announcements exist in a different namespace to announcements from inner_puzzles
|
||||
(defun-inline calculate_annoucement_id (this_coin_id this_subtotal next_coin_id cat_mod_struct)
|
||||
(sha256 next_coin_id RING_MORPH_BYTE (sha256tree (list this_coin_id this_subtotal)))
|
||||
)
|
||||
|
||||
;; create the `ASSERT_COIN_ANNOUNCEMENT` condition that ensures the next coin's announcement is correct
|
||||
(defun-inline create_assert_next_announcement_condition (this_coin_id this_subtotal next_coin_id cat_mod_struct)
|
||||
(list ASSERT_COIN_ANNOUNCEMENT
|
||||
(calculate_annoucement_id this_coin_id
|
||||
this_subtotal
|
||||
next_coin_id
|
||||
cat_mod_struct
|
||||
)
|
||||
)
|
||||
)
|
||||
|
||||
;; here we commit to I_{k-1} and S_k
|
||||
;; we add 0xcb so ring announcements exist in a different namespace to announcements from inner_puzzles
|
||||
(defun-inline create_announcement_condition (prev_coin_id prev_subtotal)
|
||||
(list CREATE_COIN_ANNOUNCEMENT
|
||||
(concat RING_MORPH_BYTE (sha256tree (list prev_coin_id prev_subtotal)))
|
||||
)
|
||||
)
|
||||
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
|
||||
;; this function takes a condition and returns an integer indicating
|
||||
;; the value of all output coins created with CREATE_COIN. If it's not
|
||||
;; a CREATE_COIN condition, it returns 0.
|
||||
|
||||
(defun-inline output_value_for_condition (condition)
|
||||
(if (= (f condition) CREATE_COIN)
|
||||
(f (r (r condition)))
|
||||
0
|
||||
)
|
||||
)
|
||||
|
||||
;; add two conditions to the list of morphed conditions:
|
||||
;; CREATE_COIN_ANNOUNCEMENT for my announcement
|
||||
;; ASSERT_COIN_ANNOUNCEMENT for the next coin's announcement
|
||||
(defun-inline generate_final_output_conditions
|
||||
(
|
||||
prev_subtotal
|
||||
this_subtotal
|
||||
morphed_conditions
|
||||
prev_coin_id
|
||||
this_coin_id
|
||||
next_coin_id
|
||||
cat_mod_struct
|
||||
)
|
||||
(c (create_announcement_condition prev_coin_id prev_subtotal)
|
||||
(c (create_assert_next_announcement_condition this_coin_id this_subtotal next_coin_id cat_mod_struct)
|
||||
morphed_conditions)
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
;; This next section of code loops through all of the conditions to do three things:
|
||||
;; 1) Look for a "magic" value of -113 and, if one exists, filter it, and take note of the tail reveal and solution
|
||||
;; 2) Morph any CREATE_COIN or CREATE_COIN_ANNOUNCEMENT conditions
|
||||
;; 3) Sum the total output amount of all of the CREATE_COINs that are output by the inner puzzle
|
||||
;;
|
||||
;; After everything return a struct in the format (morphed_conditions . (output_sum . tail_reveal_and_solution))
|
||||
;; If multiple magic conditions are specified, the later one will take precedence
|
||||
|
||||
(defun-inline condition_tail_reveal (condition) (f (r (r (r condition)))))
|
||||
(defun-inline condition_tail_solution (condition) (f (r (r (r (r condition))))))
|
||||
|
||||
(defun cons_onto_first_and_add_to_second (morphed_condition output_value struct)
|
||||
(c (c morphed_condition (f struct)) (c (+ output_value (f (r struct))) (r (r struct))))
|
||||
)
|
||||
|
||||
(defun find_and_strip_tail_info (inner_conditions cat_mod_struct tail_reveal_and_solution)
|
||||
(if inner_conditions
|
||||
(if (= (output_value_for_condition (f inner_conditions)) -113) ; Checks this is a CREATE_COIN of value -113
|
||||
(find_and_strip_tail_info
|
||||
(r inner_conditions)
|
||||
cat_mod_struct
|
||||
(c (condition_tail_reveal (f inner_conditions)) (condition_tail_solution (f inner_conditions)))
|
||||
)
|
||||
(cons_onto_first_and_add_to_second
|
||||
(morph_condition (f inner_conditions) cat_mod_struct)
|
||||
(output_value_for_condition (f inner_conditions))
|
||||
(find_and_strip_tail_info
|
||||
(r inner_conditions)
|
||||
cat_mod_struct
|
||||
tail_reveal_and_solution
|
||||
)
|
||||
)
|
||||
)
|
||||
(c () (c 0 tail_reveal_and_solution))
|
||||
)
|
||||
)
|
||||
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;; lineage checking
|
||||
|
||||
;; return true iff parent of `this_coin_info` is provably a cat
|
||||
;; A 'lineage proof' consists of (parent_parent_id parent_INNER_puzzle_hash parent_amount)
|
||||
;; We use this information to construct a coin who's puzzle has been wrapped in this MOD and verify that,
|
||||
;; once wrapped, it matches our parent coin's ID.
|
||||
(defun-inline is_parent_cat (
|
||||
cat_mod_struct
|
||||
parent_id
|
||||
lineage_proof
|
||||
)
|
||||
(= parent_id
|
||||
(calculate_coin_id (f lineage_proof)
|
||||
(cat_puzzle_hash cat_mod_struct (f (r lineage_proof)))
|
||||
(f (r (r lineage_proof)))
|
||||
)
|
||||
)
|
||||
)
|
||||
|
||||
(defun check_lineage_or_run_tail_program
|
||||
(
|
||||
this_coin_info
|
||||
tail_reveal_and_solution
|
||||
parent_is_cat ; flag which says whether or not the parent CAT check ran and passed
|
||||
lineage_proof
|
||||
Truths
|
||||
extra_delta
|
||||
inner_conditions
|
||||
)
|
||||
(if tail_reveal_and_solution
|
||||
(assert (= (sha256tree (f tail_reveal_and_solution)) (cat_tail_program_hash_truth Truths))
|
||||
(merge_list
|
||||
(a (f tail_reveal_and_solution)
|
||||
(list
|
||||
Truths
|
||||
parent_is_cat
|
||||
lineage_proof ; Lineage proof is only guaranteed to be true if parent_is_cat
|
||||
extra_delta
|
||||
inner_conditions
|
||||
(r tail_reveal_and_solution)
|
||||
)
|
||||
)
|
||||
inner_conditions
|
||||
)
|
||||
)
|
||||
(assert parent_is_cat (not extra_delta)
|
||||
inner_conditions
|
||||
)
|
||||
)
|
||||
)
|
||||
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
|
||||
(defun stager_two (
|
||||
Truths
|
||||
(inner_conditions . (output_sum . tail_reveal_and_solution))
|
||||
lineage_proof
|
||||
prev_coin_id
|
||||
this_coin_info
|
||||
next_coin_id
|
||||
prev_subtotal
|
||||
extra_delta
|
||||
)
|
||||
(check_lineage_or_run_tail_program
|
||||
this_coin_info
|
||||
tail_reveal_and_solution
|
||||
(if lineage_proof (is_parent_cat (cat_struct_truth Truths) (my_parent_cat_truth Truths) lineage_proof) ())
|
||||
lineage_proof
|
||||
Truths
|
||||
extra_delta
|
||||
(generate_final_output_conditions
|
||||
prev_subtotal
|
||||
; the expression on the next line calculates `this_subtotal` by adding the delta to `prev_subtotal`
|
||||
(+ prev_subtotal (- (input_amount_for_coin this_coin_info) output_sum) extra_delta)
|
||||
inner_conditions
|
||||
prev_coin_id
|
||||
(my_id_cat_truth Truths)
|
||||
next_coin_id
|
||||
(cat_struct_truth Truths)
|
||||
)
|
||||
)
|
||||
)
|
||||
|
||||
; CAT TRUTHS struct is: ; CAT Truths is: ((Inner puzzle hash . (MOD hash . (MOD hash hash . TAIL hash))) . (my_id . (my_parent_info my_puzhash my_amount)))
|
||||
; create truths - this_coin_info verified true because we calculated my ID from it!
|
||||
; lineage proof is verified later by cat parent check or tail_program
|
||||
|
||||
(defun stager (
|
||||
cat_mod_struct
|
||||
inner_conditions
|
||||
lineage_proof
|
||||
inner_puzzle_hash
|
||||
my_id
|
||||
prev_coin_id
|
||||
this_coin_info
|
||||
next_coin_proof
|
||||
prev_subtotal
|
||||
extra_delta
|
||||
)
|
||||
(c (list ASSERT_MY_COIN_ID my_id) (stager_two
|
||||
(cat_truth_data_to_truth_struct
|
||||
inner_puzzle_hash
|
||||
cat_mod_struct
|
||||
my_id
|
||||
this_coin_info
|
||||
)
|
||||
(find_and_strip_tail_info inner_conditions cat_mod_struct ())
|
||||
lineage_proof
|
||||
prev_coin_id
|
||||
this_coin_info
|
||||
(coin_id_for_proof next_coin_proof cat_mod_struct)
|
||||
prev_subtotal
|
||||
extra_delta
|
||||
))
|
||||
)
|
||||
|
||||
(stager
|
||||
;; calculate cat_mod_struct, inner_puzzle_hash, coin_id
|
||||
(list MOD_HASH (sha256 ONE MOD_HASH) TAIL_PROGRAM_HASH)
|
||||
(a INNER_PUZZLE inner_puzzle_solution)
|
||||
lineage_proof
|
||||
(sha256tree INNER_PUZZLE)
|
||||
(calculate_coin_id (f this_coin_info) (f (r this_coin_info)) (f (r (r this_coin_info))))
|
||||
prev_coin_id ; ID
|
||||
this_coin_info ; (parent_id puzzle_hash amount)
|
||||
next_coin_proof ; (parent_id innerpuzhash amount)
|
||||
prev_subtotal
|
||||
extra_delta
|
||||
)
|
||||
)
|
||||
|
|
@ -1 +0,0 @@
|
|||
37bef360ee858133b69d595a906dc45d01af50379dad515eb9518abb7c1d2a7a
|
||||
|
|
@ -1 +0,0 @@
|
|||
94ec19077f9a34e0b11ad2456af0170f4cc03f11230ca42e3f82e6e644ac4f5d
|
||||
|
|
@ -1,5 +1,5 @@
|
|||
(mod (LAUNCHER_PH MINT_NUMBER MINT_TOTAL)
|
||||
(include condition_codes.clvm)
|
||||
(include condition_codes.clib)
|
||||
(list
|
||||
(list CREATE_COIN LAUNCHER_PH 1)
|
||||
(list CREATE_COIN_ANNOUNCEMENT (sha256 MINT_NUMBER MINT_TOTAL)))
|
||||
|
|
@ -1 +0,0 @@
|
|||
7a32d2d9571d3436791c0ad3d7fcfdb9c43ace2b0f0ff13f98d29f0cc093f445
|
||||
|
|
@ -1 +0,0 @@
|
|||
9d98ed08770d31be4bd1bde4705dab388db5e7e9c349f5a76fc3c347aa3a0b79
|
||||
|
|
@ -1 +0,0 @@
|
|||
92aa4bc8060a8836355a1884075141b4791ce1b67ae6092bb166b2845954bc89
|
||||
|
|
@ -1 +0,0 @@
|
|||
fe94c58f1117afe315e0450daca1c62460ec1a1c439cd4018d79967a5d7d1370
|
||||
|
|
@ -1,4 +1,4 @@
|
|||
; This is a "limitations_program" for use with cat.clvm.
|
||||
; This is a "limitations_program" for use with cat.clsp.
|
||||
(mod (
|
||||
PUBKEY
|
||||
Truths
|
||||
|
|
@ -12,7 +12,7 @@
|
|||
)
|
||||
)
|
||||
|
||||
(include condition_codes.clvm)
|
||||
(include condition_codes.clib)
|
||||
|
||||
(defun sha256tree1 (TREE)
|
||||
(if (l TREE)
|
||||
|
|
@ -22,4 +22,4 @@
|
|||
(c (list AGG_SIG_UNSAFE PUBKEY (sha256tree1 delegated_puzzle))
|
||||
(a delegated_puzzle (c Truths (c parent_is_cat (c lineage_proof (c delta (c inner_conditions delegated_solution))))))
|
||||
)
|
||||
)
|
||||
)
|
||||
|
|
@ -1 +0,0 @@
|
|||
999c3696e167f8a79d938adc11feba3a3dcb39ccff69a426d570706e7b8ec399
|
||||
|
|
@ -0,0 +1,43 @@
|
|||
{
|
||||
"block_program_zero": "f0a38c8efe58895ae527c65c37f700a4238504691b83990e5dd91bd8b3c30eae",
|
||||
"calculate_synthetic_public_key": "624c5d5704d0decadfc0503e71bbffb6cdfe45025bce7cf3e6864d1eafe8f65e",
|
||||
"cat_v2": "37bef360ee858133b69d595a906dc45d01af50379dad515eb9518abb7c1d2a7a",
|
||||
"chialisp_deserialisation": "94ec19077f9a34e0b11ad2456af0170f4cc03f11230ca42e3f82e6e644ac4f5d",
|
||||
"create_nft_launcher_from_did": "7a32d2d9571d3436791c0ad3d7fcfdb9c43ace2b0f0ff13f98d29f0cc093f445",
|
||||
"decompress_coin_spend_entry": "9d98ed08770d31be4bd1bde4705dab388db5e7e9c349f5a76fc3c347aa3a0b79",
|
||||
"decompress_coin_spend_entry_with_prefix": "92aa4bc8060a8836355a1884075141b4791ce1b67ae6092bb166b2845954bc89",
|
||||
"decompress_puzzle": "fe94c58f1117afe315e0450daca1c62460ec1a1c439cd4018d79967a5d7d1370",
|
||||
"delegated_tail": "999c3696e167f8a79d938adc11feba3a3dcb39ccff69a426d570706e7b8ec399",
|
||||
"did_innerpuz": "33143d2bef64f14036742673afd158126b94284b4530a28c354fac202b0c910e",
|
||||
"everything_with_signature": "1720d13250a7c16988eaf530331cefa9dd57a76b2c82236bec8bbbff91499b89",
|
||||
"genesis_by_coin_id": "493afb89eed93ab86741b2aa61b8f5de495d33ff9b781dfc8919e602b2afa150",
|
||||
"genesis_by_puzzle_hash": "de5a6e06d41518be97ff6365694f4f89475dda773dede267caa33da63b434e36",
|
||||
"graftroot_dl_offers": "0893e36a88c064fddfa6f8abdb42c044584a98cb4273b80cccc83b4867b701a1",
|
||||
"nft_intermediate_launcher": "7a32d2d9571d3436791c0ad3d7fcfdb9c43ace2b0f0ff13f98d29f0cc093f445",
|
||||
"nft_metadata_updater_default": "fe8a4b4e27a2e29a4d3fc7ce9d527adbcaccbab6ada3903ccf3ba9a769d2d78b",
|
||||
"nft_metadata_updater_updateable": "0b1ffba1601777c06b78ab38636e9624f2f8da73be9b36e0ce17c8d8ef3bad9f",
|
||||
"nft_ownership_layer": "c5abea79afaa001b5427dfa0c8cf42ca6f38f5841b78f9b3c252733eb2de2726",
|
||||
"nft_ownership_transfer_program_one_way_claim_with_royalties": "025dee0fb1e9fa110302a7e9bfb6e381ca09618e2778b0184fa5c6b275cfce1f",
|
||||
"nft_state_layer": "a04d9f57764f54a43e4030befb4d80026e870519aaa66334aef8304f5d0393c2",
|
||||
"notification": "b8b9d8ffca6d5cba5422ead7f477ecfc8f6aaaa1c024b8c3aeb1956b24a0ab1e",
|
||||
"p2_conditions": "1c77d7d5efde60a7a1d2d27db6d746bc8e568aea1ef8586ca967a0d60b83cc36",
|
||||
"p2_delegated_conditions": "0ff94726f1a8dea5c3f70d3121945190778d3b2b3fcda3735a1f290977e98341",
|
||||
"p2_delegated_puzzle": "542cde70d1102cd1b763220990873efc8ab15625ded7eae22cc11e21ef2e2f7c",
|
||||
"p2_delegated_puzzle_or_hidden_puzzle": "e9aaa49f45bad5c889b86ee3341550c155cfdd10c3a6757de618d20612fffd52",
|
||||
"p2_m_of_n_delegate_direct": "0f199d5263ac1a62b077c159404a71abd3f9691cc57520bf1d4c5cb501504457",
|
||||
"p2_parent": "b10ce2d0b18dcf8c21ddfaf55d9b9f0adcbf1e0beb55b1a8b9cad9bbff4e5f22",
|
||||
"p2_puzzle_hash": "13e29a62b42cd2ef72a79e4bacdc59733ca6310d65af83d349360d36ec622363",
|
||||
"p2_singleton": "40f828d8dd55603f4ff9fbf6b73271e904e69406982f4fbefae2c8dcceaf9834",
|
||||
"p2_singleton_or_delayed_puzhash": "adb656e0211e2ab4f42069a4c5efc80dc907e7062be08bf1628c8e5b6d94d25b",
|
||||
"pool_member_innerpuz": "a8490702e333ddd831a3ac9c22d0fa26d2bfeaf2d33608deb22f0e0123eb0494",
|
||||
"pool_waitingroom_innerpuz": "a317541a765bf8375e1c6e7c13503d0d2cbf56cacad5182befe947e78e2c0307",
|
||||
"rom_bootstrap_generator": "161bade1f822dcd62ab712ebaf30f3922a301e48a639e4295c5685f8bece7bd9",
|
||||
"settlement_payments": "cfbfdeed5c4ca2de3d0bf520b9cb4bb7743a359bd2e6a188d19ce7dffc21d3e7",
|
||||
"settlement_payments_old": "bae24162efbd568f89bc7a340798a6118df0189eb9e3f8697bcea27af99f8f79",
|
||||
"sha256tree_module": "eb4ead6576048c9d730b5ced00646c7fdd390649cfdf48a00de1590cdd8ee18f",
|
||||
"singleton_launcher": "eff07522495060c066f66f32acc2a77e3a3e737aca8baea4d1a64ea4cdc13da9",
|
||||
"singleton_top_layer": "24e044101e57b3d8c908b8a38ad57848afd29d3eecc439dba45f4412df4954fd",
|
||||
"singleton_top_layer_v1_1": "7faa3253bfddd1e0decb0906b2dc6247bbc4cf608f58345d173adb63e8b47c9f",
|
||||
"test_generator_deserialize": "52add794fc76e89512e4a063c383418bda084c8a78c74055abe80179e4a7832c",
|
||||
"test_multiple_generator_input_arguments": "156dafbddc3e1d3bfe1f2a84e48e5e46b287b8358bf65c3c091c93e855fbfc5b"
|
||||
}
|
||||
|
|
@ -24,8 +24,8 @@
|
|||
;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.clvm)
|
||||
(include curry-and-treehash.clinc)
|
||||
(include condition_codes.clib)
|
||||
(include curry-and-treehash.clib)
|
||||
|
||||
; takes a lisp tree and returns the hash of it
|
||||
(defun sha256tree1 (TREE)
|
||||
|
|
@ -52,7 +52,7 @@
|
|||
|
||||
|
||||
; return the full puzzlehash for a singleton with the innerpuzzle curried in
|
||||
; puzzle-hash-of-curried-function is imported from curry-and-treehash.clinc
|
||||
; 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
|
||||
|
|
@ -1 +0,0 @@
|
|||
33143d2bef64f14036742673afd158126b94284b4530a28c354fac202b0c910e
|
||||
|
|
@ -1,4 +1,4 @@
|
|||
; This is a "limitations_program" for use with cat.clvm.
|
||||
; This is a "limitations_program" for use with cat.clsp.
|
||||
(mod (
|
||||
PUBKEY
|
||||
Truths
|
||||
|
|
@ -9,7 +9,7 @@
|
|||
_
|
||||
)
|
||||
|
||||
(include condition_codes.clvm)
|
||||
(include condition_codes.clib)
|
||||
|
||||
(list (list AGG_SIG_ME PUBKEY delta)) ; Careful with a delta of zero, the bytecode is 80 not 00
|
||||
)
|
||||
)
|
||||
|
|
@ -1 +0,0 @@
|
|||
1720d13250a7c16988eaf530331cefa9dd57a76b2c82236bec8bbbff91499b89
|
||||
|
|
@ -1 +0,0 @@
|
|||
493afb89eed93ab86741b2aa61b8f5de495d33ff9b781dfc8919e602b2afa150
|
||||
|
|
@ -1,4 +1,4 @@
|
|||
; This is a "limitations_program" for use with cat.clvm.
|
||||
; This is a "limitations_program" for use with cat.clsp.
|
||||
;
|
||||
; This checker allows new CATs to be created if their parent has a particular puzzle hash
|
||||
(mod (
|
||||
|
|
@ -1 +0,0 @@
|
|||
de5a6e06d41518be97ff6365694f4f89475dda773dede267caa33da63b434e36
|
||||
|
|
@ -11,9 +11,9 @@
|
|||
inner_solution
|
||||
)
|
||||
|
||||
(include condition_codes.clvm)
|
||||
(include condition_codes.clib)
|
||||
(include merkle_utils.clib)
|
||||
(include curry-and-treehash.clinc)
|
||||
(include curry-and-treehash.clib)
|
||||
|
||||
(defmacro assert items
|
||||
(if (r items)
|
||||
|
|
@ -1 +0,0 @@
|
|||
0893e36a88c064fddfa6f8abdb42c044584a98cb4273b80cccc83b4867b701a1
|
||||
|
|
@ -82,8 +82,8 @@ def load_serialized_clvm(
|
|||
clvm_filename, package_or_requirement=__name__, include_standard_libraries: bool = False, recompile: bool = True
|
||||
) -> SerializedProgram:
|
||||
"""
|
||||
This function takes a .clvm file in the given package and compiles it to a
|
||||
.clvm.hex file if the .hex file is missing or older than the .clvm file, then
|
||||
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
|
||||
|
|
|
|||
|
|
@ -1,2 +0,0 @@
|
|||
; a trivial puzzle used as the core of a lock puzzle
|
||||
(mod args (q ()))
|
||||
|
|
@ -1 +0,0 @@
|
|||
ff01ff8080
|
||||
|
|
@ -1 +0,0 @@
|
|||
f3a579254623f8094e07af862df2e45c9db5592b4105d34a256dd6c498416288
|
||||
|
|
@ -1,5 +1,5 @@
|
|||
(mod (LAUNCHER_PH MINT_NUMBER MINT_TOTAL)
|
||||
(include condition_codes.clvm)
|
||||
(include condition_codes.clib)
|
||||
(list
|
||||
(list CREATE_COIN LAUNCHER_PH 1)
|
||||
(list CREATE_COIN_ANNOUNCEMENT (sha256 MINT_NUMBER MINT_TOTAL)))
|
||||
|
|
@ -1 +0,0 @@
|
|||
7a32d2d9571d3436791c0ad3d7fcfdb9c43ace2b0f0ff13f98d29f0cc093f445
|
||||
|
|
@ -1 +0,0 @@
|
|||
fe8a4b4e27a2e29a4d3fc7ce9d527adbcaccbab6ada3903ccf3ba9a769d2d78b
|
||||
|
|
@ -1 +0,0 @@
|
|||
0b1ffba1601777c06b78ab38636e9624f2f8da73be9b36e0ce17c8d8ef3bad9f
|
||||
|
|
@ -6,8 +6,8 @@
|
|||
inner_solution
|
||||
)
|
||||
|
||||
(include condition_codes.clvm)
|
||||
(include curry-and-treehash.clinc)
|
||||
(include condition_codes.clib)
|
||||
(include curry-and-treehash.clib)
|
||||
(include utility_macros.clib)
|
||||
|
||||
(defconstant NEW_OWNER_CONDITION -10)
|
||||
|
|
@ -1 +0,0 @@
|
|||
c5abea79afaa001b5427dfa0c8cf42ca6f38f5841b78f9b3c252733eb2de2726
|
||||
|
|
@ -10,13 +10,13 @@
|
|||
|
||||
; This is a transfer program - which must return (new_owner, Optional[new_transfer_program], conditions)
|
||||
|
||||
(include condition_codes.clvm)
|
||||
(include curry-and-treehash.clinc)
|
||||
(include condition_codes.clib)
|
||||
(include curry-and-treehash.clib)
|
||||
|
||||
(defconstant TEN_THOUSAND 10000)
|
||||
|
||||
;; return the full puzzlehash for a singleton with the innerpuzzle curried in
|
||||
; puzzle-hash-of-curried-function is imported from curry-and-treehash.clinc
|
||||
; 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
|
||||
|
|
@ -1 +0,0 @@
|
|||
025dee0fb1e9fa110302a7e9bfb6e381ca09618e2778b0184fa5c6b275cfce1f
|
||||
|
|
@ -6,8 +6,8 @@
|
|||
inner_solution
|
||||
)
|
||||
|
||||
(include condition_codes.clvm)
|
||||
(include curry-and-treehash.clinc)
|
||||
(include condition_codes.clib)
|
||||
(include curry-and-treehash.clib)
|
||||
(include utility_macros.clib)
|
||||
|
||||
(defun-inline nft_state_layer_puzzle_hash (NFT_STATE_LAYER_MOD_HASH METADATA METADATA_UPDATER_PUZZLE_HASH inner_puzzle_hash)
|
||||
|
|
@ -1 +0,0 @@
|
|||
a04d9f57764f54a43e4030befb4d80026e870519aaa66334aef8304f5d0393c2
|
||||
|
|
@ -2,6 +2,6 @@
|
|||
TARGET
|
||||
AMOUNT
|
||||
)
|
||||
(include condition_codes.clvm)
|
||||
(include condition_codes.clib)
|
||||
(list (list CREATE_COIN TARGET AMOUNT) (list CREATE_COIN_ANNOUNCEMENT ()))
|
||||
)
|
||||
|
|
@ -1 +0,0 @@
|
|||
b8b9d8ffca6d5cba5422ead7f477ecfc8f6aaaa1c024b8c3aeb1956b24a0ab1e
|
||||
|
|
@ -1 +0,0 @@
|
|||
1c77d7d5efde60a7a1d2d27db6d746bc8e568aea1ef8586ca967a0d60b83cc36
|
||||
|
|
@ -16,7 +16,7 @@ from chia.types.blockchain_format.program import Program
|
|||
|
||||
from .load_clvm import load_clvm_maybe_recompile
|
||||
|
||||
MOD = load_clvm_maybe_recompile("p2_conditions.clvm")
|
||||
MOD = load_clvm_maybe_recompile("p2_conditions.clsp")
|
||||
|
||||
|
||||
def puzzle_for_conditions(conditions) -> Program:
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
(mod
|
||||
(public_key conditions)
|
||||
|
||||
(include condition_codes.clvm)
|
||||
(include condition_codes.clib)
|
||||
|
||||
;; hash a tree
|
||||
;; This is used to calculate a puzzle hash given a puzzle program.
|
||||
|
|
@ -1 +0,0 @@
|
|||
0ff94726f1a8dea5c3f70d3121945190778d3b2b3fcda3735a1f290977e98341
|
||||
|
|
@ -12,7 +12,7 @@ from chia.types.blockchain_format.program import Program
|
|||
|
||||
from .load_clvm import load_clvm_maybe_recompile
|
||||
|
||||
MOD = load_clvm_maybe_recompile("p2_delegated_conditions.clvm")
|
||||
MOD = load_clvm_maybe_recompile("p2_delegated_conditions.clsp")
|
||||
|
||||
|
||||
def puzzle_for_pk(public_key: Program) -> Program:
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
(public_key delegated_puzzle delegated_puzzle_solution)
|
||||
|
||||
(include condition_codes.clvm)
|
||||
(include condition_codes.clib)
|
||||
|
||||
;; hash a tree
|
||||
;; This is used to calculate a puzzle hash given a puzzle program.
|
||||
|
|
@ -1 +0,0 @@
|
|||
542cde70d1102cd1b763220990873efc8ab15625ded7eae22cc11e21ef2e2f7c
|
||||
|
|
@ -19,7 +19,7 @@ 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.clvm")
|
||||
MOD = load_clvm_maybe_recompile("p2_delegated_puzzle.clsp")
|
||||
|
||||
|
||||
def puzzle_for_pk(public_key: bytes) -> Program:
|
||||
|
|
|
|||
|
|
@ -47,7 +47,7 @@
|
|||
)
|
||||
)
|
||||
|
||||
(include condition_codes.clvm)
|
||||
(include condition_codes.clib)
|
||||
|
||||
;; hash a tree
|
||||
;; This is used to calculate a puzzle hash given a puzzle program.
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue