chia-blockchain 2.4.4__py3-none-any.whl

chia/_tests/wallet/test_conditions.py

@@ -0,0 +1,388 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, List, Optional, Tuple, Type, Union
+
+import pytest
+from clvm.casts import int_from_bytes
+from clvm.EvalError import EvalError
+
+from chia.types.blockchain_format.program import Program
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.condition_opcodes import ConditionOpcode
+from chia.util.ints import uint32, uint64
+from chia.wallet.conditions import (
+    CONDITION_DRIVERS,
+    CONDITION_DRIVERS_W_ABSTRACTIONS,
+    AggSig,
+    AggSigAmount,
+    AggSigMe,
+    AggSigParent,
+    AggSigParentAmount,
+    AggSigParentPuzzle,
+    AggSigPuzzle,
+    AggSigPuzzleAmount,
+    AggSigUnsafe,
+    AssertAnnouncement,
+    AssertBeforeHeightAbsolute,
+    AssertBeforeHeightRelative,
+    AssertBeforeSecondsAbsolute,
+    AssertBeforeSecondsRelative,
+    AssertCoinAnnouncement,
+    AssertConcurrentPuzzle,
+    AssertConcurrentSpend,
+    AssertHeightAbsolute,
+    AssertHeightRelative,
+    AssertMyAmount,
+    AssertMyBirthHeight,
+    AssertMyBirthSeconds,
+    AssertMyCoinID,
+    AssertMyParentID,
+    AssertMyPuzzleHash,
+    AssertPuzzleAnnouncement,
+    AssertSecondsAbsolute,
+    AssertSecondsRelative,
+    Condition,
+    ConditionValidTimes,
+    CreateAnnouncement,
+    CreateCoin,
+    CreateCoinAnnouncement,
+    CreatePuzzleAnnouncement,
+    ReceiveMessage,
+    Remark,
+    ReserveFee,
+    SendMessage,
+    Softfork,
+    Timelock,
+    UnknownCondition,
+    conditions_from_json_dicts,
+    conditions_to_json_dicts,
+    parse_conditions_non_consensus,
+    parse_timelock_info,
+)
+
+
+@dataclass(frozen=True)
+class ConditionSerializations:
+    opcode: bytes
+    program_args: Program
+    json_keys: List[str]
+    json_args: List[Any]
+
+    @property
+    def program(self) -> Program:
+        prog: Program = Program.to(self.opcode).cons(self.program_args)
+        return prog
+
+
+HASH: bytes32 = bytes32([0] * 32)
+HASH_HEX: str = HASH.hex()
+PK: bytes = b"\xc0" + bytes(47)
+PK_HEX: str = PK.hex()
+AMT: int = 0
+MSG: bytes = bytes(1)
+MSG_HEX: str = MSG.hex()
+
+
+def test_completeness() -> None:
+    assert len(ConditionOpcode) == len(CONDITION_DRIVERS) == len(CONDITION_DRIVERS_W_ABSTRACTIONS)
+
+
+@pytest.mark.parametrize("abstractions", [True, False])
+@pytest.mark.parametrize(
+    "serializations",
+    [
+        ConditionSerializations(
+            ConditionOpcode.AGG_SIG_PARENT, Program.to([PK, MSG]), ["pubkey", "msg"], [PK_HEX, MSG_HEX]
+        ),
+        ConditionSerializations(
+            ConditionOpcode.AGG_SIG_PUZZLE, Program.to([PK, MSG]), ["pubkey", "msg"], [PK_HEX, MSG_HEX]
+        ),
+        ConditionSerializations(
+            ConditionOpcode.AGG_SIG_AMOUNT, Program.to([PK, MSG]), ["pubkey", "msg"], [PK_HEX, MSG_HEX]
+        ),
+        ConditionSerializations(
+            ConditionOpcode.AGG_SIG_PUZZLE_AMOUNT, Program.to([PK, MSG]), ["pubkey", "msg"], [PK_HEX, MSG_HEX]
+        ),
+        ConditionSerializations(
+            ConditionOpcode.AGG_SIG_PARENT_AMOUNT, Program.to([PK, MSG]), ["pubkey", "msg"], [PK_HEX, MSG_HEX]
+        ),
+        ConditionSerializations(
+            ConditionOpcode.AGG_SIG_PARENT_PUZZLE, Program.to([PK, MSG]), ["pubkey", "msg"], [PK_HEX, MSG_HEX]
+        ),
+        ConditionSerializations(
+            ConditionOpcode.AGG_SIG_UNSAFE, Program.to([PK, MSG]), ["pubkey", "msg"], [PK_HEX, MSG_HEX]
+        ),
+        ConditionSerializations(
+            ConditionOpcode.AGG_SIG_ME, Program.to([PK, MSG]), ["pubkey", "msg"], [PK_HEX, MSG_HEX]
+        ),
+        ConditionSerializations(
+            ConditionOpcode.CREATE_COIN,
+            Program.to([HASH, AMT, [MSG]]),
+            ["puzzle_hash", "amount", "memos"],
+            [HASH_HEX, AMT, [MSG_HEX]],
+        ),
+        ConditionSerializations(ConditionOpcode.RESERVE_FEE, Program.to([AMT]), ["amount"], [AMT]),
+        ConditionSerializations(ConditionOpcode.CREATE_COIN_ANNOUNCEMENT, Program.to([MSG]), ["msg"], [MSG_HEX]),
+        ConditionSerializations(ConditionOpcode.ASSERT_COIN_ANNOUNCEMENT, Program.to([HASH]), ["msg"], [HASH_HEX]),
+        ConditionSerializations(ConditionOpcode.CREATE_PUZZLE_ANNOUNCEMENT, Program.to([MSG]), ["msg"], [MSG_HEX]),
+        ConditionSerializations(ConditionOpcode.ASSERT_PUZZLE_ANNOUNCEMENT, Program.to([HASH]), ["msg"], [HASH_HEX]),
+        ConditionSerializations(ConditionOpcode.ASSERT_CONCURRENT_SPEND, Program.to([HASH]), ["coin_id"], [HASH_HEX]),
+        ConditionSerializations(
+            ConditionOpcode.ASSERT_CONCURRENT_PUZZLE, Program.to([HASH]), ["puzzle_hash"], [HASH_HEX]
+        ),
+        ConditionSerializations(ConditionOpcode.ASSERT_MY_COIN_ID, Program.to([HASH]), ["coin_id"], [HASH_HEX]),
+        ConditionSerializations(ConditionOpcode.ASSERT_MY_PARENT_ID, Program.to([HASH]), ["coin_id"], [HASH_HEX]),
+        ConditionSerializations(ConditionOpcode.ASSERT_MY_PUZZLEHASH, Program.to([HASH]), ["puzzle_hash"], [HASH_HEX]),
+        ConditionSerializations(ConditionOpcode.ASSERT_MY_AMOUNT, Program.to([AMT]), ["amount"], [AMT]),
+        ConditionSerializations(ConditionOpcode.ASSERT_MY_BIRTH_SECONDS, Program.to([AMT]), ["seconds"], [AMT]),
+        ConditionSerializations(ConditionOpcode.ASSERT_MY_BIRTH_HEIGHT, Program.to([AMT]), ["height"], [AMT]),
+        ConditionSerializations(ConditionOpcode.ASSERT_EPHEMERAL, Program.to([]), [], []),
+        ConditionSerializations(ConditionOpcode.ASSERT_SECONDS_RELATIVE, Program.to([AMT]), ["seconds"], [AMT]),
+        ConditionSerializations(ConditionOpcode.ASSERT_SECONDS_ABSOLUTE, Program.to([AMT]), ["seconds"], [AMT]),
+        ConditionSerializations(ConditionOpcode.ASSERT_HEIGHT_RELATIVE, Program.to([AMT]), ["height"], [AMT]),
+        ConditionSerializations(ConditionOpcode.ASSERT_HEIGHT_ABSOLUTE, Program.to([AMT]), ["height"], [AMT]),
+        ConditionSerializations(ConditionOpcode.ASSERT_BEFORE_SECONDS_RELATIVE, Program.to([AMT]), ["seconds"], [AMT]),
+        ConditionSerializations(ConditionOpcode.ASSERT_BEFORE_SECONDS_ABSOLUTE, Program.to([AMT]), ["seconds"], [AMT]),
+        ConditionSerializations(ConditionOpcode.ASSERT_BEFORE_HEIGHT_RELATIVE, Program.to([AMT]), ["height"], [AMT]),
+        ConditionSerializations(ConditionOpcode.ASSERT_BEFORE_HEIGHT_ABSOLUTE, Program.to([AMT]), ["height"], [AMT]),
+        ConditionSerializations(
+            ConditionOpcode.SOFTFORK,
+            Program.to([AMT, [-10, HASH]]),
+            ["cost", "conditions"],
+            [AMT, ["81f6", "a0" + HASH_HEX]],
+        ),
+        ConditionSerializations(ConditionOpcode.REMARK, Program.to([]), ["rest"], ["80"]),
+        ConditionSerializations(
+            ConditionOpcode.SEND_MESSAGE,
+            Program.to([0x3F, b"foobar", Program.to(HASH)]),
+            ["mode", "msg", "args"],
+            ["63", "0x" + b"foobar".hex(), "a0" + HASH_HEX],
+        ),
+        ConditionSerializations(
+            ConditionOpcode.RECEIVE_MESSAGE,
+            Program.to([0x3F, b"foobar", Program.to(HASH)]),
+            ["mode", "msg", "args"],
+            ["63", "0x" + b"foobar".hex(), "a0" + HASH_HEX],
+        ),
+    ],
+)
+def test_condition_serialization(serializations: ConditionSerializations, abstractions: bool) -> None:
+    condition_driver: Condition = parse_conditions_non_consensus([serializations.program], abstractions=abstractions)[0]
+    if not abstractions:
+        json = {
+            "opcode": int_from_bytes(serializations.opcode),
+            "args": {key: args for key, args in zip(serializations.json_keys, serializations.json_args)},
+        }
+        assert condition_driver == conditions_from_json_dicts([json])[0]
+        assert condition_driver == conditions_from_json_dicts(conditions_to_json_dicts([condition_driver]))[0]
+    assert not isinstance(condition_driver, UnknownCondition)
+    as_program: Program = condition_driver.to_program()
+    assert as_program.at("f").atom == serializations.opcode
+    assert as_program == serializations.program
+    assert condition_driver == condition_driver.__class__.from_json_dict(condition_driver.to_json_dict())
+
+
+def test_unknown_condition() -> None:
+    unknown_condition: Condition = parse_conditions_non_consensus([Program.to([-10, HASH, AMT])])[0]
+    assert unknown_condition == conditions_from_json_dicts([{"opcode": "81f6", "args": ["a0" + HASH_HEX, "80"]}])[0]
+    assert unknown_condition == conditions_from_json_dicts([{"opcode": -10, "args": ["a0" + HASH_HEX, "80"]}])[0]
+    with pytest.raises(ValueError, match="Invalid condition opcode"):
+        conditions_from_json_dicts([{"opcode": bytes(32)}])
+    assert unknown_condition == UnknownCondition(Program.to(-10), [Program.to(HASH), Program.to(AMT)])
+    assert unknown_condition == UnknownCondition.from_program(unknown_condition.to_program())
+
+
+@pytest.mark.parametrize(
+    "drivers",
+    [
+        (CreateCoinAnnouncement, AssertCoinAnnouncement),
+        (CreatePuzzleAnnouncement, AssertPuzzleAnnouncement),
+        (CreateAnnouncement, AssertAnnouncement),
+    ],
+)
+def test_announcement_inversions(
+    drivers: Union[
+        Tuple[Type[CreateCoinAnnouncement], Type[AssertCoinAnnouncement]],
+        Tuple[Type[CreatePuzzleAnnouncement], Type[AssertPuzzleAnnouncement]],
+        Tuple[Type[CreateAnnouncement], Type[AssertAnnouncement]],
+    ]
+) -> None:
+    create_driver, assert_driver = drivers
+    # mypy is not smart enough to understand that this `if` narrows down the potential types it could be
+    # This leads to the large number of type ignores below
+    if create_driver == CreateAnnouncement and assert_driver == AssertAnnouncement:
+        with pytest.raises(ValueError, match="Must specify either"):
+            assert_driver(True)  # type: ignore[arg-type]
+        with pytest.raises(ValueError, match="Cannot create"):
+            create_driver(MSG, True).corresponding_assertion()  # type: ignore[arg-type]
+        with pytest.raises(ValueError, match="Cannot create"):
+            assert_driver(True, MSG).corresponding_creation()  # type: ignore[arg-type]
+        create_instance = create_driver(MSG, True, HASH)  # type: ignore[call-arg, arg-type]
+        assert_instance = assert_driver(True, None, HASH, MSG)  # type: ignore[call-arg, arg-type]
+    else:
+        with pytest.raises(ValueError, match="Must specify either"):
+            assert_driver()  # type: ignore[call-arg]
+        with pytest.raises(ValueError, match="Cannot create"):
+            create_driver(MSG).corresponding_assertion()  # type: ignore[call-arg]
+        with pytest.raises(ValueError, match="Cannot create"):
+            assert_driver(MSG).corresponding_creation()  # type: ignore[arg-type]
+        create_instance = create_driver(MSG, HASH)  # type: ignore[arg-type]
+        assert_instance = assert_driver(None, HASH, MSG)  # type: ignore[arg-type]
+    assert_instance.to_program()  # Verifying that even without a specific message, we can still calculate the condition
+    assert create_instance.corresponding_assertion() == assert_instance
+    assert assert_instance.corresponding_creation() == create_instance
+
+
+@dataclass(frozen=True)
+class TimelockInfo:
+    drivers: List[Condition]
+    parsed_info: ConditionValidTimes
+    conditions_after: Optional[List[Condition]] = None
+
+
+@pytest.mark.parametrize(
+    "timelock_info",
+    [
+        TimelockInfo([AssertSecondsRelative(uint64(0))], ConditionValidTimes(min_secs_since_created=uint64(0))),
+        TimelockInfo([AssertHeightRelative(uint32(0))], ConditionValidTimes(min_blocks_since_created=uint32(0))),
+        TimelockInfo([AssertSecondsAbsolute(uint64(0))], ConditionValidTimes(min_time=uint64(0))),
+        TimelockInfo([AssertHeightAbsolute(uint32(0))], ConditionValidTimes(min_height=uint32(0))),
+        TimelockInfo([AssertBeforeSecondsRelative(uint64(0))], ConditionValidTimes(max_secs_after_created=uint64(0))),
+        TimelockInfo([AssertBeforeHeightRelative(uint32(0))], ConditionValidTimes(max_blocks_after_created=uint32(0))),
+        TimelockInfo([AssertBeforeSecondsAbsolute(uint64(0))], ConditionValidTimes(max_time=uint64(0))),
+        TimelockInfo([AssertBeforeHeightAbsolute(uint32(0))], ConditionValidTimes(max_height=uint32(0))),
+        TimelockInfo(
+            [Timelock(True, True, True, uint64(0))],
+            ConditionValidTimes(min_secs_since_created=uint64(0)),
+            [AssertSecondsRelative(uint64(0))],
+        ),
+        TimelockInfo(
+            [
+                AssertSecondsAbsolute(uint64(0)),
+                AssertSecondsAbsolute(uint64(10)),
+                AssertBeforeSecondsAbsolute(uint64(20)),
+                AssertBeforeSecondsAbsolute(uint64(10)),
+            ],
+            ConditionValidTimes(min_time=uint64(10), max_time=uint64(10)),
+            [
+                AssertSecondsAbsolute(uint64(10)),
+                AssertBeforeSecondsAbsolute(uint64(10)),
+            ],
+        ),
+    ],
+)
+def test_timelock_parsing(timelock_info: TimelockInfo) -> None:
+    assert timelock_info.parsed_info == parse_timelock_info(
+        [UnknownCondition(Program.to(None), []), *timelock_info.drivers]
+    )
+    assert timelock_info.parsed_info.to_conditions() == (
+        timelock_info.conditions_after if timelock_info.conditions_after is not None else timelock_info.drivers
+    )
+
+
+@pytest.mark.parametrize(
+    "cond",
+    [
+        AggSigParent,
+        AggSigPuzzle,
+        AggSigAmount,
+        AggSigPuzzleAmount,
+        AggSigParentAmount,
+        AggSigParentPuzzle,
+        AggSigUnsafe,
+        AggSigMe,
+        CreateCoin,
+        ReserveFee,
+        AssertCoinAnnouncement,
+        CreateCoinAnnouncement,
+        AssertPuzzleAnnouncement,
+        CreatePuzzleAnnouncement,
+        AssertConcurrentSpend,
+        AssertConcurrentPuzzle,
+        AssertMyCoinID,
+        AssertMyParentID,
+        AssertMyPuzzleHash,
+        AssertMyAmount,
+        AssertMyBirthSeconds,
+        AssertMyBirthHeight,
+        AssertSecondsRelative,
+        AssertSecondsAbsolute,
+        AssertHeightRelative,
+        AssertHeightAbsolute,
+        AssertBeforeSecondsRelative,
+        AssertBeforeSecondsAbsolute,
+        AssertBeforeHeightRelative,
+        AssertBeforeHeightAbsolute,
+        Softfork,
+        Remark,
+        UnknownCondition,
+        AggSig,
+        CreateAnnouncement,
+        AssertAnnouncement,
+        Timelock,
+        SendMessage,
+        ReceiveMessage,
+    ],
+)
+@pytest.mark.parametrize(
+    "prg",
+    [
+        bytes([0x80]),
+        bytes([0xFF, 0x80, 0xFF, 0xFF, 0xFF, 0x80, 0x80, 0x80, 0x80]),
+        bytes([0xFF, 0x80, 0xFF, 0xFF, 0x80, 0x80, 0xFF, 0x80, 0x80]),
+        bytes([0xFF, 0x80, 0xFF, 0xFF, 0x80, 0x80, 0xFF, 0x80, 0xFF, 0x80, 0x80]),
+        bytes([0xFF, 0x80, 0xFF, 0xFF, 0x80, 0x80, 0xFF, 0x80, 0xFF, 0x80, 0xFF, 0x80, 0x80]),
+    ],
+)
+def test_invalid_condition(
+    cond: Type[
+        Union[
+            AggSigParent,
+            AggSigPuzzle,
+            AggSigAmount,
+            AggSigPuzzleAmount,
+            AggSigParentAmount,
+            AggSigParentPuzzle,
+            AggSigUnsafe,
+            AggSigMe,
+            CreateCoin,
+            ReserveFee,
+            AssertCoinAnnouncement,
+            CreateCoinAnnouncement,
+            AssertPuzzleAnnouncement,
+            CreatePuzzleAnnouncement,
+            AssertConcurrentSpend,
+            AssertConcurrentPuzzle,
+            AssertMyCoinID,
+            AssertMyParentID,
+            AssertMyPuzzleHash,
+            AssertMyAmount,
+            AssertMyBirthSeconds,
+            AssertMyBirthHeight,
+            AssertSecondsRelative,
+            AssertSecondsAbsolute,
+            AssertHeightRelative,
+            AssertHeightAbsolute,
+            AssertBeforeSecondsRelative,
+            AssertBeforeSecondsAbsolute,
+            AssertBeforeHeightRelative,
+            AssertBeforeHeightAbsolute,
+            Softfork,
+            Remark,
+            UnknownCondition,
+            AggSig,
+            CreateAnnouncement,
+            AssertAnnouncement,
+            Timelock,
+            SendMessage,
+            ReceiveMessage,
+        ]
+    ],
+    prg: bytes,
+) -> None:
+    if (cond == Remark or cond == UnknownCondition) and prg != b"\x80":
+        pytest.skip("condition takes arbitrary arguments")
+
+    with pytest.raises((ValueError, EvalError, KeyError)):
+        cond.from_program(Program.from_bytes(prg))

