chia-blockchain 2.5.1rc1__py3-none-any.whl

chia/_tests/clvm/test_program.py

@@ -0,0 +1,150 @@
+from __future__ import annotations
+
+import pytest
+from clvm.EvalError import EvalError
+from clvm.operators import KEYWORD_TO_ATOM
+from clvm_tools.binutils import assemble, disassemble
+
+from chia.types.blockchain_format.program import Program
+
+
+def test_at():
+    p = Program.to([10, 20, 30, [15, 17], 40, 50])
+
+    assert p.first() == p.at("f")
+    assert Program.to(10) == p.at("f")
+
+    assert p.rest() == p.at("r")
+    assert Program.to([20, 30, [15, 17], 40, 50]) == p.at("r")
+
+    assert p.rest().rest().rest().first().rest().first() == p.at("rrrfrf")
+    assert Program.to(17) == p.at("rrrfrf")
+
+    with pytest.raises(ValueError):
+        p.at("q")
+
+    with pytest.raises(EvalError):
+        p.at("ff")
+
+
+def test_replace():
+    p1 = Program.to([100, 200, 300])
+    assert p1.replace(f=105) == Program.to([105, 200, 300])
+    assert p1.replace(rrf=[301, 302]) == Program.to([100, 200, [301, 302]])
+    assert p1.replace(f=105, rrf=[301, 302]) == Program.to([105, 200, [301, 302]])
+    assert p1.replace(f=100, r=200) == Program.to((100, 200))
+
+
+def test_replace_conflicts():
+    p1 = Program.to([100, 200, 300])
+    with pytest.raises(ValueError):
+        p1.replace(rr=105, rrf=200)
+
+
+def test_replace_conflicting_paths():
+    p1 = Program.to([100, 200, 300])
+    with pytest.raises(ValueError):
+        p1.replace(ff=105)
+
+
+def test_replace_bad_path():
+    p1 = Program.to([100, 200, 300])
+    with pytest.raises(ValueError):
+        p1.replace(q=105)
+    with pytest.raises(ValueError):
+        p1.replace(rq=105)
+
+
+def check_idempotency(f, *args):
+    prg = Program.to(f)
+    curried = prg.curry(*args)
+
+    r = disassemble(curried)
+    f_0, args_0 = curried.uncurry()
+
+    assert disassemble(f_0) == disassemble(f)
+    assert disassemble(args_0) == disassemble(Program.to(list(args)))
+    return r
+
+
+def test_curry_uncurry():
+    PLUS = KEYWORD_TO_ATOM["+"][0]
+    f = assemble("(+ 2 5)")
+    actual_disassembly = check_idempotency(f, 200, 30)
+    assert actual_disassembly == f"(a (q {PLUS} 2 5) (c (q . 200) (c (q . 30) 1)))"
+
+    f = assemble("(+ 2 5)")
+    args = assemble("(+ (q . 50) (q . 60))")
+    # passing "args" here wraps the arguments in a list
+    actual_disassembly = check_idempotency(f, args)
+    assert actual_disassembly == f"(a (q {PLUS} 2 5) (c (q {PLUS} (q . 50) (q . 60)) 1))"
+
+
+def test_uncurry_not_curried():
+    # this function has not been curried
+    plus = Program.to(assemble("(+ 2 5)"))
+    assert plus.uncurry() == (plus, Program.to(0))
+
+
+def test_uncurry():
+    # this is a positive test
+    plus = Program.to(assemble("(2 (q . (+ 2 5)) (c (q . 1) 1))"))
+    assert plus.uncurry() == (Program.to(assemble("(+ 2 5)")), Program.to([1]))
+
+
+def test_uncurry_top_level_garbage():
+    # there's garbage at the end of the top-level list
+    plus = Program.to(assemble("(2 (q . 1) (c (q . 1) (q . 1)) (q . 0x1337))"))
+    assert plus.uncurry() == (plus, Program.to(0))
+
+
+def test_uncurry_not_pair():
+    # the second item in the list is expected to be a pair, with a quote
+    plus = Program.to(assemble("(2 1 (c (q . 1) (q . 1)))"))
+    assert plus.uncurry() == (plus, Program.to(0))
+
+
+def test_uncurry_args_garbage():
+    # there's garbage at the end of the args list
+    plus = Program.to(assemble("(2 (q . 1) (c (q . 1) (q . 1) (q . 0x1337)))"))
+    assert plus.uncurry() == (plus, Program.to(0))
+
+
+def test_run() -> None:
+    div = Program.to(assemble("(/ 2 5)"))
+    ret = div.run([10, 5])
+    assert ret.atom == bytes([2])
+
+    ret = div.run([10, -5])
+    assert ret.atom == bytes([0xFE])
+
+    # run()
+    cost, ret = div.run_with_cost(100000, [10, -5], 0)
+    assert cost == 1107
+    print(ret)
+    assert ret.atom == bytes([0xFE])
+
+    cost, ret = div.run_with_cost(100000, [10, -5], 0)
+    assert cost == 1107
+    print(ret)
+    assert ret.atom == bytes([0xFE])
+
+    # run_with_flags()
+    cost, ret = div.run_with_flags(100000, 0, [10, -5])
+    assert cost == 1107
+    print(ret)
+    assert ret.atom == bytes([0xFE])
+
+    cost, ret = div.run_with_flags(100000, 0, [10, -5])
+    assert cost == 1107
+    print(ret)
+    assert ret.atom == bytes([0xFE])
+
+    # run_with_cost()
+    ret = div.run([10, -5], 100000, 0)
+    print(ret)
+    assert ret.atom == bytes([0xFE])
+
+    ret = div.run([10, -5], 100000, 0)
+    print(ret)
+    assert ret.atom == bytes([0xFE])

chia/_tests/clvm/test_puzzle_compression.py

@@ -0,0 +1,143 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from typing import Callable, SupportsBytes
+
+import pytest
+from chia_rs import G1Element, G2Element
+
+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, make_spend
+from chia.types.spend_bundle import SpendBundle
+from chia.util.ints import uint64
+from chia.wallet.cat_wallet.cat_utils import CAT_MOD, construct_cat_puzzle
+from chia.wallet.puzzles.p2_delegated_puzzle_or_hidden_puzzle import puzzle_for_pk
+from chia.wallet.trading.offer import OFFER_MOD
+from chia.wallet.util.puzzle_compression import (
+    LATEST_VERSION,
+    OFFER_MOD_OLD,
+    compress_object_with_puzzles,
+    decompress_object_with_puzzles,
+    lowest_best_version,
+)
+
+ONE_32 = bytes32([17] * 32)
+COIN = Coin(bytes32.zeros, bytes32.zeros, uint64(0))
+SOLUTION = Program.to([])
+
+
+log = logging.getLogger(__name__)
+
+
+@dataclass
+class CompressionReporter:
+    record_property: Callable
+
+    def __call__(self, name: str, original: SupportsBytes, compressed: SupportsBytes):
+        ratio = len(bytes(compressed)) / len(bytes(original))
+        self.record_property(name="compression_ratio", value=ratio)
+        log.warning(f"{name} compression ratio: {ratio}")
+
+
+@pytest.fixture(name="report_compression")
+def report_compression_fixture(record_property):
+    return CompressionReporter(record_property=record_property)
+
+
+def test_standard_puzzle(report_compression):
+    coin_spend = make_spend(
+        COIN,
+        puzzle_for_pk(G1Element()),
+        SOLUTION,
+    )
+    compressed = compress_object_with_puzzles(bytes(coin_spend), LATEST_VERSION)
+    assert len(bytes(coin_spend)) > len(compressed)
+    assert coin_spend == CoinSpend.from_bytes(decompress_object_with_puzzles(compressed))
+
+    report_compression(name="standard puzzle", original=coin_spend, compressed=compressed)
+
+
+def test_decompress_limit():
+    buffer = bytearray(10 * 1024 * 1024)
+    compressed = compress_object_with_puzzles(buffer, LATEST_VERSION)
+    print(len(compressed))
+    decompressed = decompress_object_with_puzzles(compressed)
+    print(len(decompressed))
+    assert len(decompressed) <= 6 * 1024 * 1024
+
+
+def test_cat_puzzle(report_compression):
+    coin_spend = make_spend(
+        COIN,
+        construct_cat_puzzle(CAT_MOD, Program.to([]).get_tree_hash(), Program.to(1)),
+        SOLUTION,
+    )
+    compressed = compress_object_with_puzzles(bytes(coin_spend), LATEST_VERSION)
+    assert len(bytes(coin_spend)) > len(compressed)
+    assert coin_spend == CoinSpend.from_bytes(decompress_object_with_puzzles(compressed))
+
+    report_compression(name="CAT puzzle", original=coin_spend, compressed=compressed)
+
+
+def test_offer_puzzle(report_compression):
+    coin_spend = make_spend(
+        COIN,
+        OFFER_MOD,
+        SOLUTION,
+    )
+    compressed = compress_object_with_puzzles(bytes(coin_spend), LATEST_VERSION)
+    assert len(bytes(coin_spend)) > len(compressed)
+    assert coin_spend == CoinSpend.from_bytes(decompress_object_with_puzzles(compressed))
+
+    report_compression(name="offer puzzle", original=coin_spend, compressed=compressed)
+
+
+def test_nesting_puzzles(report_compression):
+    coin_spend = make_spend(
+        COIN,
+        construct_cat_puzzle(CAT_MOD, Program.to([]).get_tree_hash(), puzzle_for_pk(G1Element())),
+        SOLUTION,
+    )
+    compressed = compress_object_with_puzzles(bytes(coin_spend), LATEST_VERSION)
+    assert len(bytes(coin_spend)) > len(compressed)
+    assert coin_spend == CoinSpend.from_bytes(decompress_object_with_puzzles(compressed))
+
+    report_compression(name="nesting puzzle", original=coin_spend, compressed=compressed)
+
+
+def test_unknown_wrapper(report_compression):
+    unknown = Program.to([2, 2, []])  # (a 2 ())
+    coin_spend = make_spend(
+        COIN,
+        unknown.curry(puzzle_for_pk(G1Element())),
+        SOLUTION,
+    )
+    compressed = compress_object_with_puzzles(bytes(coin_spend), LATEST_VERSION)
+    assert len(bytes(coin_spend)) > len(compressed)
+    assert coin_spend == CoinSpend.from_bytes(decompress_object_with_puzzles(compressed))
+
+    report_compression(name="unknown wrapper", original=coin_spend, compressed=compressed)
+
+
+def test_lowest_best_version():
+    assert lowest_best_version([bytes(CAT_MOD)]) == 4
+    assert lowest_best_version([bytes(OFFER_MOD_OLD)]) == 2
+    assert lowest_best_version([bytes(OFFER_MOD)]) == 5
+
+
+def test_version_override():
+    coin_spend = make_spend(
+        COIN,
+        OFFER_MOD,
+        SOLUTION,
+    )
+    spend_bundle = SpendBundle([coin_spend], G2Element())
+    compressed = compress_object_with_puzzles(bytes(spend_bundle), LATEST_VERSION)
+    compressed_earlier = compress_object_with_puzzles(bytes(spend_bundle), 1)
+    assert len(bytes(spend_bundle)) > len(bytes(compressed))
+    assert spend_bundle == SpendBundle.from_bytes(decompress_object_with_puzzles(compressed))
+    assert spend_bundle == SpendBundle.from_bytes(decompress_object_with_puzzles(compressed_earlier))
+    assert len(bytes(compressed_earlier)) > len(bytes(compressed))