chia/_tests/wallet/test_debug_spend_bundle.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+import sys
+from io import StringIO
+
+from chia_rs import AugSchemeMPL, PrivateKey
+
+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 make_spend
+from chia.types.condition_opcodes import ConditionOpcode
+from chia.util.hash import std_hash
+from chia.util.ints import uint64
+from chia.wallet.util.debug_spend_bundle import debug_spend_bundle
+from chia.wallet.wallet_spend_bundle import WalletSpendBundle
+
+
+def test_debug_spend_bundle() -> None:
+    sk = PrivateKey.from_bytes(bytes([1] * 32))
+    pk = sk.get_g1()
+    msg = bytes(32)
+    sig = AugSchemeMPL.sign(sk, msg)
+    ACS = Program.to(15).curry(Program.to("hey").curry("now")).curry("brown", "cow")
+    ACS_PH = ACS.get_tree_hash()
+    coin: Coin = Coin(bytes32([0] * 32), ACS_PH, uint64(3))
+    child_coin: Coin = Coin(coin.name(), ACS_PH, uint64(0))
+    coin_bad_reveal: Coin = Coin(bytes32([0] * 32), bytes32([0] * 32), uint64(0))
+    solution = Program.to(
+        [
+            [ConditionOpcode.AGG_SIG_UNSAFE, pk, msg],
+            [ConditionOpcode.REMARK],
+            [ConditionOpcode.CREATE_COIN, ACS_PH, 0],
+            [ConditionOpcode.CREATE_COIN, bytes32([0] * 32), 1],
+            [ConditionOpcode.CREATE_COIN, bytes32([0] * 32), 2, [b"memo", b"memo", b"memo"]],
+            [ConditionOpcode.CREATE_COIN_ANNOUNCEMENT, None],
+            [ConditionOpcode.ASSERT_COIN_ANNOUNCEMENT, bytes32([0] * 32)],
+            [ConditionOpcode.ASSERT_COIN_ANNOUNCEMENT, std_hash(coin.name())],
+            [ConditionOpcode.CREATE_COIN_ANNOUNCEMENT, b"hey"],
+            [ConditionOpcode.CREATE_PUZZLE_ANNOUNCEMENT, None],
+            [ConditionOpcode.ASSERT_PUZZLE_ANNOUNCEMENT, bytes32([0] * 32)],
+            [ConditionOpcode.ASSERT_PUZZLE_ANNOUNCEMENT, std_hash(coin.puzzle_hash)],
+            [ConditionOpcode.CREATE_PUZZLE_ANNOUNCEMENT, b"hey"],
+        ]
+    )
+
+    result = StringIO()
+    sys.stdout = result
+
+    debug_spend_bundle(
+        WalletSpendBundle(
+            [
+                make_spend(
+                    coin_bad_reveal,
+                    ACS,
+                    Program.to(None),
+                ),
+                make_spend(
+                    coin,
+                    ACS,
+                    solution,
+                ),
+                make_spend(
+                    child_coin,
+                    ACS,
+                    Program.to(None),
+                ),
+            ],
+            sig,
+        )
+    )
+
+    assert (
+        result.getvalue()
+        == '================================================================================\nconsuming coin (0x0000000000000000000000000000000000000000000000000000000000000000 0x0000000000000000000000000000000000000000000000000000000000000000 ())\n  with id f5a5fd42d16a20302798ef6ed309979b43003d2320d9f0e8ea9831a92759fb4b\n\n\nbrun -y main.sym \'(a (q 2 (q . 15) (c (q 2 (q . "hey") (c (q . "now") 1)) 1)) (c (q . "brown") (c (q . "cow") 1)))\' \'()\'\n\n--- Uncurried Args ---\n- <curried puzzle>\n  - Layer 1:\n    - Mod hash: 507414e217dc45d6dbb923077c48641c9d2ba8430c92df9c49660480f398b133\n    - "brown"\n    - "cow"\n  - Layer 2:\n    - Mod hash: 24255ef5d941493b9978f3aabb0ed07d084ade196d23f463ff058954cbf6e9b6\n    - <curried puzzle>\n      - Layer 1:\n        - Mod hash: 7ee93c7e6fde43b6ac75100244fd294b8247362f22724b2ef0099bf7ab083def\n        - "now"\n\n*** BAD PUZZLE REVEAL\n3c4f5a82fc6548a256f5959430704623fa7ac291f45e1da47e2f91f0e6c30307 vs 0000000000000000000000000000000000000000000000000000000000000000\n********************************************************************************\n\nconsuming coin (0x0000000000000000000000000000000000000000000000000000000000000000 0x3c4f5a82fc6548a256f5959430704623fa7ac291f45e1da47e2f91f0e6c30307 3)\n  with id f61c4154a3541d84bf6ed0f05ac8a062ab08022b48e53daf7f5603fc8eb7ed1f\n\n\nbrun -y main.sym \'(a (q 2 (q . 15) (c (q 2 (q . "hey") (c (q . "now") 1)) 1)) (c (q . "brown") (c (q . "cow") 1)))\' \'((49 0xaa1a1c26055a329817a5759d877a2795f9499b97d6056edde0eea39512f24e8bc874b4471f0501127abb1ea0d9f68ac1 0x0000000000000000000000000000000000000000000000000000000000000000) (q) (51 0x3c4f5a82fc6548a256f5959430704623fa7ac291f45e1da47e2f91f0e6c30307 ()) (51 0x0000000000000000000000000000000000000000000000000000000000000000 1) (51 0x0000000000000000000000000000000000000000000000000000000000000000 2 ("memo" "memo" "memo")) (60 ()) (61 0x0000000000000000000000000000000000000000000000000000000000000000) (61 0x98442bcc931fc4c94a2a1b17dafb8959a867097bd3aa73871ca9cfc8327346b4) (60 "hey") (62 ()) (63 0x0000000000000000000000000000000000000000000000000000000000000000) (63 0xfb4c79668bee67977af996dc2f42071735a819b4221d3f5c9e8e9f43c30c2bc5) (62 "hey"))\'\n\n--- Uncurried Args ---\n- <curried puzzle>\n  - Layer 1:\n    - Mod hash: 507414e217dc45d6dbb923077c48641c9d2ba8430c92df9c49660480f398b133\n    - "brown"\n    - "cow"\n  - Layer 2:\n    - Mod hash: 24255ef5d941493b9978f3aabb0ed07d084ade196d23f463ff058954cbf6e9b6\n    - <curried puzzle>\n      - Layer 1:\n        - Mod hash: 7ee93c7e6fde43b6ac75100244fd294b8247362f22724b2ef0099bf7ab083def\n        - "now"\n\n((AGG_SIG_UNSAFE 0xaa1a1c26055a329817a5759d877a2795f9499b97d6056edde0eea39512f24e8bc874b4471f0501127abb1ea0d9f68ac1 0x0000000000000000000000000000000000000000000000000000000000000000) (REMARK) (CREATE_COIN 0x3c4f5a82fc6548a256f5959430704623fa7ac291f45e1da47e2f91f0e6c30307 ()) (CREATE_COIN 0x0000000000000000000000000000000000000000000000000000000000000000 1) (CREATE_COIN 0x0000000000000000000000000000000000000000000000000000000000000000 2 ("memo" "memo" "memo")) (CREATE_COIN_ANNOUNCEMENT ()) (ASSERT_COIN_ANNOUNCEMENT 0x0000000000000000000000000000000000000000000000000000000000000000) (ASSERT_COIN_ANNOUNCEMENT 0x98442bcc931fc4c94a2a1b17dafb8959a867097bd3aa73871ca9cfc8327346b4) (CREATE_COIN_ANNOUNCEMENT "hey") (CREATE_PUZZLE_ANNOUNCEMENT ()) (ASSERT_PUZZLE_ANNOUNCEMENT 0x0000000000000000000000000000000000000000000000000000000000000000) (ASSERT_PUZZLE_ANNOUNCEMENT 0xfb4c79668bee67977af996dc2f42071735a819b4221d3f5c9e8e9f43c30c2bc5) (CREATE_PUZZLE_ANNOUNCEMENT "hey"))\n\ngrouped conditions:\n\n  (AGG_SIG_UNSAFE 0xaa1a1c26055a329817a5759d877a2795f9499b97d6056edde0eea39512f24e8bc874b4471f0501127abb1ea0d9f68ac1 0x0000000000000000000000000000000000000000000000000000000000000000)\n\n  (REMARK)\n\n  (CREATE_COIN 0x3c4f5a82fc6548a256f5959430704623fa7ac291f45e1da47e2f91f0e6c30307 ())\n  (CREATE_COIN 0x0000000000000000000000000000000000000000000000000000000000000000 1)\n  (CREATE_COIN 0x0000000000000000000000000000000000000000000000000000000000000000 2 ("memo" "memo" "memo"))\n\n  (CREATE_COIN_ANNOUNCEMENT ())\n  (CREATE_COIN_ANNOUNCEMENT "hey")\n\n  (ASSERT_COIN_ANNOUNCEMENT 0x0000000000000000000000000000000000000000000000000000000000000000)\n  (ASSERT_COIN_ANNOUNCEMENT 0x98442bcc931fc4c94a2a1b17dafb8959a867097bd3aa73871ca9cfc8327346b4)\n\n  (CREATE_PUZZLE_ANNOUNCEMENT ())\n  (CREATE_PUZZLE_ANNOUNCEMENT "hey")\n\n  (ASSERT_PUZZLE_ANNOUNCEMENT 0x0000000000000000000000000000000000000000000000000000000000000000)\n  (ASSERT_PUZZLE_ANNOUNCEMENT 0xfb4c79668bee67977af996dc2f42071735a819b4221d3f5c9e8e9f43c30c2bc5)\n\n\n-------\nconsuming coin (0xf61c4154a3541d84bf6ed0f05ac8a062ab08022b48e53daf7f5603fc8eb7ed1f 0x3c4f5a82fc6548a256f5959430704623fa7ac291f45e1da47e2f91f0e6c30307 ())\n  with id a6f9255571f8a910057476920a960ae7be70034677303a944b28a47550b9a5e4\n\n\nbrun -y main.sym \'(a (q 2 (q . 15) (c (q 2 (q . "hey") (c (q . "now") 1)) 1)) (c (q . "brown") (c (q . "cow") 1)))\' \'()\'\n\n--- Uncurried Args ---\n- <curried puzzle>\n  - Layer 1:\n    - Mod hash: 507414e217dc45d6dbb923077c48641c9d2ba8430c92df9c49660480f398b133\n    - "brown"\n    - "cow"\n  - Layer 2:\n    - Mod hash: 24255ef5d941493b9978f3aabb0ed07d084ade196d23f463ff058954cbf6e9b6\n    - <curried puzzle>\n      - Layer 1:\n        - Mod hash: 7ee93c7e6fde43b6ac75100244fd294b8247362f22724b2ef0099bf7ab083def\n        - "now"\n\n()\n\n(no output conditions generated)\n\n-------\n\nspent coins\n  (0x0000000000000000000000000000000000000000000000000000000000000000 0x0000000000000000000000000000000000000000000000000000000000000000 ())\n      => spent coin id f5a5fd42d16a20302798ef6ed309979b43003d2320d9f0e8ea9831a92759fb4b\n  (0x0000000000000000000000000000000000000000000000000000000000000000 0x3c4f5a82fc6548a256f5959430704623fa7ac291f45e1da47e2f91f0e6c30307 3)\n      => spent coin id f61c4154a3541d84bf6ed0f05ac8a062ab08022b48e53daf7f5603fc8eb7ed1f\n\ncreated coins\n  (0xf61c4154a3541d84bf6ed0f05ac8a062ab08022b48e53daf7f5603fc8eb7ed1f 0x0000000000000000000000000000000000000000000000000000000000000000 1)\n      => created coin id 041ca97661e2ab59c4d85848092229b00bae000573927b6ab9af4e2becd765c5\n  (0xf61c4154a3541d84bf6ed0f05ac8a062ab08022b48e53daf7f5603fc8eb7ed1f 0x0000000000000000000000000000000000000000000000000000000000000000 2)\n      => created coin id d3f6dc7e6c0a81d22ebebd5559962bab95fa7798ad4b0bcbb42da214215e5e98\n\nephemeral coins\n  (0xf61c4154a3541d84bf6ed0f05ac8a062ab08022b48e53daf7f5603fc8eb7ed1f 0x3c4f5a82fc6548a256f5959430704623fa7ac291f45e1da47e2f91f0e6c30307 ())\n      => created coin id a6f9255571f8a910057476920a960ae7be70034677303a944b28a47550b9a5e4\ncreated coin announcements\n  [\'0xf61c4154a3541d84bf6ed0f05ac8a062ab08022b48e53daf7f5603fc8eb7ed1f\', \'0x686579\'] =>\n      17577cbab71385b4ee009c792f5ed2d954fbd3a31fede834150184519e0ac3fe\n  [\'0xf61c4154a3541d84bf6ed0f05ac8a062ab08022b48e53daf7f5603fc8eb7ed1f\', \'0x\'] =>\n      98442bcc931fc4c94a2a1b17dafb8959a867097bd3aa73871ca9cfc8327346b4\ncreated puzzle announcements\n  [\'0x3c4f5a82fc6548a256f5959430704623fa7ac291f45e1da47e2f91f0e6c30307\', \'0x686579\'] =>\n      73f660046d0c542a49db3410b64f12770fc23707bbf1f082d35d9af71f89edd2\n  [\'0x3c4f5a82fc6548a256f5959430704623fa7ac291f45e1da47e2f91f0e6c30307\', \'0x\'] =>\n      fb4c79668bee67977af996dc2f42071735a819b4221d3f5c9e8e9f43c30c2bc5\n\n\nzero_coin_set = [b\'\\xa6\\xf9%Uq\\xf8\\xa9\\x10\\x05tv\\x92\\n\\x96\\n\\xe7\\xbep\\x03Fw0:\\x94K(\\xa4uP\\xb9\\xa5\\xe4\']\n\ncreated  coin announcements = [\'17577cbab71385b4ee009c792f5ed2d954fbd3a31fede834150184519e0ac3fe\', \'98442bcc931fc4c94a2a1b17dafb8959a867097bd3aa73871ca9cfc8327346b4\']\n\nasserted coin announcements = [\'0000000000000000000000000000000000000000000000000000000000000000\', \'98442bcc931fc4c94a2a1b17dafb8959a867097bd3aa73871ca9cfc8327346b4\']\n\nsymdiff of coin announcements = [\'0000000000000000000000000000000000000000000000000000000000000000\', \'17577cbab71385b4ee009c792f5ed2d954fbd3a31fede834150184519e0ac3fe\']\n\ncreated  puzzle announcements = [\'73f660046d0c542a49db3410b64f12770fc23707bbf1f082d35d9af71f89edd2\', \'fb4c79668bee67977af996dc2f42071735a819b4221d3f5c9e8e9f43c30c2bc5\']\n\nasserted puzzle announcements = [\'0000000000000000000000000000000000000000000000000000000000000000\', \'fb4c79668bee67977af996dc2f42071735a819b4221d3f5c9e8e9f43c30c2bc5\']\n\nsymdiff of puzzle announcements = [\'0000000000000000000000000000000000000000000000000000000000000000\', \'73f660046d0c542a49db3410b64f12770fc23707bbf1f082d35d9af71f89edd2\']\n\n\n================================================================================\n\naggregated signature check pass: True\npks: [<G1Element aa1a1c26055a329817a5759d877a2795f9499b97d6056edde0eea39512f24e8bc874b4471f0501127abb1ea0d9f68ac1>]\nmsgs: [\'0000000000000000000000000000000000000000000000000000000000000000\']\nadd_data: ccd5bb71183532bff220ba46c268991a3ff07eb358e8255a65c30a2dce0e5fbb\nsignature: a458f8f379a4bec00f36cd38e36790210f0b7c4ee772417c0cd20513d75c7505a0532d220ab03a471e9e255e2c54472a03abd31a9feb56d551bf482e31e48747b04fe90f4e3c2af98a2de0d11f869cde360f93b8efa37ec1c28950aa52bfbacd\n'  # noqa
+    )