chia/_tests/clvm/test_puzzle_drivers.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from typing import Any, Union
+
+import pytest
+
+from chia.types.blockchain_format.program import Program
+from chia.wallet.puzzle_drivers import PuzzleInfo, Solver
+
+
+def test_puzzle_info() -> None:
+    test_driver: dict[str, Any] = {
+        "string": "hello",
+        "bytes": "0xcafef00d",
+        "int": "123",
+        "program": "(q . 'hello')",
+        "zero": "0",
+        "nil": "()",
+    }
+    test_also: dict[str, Any] = {"type": "TEST", "string": "hello"}
+    test_driver["also"] = test_also
+
+    with pytest.raises(ValueError, match="A type is required"):
+        PuzzleInfo(test_driver)
+    solver = Solver(test_driver)
+
+    test_driver["type"] = "TEST"
+    puzzle_info = PuzzleInfo(test_driver)
+
+    assert puzzle_info.type() == "TEST"
+    assert puzzle_info.also() == PuzzleInfo(test_also)
+
+    capitalize_bytes = test_driver.copy()
+    capitalize_bytes["bytes"] = "0xCAFEF00D"
+    assert solver == Solver(capitalize_bytes)
+    assert puzzle_info == PuzzleInfo(capitalize_bytes)
+
+    obj: Union[PuzzleInfo, Solver]
+    for obj in (puzzle_info, solver):
+        assert obj["string"] == "hello"
+        assert obj["bytes"] == bytes.fromhex("cafef00d")
+        assert obj["int"] == 123
+        assert obj["program"] == Program.to((1, "hello"))
+        assert obj["zero"] == 0
+        assert obj["nil"] == Program.to([])

chia/_tests/clvm/test_puzzles.py

@@ -0,0 +1,242 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+
+from chia_rs import AugSchemeMPL, G1Element
+
+from chia._tests.clvm.coin_store import CoinStore, CoinTimestamp
+from chia._tests.core.make_block_generator import int_to_public_key
+from chia._tests.util.key_tool import KeyTool
+from chia.consensus.default_constants import DEFAULT_CONSTANTS
+from chia.types.blockchain_format.program import Program
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.coin_spend import make_spend
+from chia.types.spend_bundle import SpendBundle
+from chia.util.hash import std_hash
+from chia.util.ints import uint32, uint64
+from chia.wallet.puzzles import (
+    p2_conditions,
+    p2_delegated_conditions,
+    p2_delegated_puzzle,
+    p2_delegated_puzzle_or_hidden_puzzle,
+    p2_m_of_n_delegate_direct,
+    p2_puzzle_hash,
+)
+from chia.wallet.puzzles.puzzle_utils import make_create_coin_condition
+
+T1 = CoinTimestamp(1, uint32(10000000))
+T2 = CoinTimestamp(5, uint32(10003000))
+
+MAX_BLOCK_COST_CLVM = 10**18
+
+
+def secret_exponent_for_index(index: int) -> int:
+    blob = index.to_bytes(32, "big")
+    hashed_blob = AugSchemeMPL.key_gen(std_hash(b"foo" + blob))
+    r = int.from_bytes(hashed_blob, "big")
+    return r
+
+
+def public_key_for_index(index: int, key_lookup: KeyTool) -> bytes:
+    secret_exponent = secret_exponent_for_index(index)
+    key_lookup.add_secret_exponents([secret_exponent])
+    return bytes(int_to_public_key(secret_exponent))
+
+
+def throwaway_puzzle_hash(index: int, key_lookup: KeyTool) -> bytes32:
+    return p2_delegated_puzzle.puzzle_for_pk(public_key_for_index(index, key_lookup)).get_tree_hash()
+
+
+def do_test_spend(
+    puzzle_reveal: Program,
+    solution: Program,
+    payments: Iterable[tuple[bytes32, int]],
+    key_lookup: KeyTool,
+    farm_time: CoinTimestamp = T1,
+    spend_time: CoinTimestamp = T2,
+) -> SpendBundle:
+    """
+    This method will farm a coin paid to the hash of `puzzle_reveal`, then try to spend it
+    with `solution`, and verify that the created coins correspond to `payments`.
+
+    The `key_lookup` is used to create a signed version of the `SpendBundle`
+    """
+
+    coin_db = CoinStore(DEFAULT_CONSTANTS)
+
+    puzzle_hash = puzzle_reveal.get_tree_hash()
+
+    # farm it
+    coin = coin_db.farm_coin(puzzle_hash, farm_time)
+
+    # spend it
+    coin_spend = make_spend(coin, puzzle_reveal, solution)
+
+    # sign the solution
+    signature = key_lookup.signature_for_solution(coin_spend, DEFAULT_CONSTANTS.AGG_SIG_ME_ADDITIONAL_DATA)
+    spend_bundle = SpendBundle([coin_spend], signature)
+    coin_db.update_coin_store_for_spend_bundle(spend_bundle, spend_time, MAX_BLOCK_COST_CLVM)
+
+    # ensure all outputs are there
+    for puzzle_hash, amount in payments:
+        for coin in coin_db.coins_for_puzzle_hash(puzzle_hash):
+            if coin.amount == amount:
+                break
+        else:
+            assert 0
+
+    return spend_bundle
+
+
+def default_payments_and_conditions(
+    initial_index: int, key_lookup: KeyTool
+) -> tuple[list[tuple[bytes32, int]], Program]:
+    # the coin we get from coin_db.farm_coin only has amount 1024, so we can
+    # only make small payments to avoid failing with MINTING_COIN
+    payments = [
+        (throwaway_puzzle_hash(initial_index + 1, key_lookup), initial_index * 10),
+        (throwaway_puzzle_hash(initial_index + 2, key_lookup), (initial_index + 1) * 10),
+    ]
+    conditions = Program.to([make_create_coin_condition(ph, uint64(amount), []) for ph, amount in payments])
+    return payments, conditions
+
+
+def test_p2_conditions():
+    key_lookup = KeyTool()
+    payments, conditions = default_payments_and_conditions(1, key_lookup)
+
+    puzzle = p2_conditions.puzzle_for_conditions(conditions)
+    solution = p2_conditions.solution_for_conditions(conditions)
+
+    do_test_spend(puzzle, solution, payments, key_lookup)
+
+
+def test_p2_delegated_conditions():
+    key_lookup = KeyTool()
+    payments, conditions = default_payments_and_conditions(1, key_lookup)
+
+    pk = public_key_for_index(1, key_lookup)
+
+    puzzle = p2_delegated_conditions.puzzle_for_pk(pk)
+    solution = p2_delegated_conditions.solution_for_conditions(conditions)
+
+    do_test_spend(puzzle, solution, payments, key_lookup)
+
+
+def test_p2_delegated_puzzle_simple():
+    key_lookup = KeyTool()
+    payments, conditions = default_payments_and_conditions(1, key_lookup)
+
+    pk = public_key_for_index(1, key_lookup)
+
+    puzzle = p2_delegated_puzzle.puzzle_for_pk(pk)
+    solution = p2_delegated_puzzle.solution_for_conditions(conditions)
+
+    do_test_spend(puzzle, solution, payments, key_lookup)
+
+
+def test_p2_delegated_puzzle_graftroot():
+    key_lookup = KeyTool()
+    payments, conditions = default_payments_and_conditions(1, key_lookup)
+
+    delegated_puzzle = p2_delegated_conditions.puzzle_for_pk(public_key_for_index(8, key_lookup))
+    delegated_solution = p2_delegated_conditions.solution_for_conditions(conditions)
+
+    puzzle_program = p2_delegated_puzzle.puzzle_for_pk(public_key_for_index(1, key_lookup))
+    solution = p2_delegated_puzzle.solution_for_delegated_puzzle(delegated_puzzle, delegated_solution)
+
+    do_test_spend(puzzle_program, solution, payments, key_lookup)
+
+
+def test_p2_puzzle_hash():
+    key_lookup = KeyTool()
+    payments, conditions = default_payments_and_conditions(1, key_lookup)
+
+    inner_puzzle = p2_delegated_conditions.puzzle_for_pk(public_key_for_index(4, key_lookup))
+    inner_solution = p2_delegated_conditions.solution_for_conditions(conditions)
+    inner_puzzle_hash = inner_puzzle.get_tree_hash()
+
+    puzzle_program = p2_puzzle_hash.puzzle_for_inner_puzzle_hash(inner_puzzle_hash)
+    assert puzzle_program == p2_puzzle_hash.puzzle_for_inner_puzzle(inner_puzzle)
+    solution = p2_puzzle_hash.solution_for_inner_puzzle_and_inner_solution(inner_puzzle, inner_solution)
+
+    do_test_spend(puzzle_program, solution, payments, key_lookup)
+
+
+def test_p2_m_of_n_delegated_puzzle():
+    key_lookup = KeyTool()
+    payments, conditions = default_payments_and_conditions(1, key_lookup)
+
+    pks = [public_key_for_index(_, key_lookup) for _ in range(1, 6)]
+    M = 3
+
+    delegated_puzzle = p2_conditions.puzzle_for_conditions(conditions)
+    delegated_solution = []
+
+    puzzle_program = p2_m_of_n_delegate_direct.puzzle_for_m_of_public_key_list(M, pks)
+    selectors = [1, [], [], 1, 1]
+    solution = p2_m_of_n_delegate_direct.solution_for_delegated_puzzle(
+        M, selectors, delegated_puzzle, delegated_solution
+    )
+
+    do_test_spend(puzzle_program, solution, payments, key_lookup)
+
+
+def test_p2_delegated_puzzle_or_hidden_puzzle_with_hidden_puzzle():
+    key_lookup = KeyTool()
+    payments, conditions = default_payments_and_conditions(1, key_lookup)
+
+    hidden_puzzle = p2_conditions.puzzle_for_conditions(conditions)
+    hidden_public_key = public_key_for_index(10, key_lookup)
+
+    puzzle = p2_delegated_puzzle_or_hidden_puzzle.puzzle_for_public_key_and_hidden_puzzle(
+        G1Element.from_bytes_unchecked(hidden_public_key), hidden_puzzle
+    )
+    solution = p2_delegated_puzzle_or_hidden_puzzle.solution_for_hidden_puzzle(
+        G1Element.from_bytes_unchecked(hidden_public_key), hidden_puzzle, Program.to(0)
+    )
+
+    do_test_spend(puzzle, solution, payments, key_lookup)
+
+
+def do_test_spend_p2_delegated_puzzle_or_hidden_puzzle_with_delegated_puzzle(hidden_pub_key_index):
+    key_lookup = KeyTool()
+    _payments, conditions = default_payments_and_conditions(1, key_lookup)
+
+    hidden_puzzle = p2_conditions.puzzle_for_conditions(conditions)
+    hidden_public_key = public_key_for_index(hidden_pub_key_index, key_lookup)
+    hidden_pub_key_point = G1Element.from_bytes(hidden_public_key)
+
+    puzzle = p2_delegated_puzzle_or_hidden_puzzle.puzzle_for_public_key_and_hidden_puzzle(
+        hidden_pub_key_point, hidden_puzzle
+    )
+    payable_payments, payable_conditions = default_payments_and_conditions(5, key_lookup)
+
+    delegated_puzzle = p2_conditions.puzzle_for_conditions(payable_conditions)
+    delegated_solution = []
+
+    synthetic_public_key = p2_delegated_puzzle_or_hidden_puzzle.calculate_synthetic_public_key(
+        G1Element.from_bytes(hidden_public_key), hidden_puzzle.get_tree_hash()
+    )
+
+    solution = p2_delegated_puzzle_or_hidden_puzzle.solution_for_delegated_puzzle(delegated_puzzle, delegated_solution)
+
+    hidden_puzzle_hash = hidden_puzzle.get_tree_hash()
+    synthetic_offset = p2_delegated_puzzle_or_hidden_puzzle.calculate_synthetic_offset(
+        hidden_pub_key_point, hidden_puzzle_hash
+    )
+
+    assert synthetic_public_key == int_to_public_key(synthetic_offset) + hidden_pub_key_point
+
+    secret_exponent = key_lookup.dict[G1Element.from_bytes(hidden_public_key)]
+    assert int_to_public_key(secret_exponent) == hidden_pub_key_point
+
+    synthetic_secret_exponent = secret_exponent + synthetic_offset
+    key_lookup.add_secret_exponents([synthetic_secret_exponent])
+
+    do_test_spend(puzzle, solution, payable_payments, key_lookup)
+
+
+def test_p2_delegated_puzzle_or_hidden_puzzle_with_delegated_puzzle():
+    for hidden_pub_key_index in range(1, 10):
+        do_test_spend_p2_delegated_puzzle_or_hidden_puzzle_with_delegated_puzzle(hidden_pub_key_index)