chia-blockchain 2.5.2rc1__py3-none-any.whl → 2.5.3__py3-none-any.whl

chia/_tests/wallet/dao_wallet/test_dao_clvm.py

@@ -1,1330 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, Optional
-
-import pytest
-from chia_rs import AugSchemeMPL
-from clvm.casts import int_to_bytes
-
-from chia._tests.util.spend_sim import SimClient, SpendSim, sim_and_client
-from chia.types.blockchain_format.coin import Coin
-from chia.types.blockchain_format.program import INFINITE_COST, 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.types.mempool_inclusion_status import MempoolInclusionStatus
-from chia.util.condition_tools import conditions_dict_for_solution
-from chia.util.errors import Err
-from chia.util.hash import std_hash
-from chia.util.ints import uint32, uint64
-from chia.wallet.cat_wallet.cat_utils import CAT_MOD
-from chia.wallet.dao_wallet.dao_info import DAORules
-from chia.wallet.dao_wallet.dao_utils import curry_singleton, get_p2_singleton_puzhash, get_treasury_puzzle
-from chia.wallet.puzzles.load_clvm import load_clvm
-from chia.wallet.singleton import create_singleton_puzzle_hash
-from chia.wallet.wallet_spend_bundle import WalletSpendBundle
-
-CAT_MOD_HASH: bytes32 = CAT_MOD.get_tree_hash()
-SINGLETON_MOD: Program = load_clvm("singleton_top_layer_v1_1.clsp")
-SINGLETON_MOD_HASH: bytes32 = SINGLETON_MOD.get_tree_hash()
-SINGLETON_LAUNCHER: Program = load_clvm("singleton_launcher.clsp")
-SINGLETON_LAUNCHER_HASH: bytes32 = SINGLETON_LAUNCHER.get_tree_hash()
-DAO_LOCKUP_MOD: Program = load_clvm("dao_lockup.clsp")
-DAO_LOCKUP_MOD_HASH: bytes32 = DAO_LOCKUP_MOD.get_tree_hash()
-DAO_PROPOSAL_TIMER_MOD: Program = load_clvm("dao_proposal_timer.clsp")
-DAO_PROPOSAL_TIMER_MOD_HASH: bytes32 = DAO_PROPOSAL_TIMER_MOD.get_tree_hash()
-DAO_PROPOSAL_MOD: Program = load_clvm("dao_proposal.clsp")
-DAO_PROPOSAL_MOD_HASH: bytes32 = DAO_PROPOSAL_MOD.get_tree_hash()
-DAO_PROPOSAL_VALIDATOR_MOD: Program = load_clvm("dao_proposal_validator.clsp")
-DAO_PROPOSAL_VALIDATOR_MOD_HASH: bytes32 = DAO_PROPOSAL_VALIDATOR_MOD.get_tree_hash()
-DAO_TREASURY_MOD: Program = load_clvm("dao_treasury.clsp")
-DAO_TREASURY_MOD_HASH: bytes32 = DAO_TREASURY_MOD.get_tree_hash()
-SPEND_P2_SINGLETON_MOD: Program = load_clvm("dao_spend_p2_singleton_v2.clsp")
-SPEND_P2_SINGLETON_MOD_HASH: bytes32 = SPEND_P2_SINGLETON_MOD.get_tree_hash()
-DAO_FINISHED_STATE: Program = load_clvm("dao_finished_state.clsp")
-DAO_FINISHED_STATE_HASH: bytes32 = DAO_FINISHED_STATE.get_tree_hash()
-DAO_CAT_TAIL: Program = load_clvm(
-    "genesis_by_coin_id_or_singleton.clsp", package_or_requirement="chia.wallet.cat_wallet.puzzles"
-)
-DAO_CAT_TAIL_HASH: bytes32 = DAO_CAT_TAIL.get_tree_hash()
-P2_SINGLETON_MOD: Program = load_clvm("p2_singleton_via_delegated_puzzle.clsp")
-P2_SINGLETON_MOD_HASH: bytes32 = P2_SINGLETON_MOD.get_tree_hash()
-P2_SINGLETON_AGGREGATOR_MOD: Program = load_clvm("p2_singleton_aggregator.clsp")
-P2_SINGLETON_AGGREGATOR_MOD_HASH: bytes32 = P2_SINGLETON_AGGREGATOR_MOD.get_tree_hash()
-DAO_UPDATE_MOD: Program = load_clvm("dao_update_proposal.clsp")
-DAO_UPDATE_MOD_HASH: bytes32 = DAO_UPDATE_MOD.get_tree_hash()
-
-
-def test_finished_state() -> None:
-    """
-    Once a proposal has closed, it becomes a 'beacon' singleton which announces
-    its proposal ID. This is referred to as the finished state and is used to
-    confirm that a proposal has closed in order to release voting CATs from
-    the lockup puzzle.
-    """
-    proposal_id = Program.to("proposal_id").get_tree_hash()
-    singleton_struct: Program = Program.to(
-        (SINGLETON_MOD.get_tree_hash(), (proposal_id, SINGLETON_LAUNCHER.get_tree_hash()))
-    )
-    finished_inner_puz = DAO_FINISHED_STATE.curry(singleton_struct, DAO_FINISHED_STATE_HASH)
-    finished_full_puz = SINGLETON_MOD.curry(singleton_struct, finished_inner_puz)
-    inner_sol = Program.to([1])
-
-    conds = finished_inner_puz.run(inner_sol).as_python()
-    assert conds[0][1] == finished_full_puz.get_tree_hash()
-    assert conds[2][1] == finished_inner_puz.get_tree_hash()
-
-    lineage = Program.to([proposal_id, finished_inner_puz.get_tree_hash(), 1])
-    full_sol = Program.to([lineage, 1, inner_sol])
-
-    conds = conditions_dict_for_solution(finished_full_puz, full_sol, INFINITE_COST)
-    assert conds[ConditionOpcode.ASSERT_MY_PUZZLEHASH][0].vars[0] == finished_full_puz.get_tree_hash()
-    assert conds[ConditionOpcode.CREATE_COIN][0].vars[0] == finished_full_puz.get_tree_hash()
-
-
-def test_proposal() -> None:
-    """
-    This test covers the three paths for closing a proposal:
-    - Close a passed proposal
-    - Close a failed proposal
-    - Self-destruct a broken proposal
-    """
-    proposal_pass_percentage: uint64 = uint64(5100)
-    CAT_TAIL_HASH = Program.to("tail").get_tree_hash()
-    treasury_id = Program.to("treasury").get_tree_hash()
-    singleton_id = Program.to("singleton_id").get_tree_hash()
-    singleton_struct: Program = Program.to(
-        (SINGLETON_MOD.get_tree_hash(), (singleton_id, SINGLETON_LAUNCHER.get_tree_hash()))
-    )
-    self_destruct_time = 1000  # number of blocks
-    oracle_spend_delay = 10
-    active_votes_list = [0xFADEDDAB]  # are the ids of previously voted on proposals?
-    acs: Program = Program.to(1)
-    acs_ph: bytes32 = acs.get_tree_hash()
-
-    dao_lockup_self = DAO_LOCKUP_MOD.curry(
-        SINGLETON_MOD_HASH,
-        SINGLETON_LAUNCHER_HASH,
-        DAO_FINISHED_STATE_HASH,
-        CAT_MOD_HASH,
-        CAT_TAIL_HASH,
-    )
-
-    proposal_curry_one = DAO_PROPOSAL_MOD.curry(
-        DAO_PROPOSAL_TIMER_MOD_HASH,
-        SINGLETON_MOD_HASH,
-        SINGLETON_LAUNCHER_HASH,
-        CAT_MOD_HASH,
-        DAO_FINISHED_STATE_HASH,
-        DAO_TREASURY_MOD_HASH,
-        dao_lockup_self.get_tree_hash(),
-        CAT_TAIL_HASH,
-        treasury_id,
-    )
-
-    # make a lockup puz for the dao cat
-    lockup_puz = dao_lockup_self.curry(
-        dao_lockup_self.get_tree_hash(),
-        active_votes_list,
-        acs,  # innerpuz
-    )
-
-    dao_cat_puz: Program = CAT_MOD.curry(CAT_MOD_HASH, CAT_TAIL_HASH, lockup_puz)
-    dao_cat_puzhash: bytes32 = dao_cat_puz.get_tree_hash()
-
-    # Test Voting
-    current_yes_votes = 20
-    current_total_votes = 100
-    full_proposal: Program = proposal_curry_one.curry(
-        proposal_curry_one.get_tree_hash(),
-        singleton_id,
-        acs_ph,
-        current_yes_votes,
-        current_total_votes,
-    )
-
-    vote_amount = 10
-    vote_type = 1  # yes vote
-    vote_coin_id = Program.to("vote_coin").get_tree_hash()
-    solution: Program = Program.to(
-        [
-            [vote_amount],  # vote amounts
-            vote_type,  # vote type (yes)
-            [vote_coin_id],  # vote coin ids
-            [active_votes_list],  # previous votes
-            [acs_ph],  # lockup inner puz hash
-            0,  # inner puz reveal
-            0,  # soft close len
-            self_destruct_time,
-            oracle_spend_delay,
-            0,
-            1,
-        ]
-    )
-
-    # Run the proposal and check its conditions
-    conditions = conditions_dict_for_solution(full_proposal, solution, INFINITE_COST)
-
-    # Puzzle Announcement of vote_coin_ids
-    assert bytes32(conditions[ConditionOpcode.CREATE_PUZZLE_ANNOUNCEMENT][0].vars[0]) == vote_coin_id
-
-    # Assert puzzle announcement from dao_cat of proposal_id and all vote details
-    apa_msg = Program.to([singleton_id, vote_amount, vote_type, vote_coin_id]).get_tree_hash()
-    assert conditions[ConditionOpcode.ASSERT_PUZZLE_ANNOUNCEMENT][0].vars[0] == std_hash(dao_cat_puzhash + apa_msg)
-
-    # Check that the proposal recreates itself with updated vote amounts
-    next_proposal: Program = proposal_curry_one.curry(
-        proposal_curry_one.get_tree_hash(),
-        singleton_id,
-        acs_ph,
-        current_yes_votes + vote_amount,
-        current_total_votes + vote_amount,
-    )
-    assert bytes32(conditions[ConditionOpcode.CREATE_COIN][0].vars[0]) == next_proposal.get_tree_hash()
-    assert conditions[ConditionOpcode.CREATE_COIN][0].vars[1] == int_to_bytes(1)
-
-    # Try to vote using multiple coin ids
-    vote_coin_id_1 = Program.to("vote_coin_1").get_tree_hash()
-    vote_coin_id_2 = Program.to("vote_coin_2").get_tree_hash()
-    repeat_solution_1: Program = Program.to(
-        [
-            [vote_amount, 20],  # vote amounts
-            vote_type,  # vote type (yes)
-            [vote_coin_id_1, vote_coin_id_2],  # vote coin ids
-            [active_votes_list, 0],  # previous votes
-            [acs_ph, acs_ph],  # lockup inner puz hash
-            0,  # inner puz reveal
-            0,  # soft close len
-            self_destruct_time,
-            oracle_spend_delay,
-            0,
-            1,
-        ]
-    )
-
-    conds_repeated = conditions_dict_for_solution(full_proposal, repeat_solution_1, INFINITE_COST)
-    assert len(conds_repeated) == 5
-
-    # Try to vote using repeated coin ids
-    repeat_solution_2: Program = Program.to(
-        [
-            [vote_amount, vote_amount, 20],  # vote amounts
-            vote_type,  # vote type (yes)
-            [vote_coin_id_1, vote_coin_id_1, vote_coin_id_2],  # vote coin ids
-            [active_votes_list],  # previous votes
-            [acs_ph],  # lockup inner puz hash
-            0,  # inner puz reveal
-            0,  # soft close len
-            self_destruct_time,
-            oracle_spend_delay,
-            0,
-            1,
-        ]
-    )
-
-    with pytest.raises(ValueError) as e_info:
-        conditions_dict_for_solution(full_proposal, repeat_solution_2, INFINITE_COST)
-    assert "clvm raise" in e_info.value.args[0]
-
-    # Test Launch
-    current_yes_votes = 0
-    current_total_votes = 0
-    launch_proposal: Program = proposal_curry_one.curry(
-        proposal_curry_one.get_tree_hash(),
-        singleton_id,
-        acs_ph,
-        current_yes_votes,
-        current_total_votes,
-    )
-    vote_amount = 10
-    vote_type = 1  # yes vote
-    vote_coin_id = Program.to("vote_coin").get_tree_hash()
-    solution = Program.to(
-        [
-            [vote_amount],  # vote amounts
-            vote_type,  # vote type (yes)
-            [vote_coin_id],  # vote coin ids
-            # TODO: Check whether previous votes should be 0 in the first spend since
-            # proposal looks at (f previous_votes) during loop_over_vote_coins
-            [0],  # previous votes
-            [acs_ph],  # lockup inner puz hash
-            acs,  # inner puz reveal
-            0,  # soft close len
-            self_destruct_time,
-            oracle_spend_delay,
-            0,
-            1,
-        ]
-    )
-    # Run the proposal and check its conditions
-    conditions = conditions_dict_for_solution(launch_proposal, solution, INFINITE_COST)
-    # check that the timer is created
-    timer_puz = DAO_PROPOSAL_TIMER_MOD.curry(
-        proposal_curry_one.get_tree_hash(),
-        singleton_struct,
-    )
-    timer_puzhash = timer_puz.get_tree_hash()
-    assert conditions[ConditionOpcode.CREATE_COIN][1].vars[0] == timer_puzhash
-
-    # Test exits
-
-    # Test attempt to close a passing proposal
-    current_yes_votes = 200
-    current_total_votes = 350
-    full_proposal = proposal_curry_one.curry(
-        proposal_curry_one.get_tree_hash(),
-        singleton_id,
-        acs_ph,
-        current_yes_votes,
-        current_total_votes,
-    )
-    attendance_required = 200
-    proposal_timelock = 20
-    soft_close_length = 5
-    solution = Program.to(
-        [
-            Program.to("validator_hash").get_tree_hash(),
-            0,
-            # Program.to("receiver_hash").get_tree_hash(), # not needed anymore?
-            proposal_timelock,
-            proposal_pass_percentage,
-            attendance_required,
-            0,
-            soft_close_length,
-            self_destruct_time,
-            oracle_spend_delay,
-            0,
-            1,
-        ]
-    )
-
-    conds = conditions_dict_for_solution(full_proposal, solution, INFINITE_COST)
-
-    # make a matching treasury puzzle for the APA
-    treasury_inner: Program = DAO_TREASURY_MOD.curry(
-        DAO_TREASURY_MOD_HASH,
-        Program.to("validator_hash"),
-        proposal_timelock,
-        soft_close_length,
-        attendance_required,
-        proposal_pass_percentage,
-        self_destruct_time,
-        oracle_spend_delay,
-    )
-    treasury: Program = SINGLETON_MOD.curry(
-        Program.to((SINGLETON_MOD_HASH, (treasury_id, SINGLETON_LAUNCHER_HASH))),
-        treasury_inner,
-    )
-    treasury_puzhash = treasury.get_tree_hash()
-    apa_msg_bytes = singleton_id
-
-    timer_apa = std_hash(timer_puzhash + singleton_id)
-    assert conds[ConditionOpcode.ASSERT_PUZZLE_ANNOUNCEMENT][0].vars[0] == timer_apa
-    assert conds[ConditionOpcode.ASSERT_PUZZLE_ANNOUNCEMENT][1].vars[0] == std_hash(treasury_puzhash + apa_msg_bytes)
-
-    # close a failed proposal
-    full_proposal = proposal_curry_one.curry(
-        proposal_curry_one.get_tree_hash(),
-        singleton_id,
-        acs_ph,
-        20,  # failing number of yes votes
-        current_total_votes,
-    )
-    solution = Program.to(
-        [
-            Program.to("validator_hash").get_tree_hash(),
-            0,
-            # Program.to("receiver_hash").get_tree_hash(), # not needed anymore?
-            proposal_timelock,
-            proposal_pass_percentage,
-            attendance_required,
-            0,
-            soft_close_length,
-            self_destruct_time,
-            oracle_spend_delay,
-            0,
-            1,
-        ]
-    )
-    conds = conditions_dict_for_solution(full_proposal, solution, INFINITE_COST)
-    apa_msg_int = int_to_bytes(0)
-    assert conds[ConditionOpcode.ASSERT_PUZZLE_ANNOUNCEMENT][1].vars[0] == std_hash(treasury_puzhash + apa_msg_int)
-    assert conds[ConditionOpcode.ASSERT_PUZZLE_ANNOUNCEMENT][0].vars[0] == timer_apa
-
-    finished_puz = DAO_FINISHED_STATE.curry(singleton_struct, DAO_FINISHED_STATE_HASH)
-    assert conds[ConditionOpcode.CREATE_COIN][0].vars[0] == finished_puz.get_tree_hash()
-
-    # self destruct a proposal
-    attendance_required = 200
-    solution = Program.to(
-        [
-            Program.to("validator_hash").get_tree_hash(),
-            0,
-            # Program.to("receiver_hash").get_tree_hash(), # not needed anymore?
-            proposal_timelock,
-            proposal_pass_percentage,
-            attendance_required,
-            0,
-            soft_close_length,
-            self_destruct_time,
-            oracle_spend_delay,
-            1,
-            1,
-        ]
-    )
-    conds = conditions_dict_for_solution(full_proposal, solution, INFINITE_COST)
-    assert conds[ConditionOpcode.ASSERT_PUZZLE_ANNOUNCEMENT][0].vars[0] == std_hash(treasury_puzhash + apa_msg_int)
-    assert conds[ConditionOpcode.CREATE_COIN][0].vars[0] == finished_puz.get_tree_hash()
-
-
-def test_proposal_timer() -> None:
-    """
-    The timer puzzle is created at the same time as a proposal, and enforces a relative time condition on proposals
-    The closing time is passed in via the timer solution and confirmed via announcement from the proposal.
-    It creates/asserts announcements to pair it with the finishing spend of a proposal.
-    The timer puzzle only has one spend path so there is only one test case for this puzzle.
-    """
-    CAT_TAIL_HASH = Program.to("tail").get_tree_hash()
-    treasury_id = Program.to("treasury").get_tree_hash()
-    singleton_id = Program.to("singleton_id").get_tree_hash()
-    singleton_struct: Program = Program.to(
-        (SINGLETON_MOD.get_tree_hash(), (singleton_id, SINGLETON_LAUNCHER.get_tree_hash()))
-    )
-    dao_lockup_self = DAO_LOCKUP_MOD.curry(
-        SINGLETON_MOD_HASH,
-        SINGLETON_LAUNCHER_HASH,
-        DAO_FINISHED_STATE_HASH,
-        CAT_MOD_HASH,
-        CAT_TAIL_HASH,
-    )
-
-    proposal_curry_one = DAO_PROPOSAL_MOD.curry(
-        DAO_PROPOSAL_TIMER_MOD_HASH,
-        SINGLETON_MOD_HASH,
-        SINGLETON_LAUNCHER_HASH,
-        CAT_MOD_HASH,
-        DAO_FINISHED_STATE_HASH,
-        DAO_TREASURY_MOD_HASH,
-        dao_lockup_self.get_tree_hash(),
-        CAT_TAIL_HASH,
-        treasury_id,
-    )
-
-    proposal_timer_full: Program = DAO_PROPOSAL_TIMER_MOD.curry(
-        proposal_curry_one.get_tree_hash(),
-        singleton_struct,
-    )
-
-    timelock = int_to_bytes(101)
-    parent_parent_id = Program.to("parent_parent").get_tree_hash()
-    parent_amount = 2000
-    solution: Program = Program.to(
-        [
-            140,  # yes votes
-            180,  # total votes
-            Program.to(1).get_tree_hash(),  # proposal innerpuz
-            timelock,
-            parent_parent_id,
-            parent_amount,
-        ]
-    )
-    # run the timer puzzle.
-    conds = conditions_dict_for_solution(proposal_timer_full, solution, INFINITE_COST)
-    assert len(conds) == 4
-
-    # Validate the output conditions
-    # Check the timelock is present
-    assert conds[ConditionOpcode.ASSERT_HEIGHT_RELATIVE][0].vars[0] == timelock
-    # Check the proposal id is announced by the timer puz
-    assert conds[ConditionOpcode.CREATE_PUZZLE_ANNOUNCEMENT][0].vars[0] == singleton_id
-    # Check the proposal puz announces the timelock
-    expected_proposal_puzhash: bytes32 = create_singleton_puzzle_hash(
-        proposal_curry_one.curry(
-            proposal_curry_one.get_tree_hash(), singleton_id, Program.to(1).get_tree_hash(), 140, 180
-        ).get_tree_hash(),
-        singleton_id,
-    )
-    assert conds[ConditionOpcode.ASSERT_PUZZLE_ANNOUNCEMENT][0].vars[0] == std_hash(
-        expected_proposal_puzhash + timelock
-    )
-    # Check the parent is a proposal
-    expected_parent_puzhash: bytes32 = create_singleton_puzzle_hash(
-        proposal_curry_one.curry(
-            proposal_curry_one.get_tree_hash(),
-            singleton_id,
-            Program.to(1).get_tree_hash(),
-            0,
-            0,
-        ).get_tree_hash(),
-        singleton_id,
-    )
-    parent_id = std_hash(parent_parent_id + expected_parent_puzhash + int_to_bytes(parent_amount))
-    assert conds[ConditionOpcode.ASSERT_MY_PARENT_ID][0].vars[0] == parent_id
-
-
-def test_validator() -> None:
-    """
-    The proposal validator is run by the treasury when a passing proposal is closed.
-    Its main purpose is to check that the proposal's vote amounts adehere to
-    the DAO rules contained in the treasury (which are passed in from the
-    treasury as Truth values). It creates a puzzle announcement of the
-    proposal ID, that the proposal itself asserts. It also spends the value
-    held in the proposal to the excess payout puzhash.
-
-    The test cases covered are:
-    - Executing a spend proposal in which the validator executes the spend of a
-      `spend_p2_singleton` coin. This is just a proposal that spends some the treasury
-    - Executing an update proposal that changes the DAO rules.
-    """
-    # Setup the treasury
-    treasury_id = Program.to("treasury_id").get_tree_hash()
-    treasury_struct: Program = Program.to((SINGLETON_MOD_HASH, (treasury_id, SINGLETON_LAUNCHER_HASH)))
-
-    # Setup the proposal
-    proposal_id = Program.to("proposal_id").get_tree_hash()
-    proposal_struct: Program = Program.to((SINGLETON_MOD.get_tree_hash(), (proposal_id, SINGLETON_LAUNCHER_HASH)))
-    CAT_TAIL_HASH = Program.to("tail").get_tree_hash()
-    acs: Program = Program.to(1)
-    acs_ph: bytes32 = acs.get_tree_hash()
-
-    p2_singleton = P2_SINGLETON_MOD.curry(treasury_struct, P2_SINGLETON_AGGREGATOR_MOD)
-    p2_singleton_puzhash = p2_singleton.get_tree_hash()
-    parent_id = Program.to("parent").get_tree_hash()
-    locked_amount = 100000
-    spend_amount = 1100
-    conditions = [[51, 0xDABBAD00, 1000], [51, 0xCAFEF00D, 100]]
-
-    # Setup the validator
-    minimum_amt = 1
-    excess_puzhash = bytes32(b"1" * 32)
-    dao_lockup_self = DAO_LOCKUP_MOD.curry(
-        SINGLETON_MOD_HASH,
-        SINGLETON_LAUNCHER_HASH,
-        DAO_FINISHED_STATE_HASH,
-        CAT_MOD_HASH,
-        CAT_TAIL_HASH,
-    )
-
-    proposal_curry_one = DAO_PROPOSAL_MOD.curry(
-        DAO_PROPOSAL_TIMER_MOD_HASH,
-        SINGLETON_MOD_HASH,
-        SINGLETON_LAUNCHER_HASH,
-        CAT_MOD_HASH,
-        DAO_FINISHED_STATE_HASH,
-        DAO_TREASURY_MOD_HASH,
-        dao_lockup_self.get_tree_hash(),
-        CAT_TAIL_HASH,
-        treasury_id,
-    )
-    proposal_validator = DAO_PROPOSAL_VALIDATOR_MOD.curry(
-        treasury_struct,
-        proposal_curry_one.get_tree_hash(),
-        minimum_amt,
-        excess_puzhash,
-    )
-
-    # Can now create the treasury inner puz
-    treasury_inner = DAO_TREASURY_MOD.curry(
-        DAO_TREASURY_MOD_HASH,
-        proposal_validator,
-        10,  # proposal len
-        5,  # soft close
-        1000,  # attendance
-        5100,  # pass margin
-        20,  # self_destruct len
-        3,  # oracle delay
-    )
-
-    # Setup the spend_p2_singleton (proposal inner puz)
-    spend_p2_singleton = SPEND_P2_SINGLETON_MOD.curry(
-        treasury_struct,
-        CAT_MOD_HASH,
-        conditions,
-        [],
-        p2_singleton_puzhash,  # tailhash conds
-    )
-    spend_p2_singleton_puzhash = spend_p2_singleton.get_tree_hash()
-
-    parent_amt_list = [[parent_id, locked_amount]]
-    cat_parent_amt_list: list[Optional[Any]] = []
-    spend_p2_singleton_solution = Program.to([parent_amt_list, cat_parent_amt_list, treasury_inner.get_tree_hash()])
-
-    output_conds = spend_p2_singleton.run(spend_p2_singleton_solution)
-
-    proposal: Program = proposal_curry_one.curry(
-        proposal_curry_one.get_tree_hash(),
-        proposal_id,
-        spend_p2_singleton_puzhash,
-        950,
-        1200,
-    )
-    full_proposal = SINGLETON_MOD.curry(proposal_struct, proposal)
-    proposal_amt = uint64(10)
-    proposal_coin_id = Coin(parent_id, full_proposal.get_tree_hash(), proposal_amt).name()
-    solution = Program.to(
-        [
-            1000,
-            5100,
-            [proposal_coin_id, spend_p2_singleton_puzhash, 0],
-            [proposal_id, 1200, 950, parent_id, proposal_amt],
-            output_conds,
-        ]
-    )
-
-    conds: Program = proposal_validator.run(solution)
-    assert len(conds.as_python()) == 7 + len(conditions)
-
-    # test update
-    proposal = proposal_curry_one.curry(
-        proposal_curry_one.get_tree_hash(),
-        proposal_id,
-        acs_ph,
-        950,
-        1200,
-    )
-    full_proposal = SINGLETON_MOD.curry(proposal_struct, proposal)
-    proposal_coin_id = Coin(parent_id, full_proposal.get_tree_hash(), proposal_amt).name()
-    solution = Program.to(
-        [
-            1000,
-            5100,
-            [proposal_coin_id, acs_ph, 0],
-            [proposal_id, 1200, 950, parent_id, proposal_amt],
-            [[51, 0xCAFEF00D, spend_amount]],
-        ]
-    )
-    conds = proposal_validator.run(solution)
-    assert len(conds.as_python()) == 3
-
-
-def test_spend_p2_singleton() -> None:
-    # Curried values
-    singleton_id = Program.to("singleton_id").get_tree_hash()
-    singleton_struct: Program = Program.to((SINGLETON_MOD_HASH, (singleton_id, SINGLETON_LAUNCHER_HASH)))
-    p2_singleton_puzhash = P2_SINGLETON_MOD.curry(singleton_struct, P2_SINGLETON_AGGREGATOR_MOD).get_tree_hash()
-    cat_tail_1 = Program.to("cat_tail_1").get_tree_hash()
-    cat_tail_2 = Program.to("cat_tail_2").get_tree_hash()
-    conditions = [[51, 0xCAFEF00D, 100], [51, 0xFEEDBEEF, 200]]
-    list_of_tailhash_conds = [
-        [cat_tail_1, [[51, 0x8BADF00D, 123], [51, 0xF00DF00D, 321]]],
-        [cat_tail_2, [[51, 0x8BADF00D, 123], [51, 0xF00DF00D, 321]]],
-    ]
-
-    # Solution Values
-    xch_parent_amt_list = [[b"x" * 32, 10], [b"y" * 32, 100]]
-    cat_parent_amt_list = [
-        [cat_tail_1, [["b" * 32, 100], [b"c" * 32, 400]]],
-        [cat_tail_2, [[b"e" * 32, 100], [b"f" * 32, 400]]],
-    ]
-    # cat_parent_amt_list = []
-    treasury_inner_puzhash = Program.to("treasury_inner").get_tree_hash()
-
-    # Puzzle
-    spend_p2_puz = SPEND_P2_SINGLETON_MOD.curry(
-        singleton_struct, CAT_MOD_HASH, conditions, list_of_tailhash_conds, p2_singleton_puzhash
-    )
-
-    # Solution
-    spend_p2_sol = Program.to([xch_parent_amt_list, cat_parent_amt_list, treasury_inner_puzhash])
-
-    conds = spend_p2_puz.run(spend_p2_sol)
-    assert conds
-
-    # spend only cats
-    conditions = []
-    list_of_tailhash_conds = [
-        [cat_tail_1, [[51, b"q" * 32, 123], [51, b"w" * 32, 321]]],
-        [cat_tail_2, [[51, b"e" * 32, 123], [51, b"r" * 32, 321]]],
-    ]
-    xch_parent_amt_list = []
-    cat_parent_amt_list = [
-        [cat_tail_1, [[b"b" * 32, 100], [b"c" * 32, 400]]],
-        [cat_tail_2, [[b"e" * 32, 100], [b"f" * 32, 400]]],
-    ]
-    treasury_inner_puzhash = Program.to("treasury_inner").get_tree_hash()
-
-    # Puzzle
-    spend_p2_puz = SPEND_P2_SINGLETON_MOD.curry(
-        singleton_struct, CAT_MOD_HASH, conditions, list_of_tailhash_conds, p2_singleton_puzhash
-    )
-
-    # Solution
-    spend_p2_sol = Program.to([xch_parent_amt_list, cat_parent_amt_list, treasury_inner_puzhash])
-    conds = spend_p2_puz.run(spend_p2_sol)
-    assert conds
-
-    # test deduplicate cat_parent_amount_list
-    cat_parent_amt_list = [
-        [cat_tail_1, [[b"b" * 32, 100], [b"c" * 32, 400], [b"b" * 32, 100], [b"b" * 32, 100]]],
-        [cat_tail_2, [[b"e" * 32, 100], [b"f" * 32, 400], [b"f" * 32, 400], [b"e" * 32, 100]]],
-    ]
-
-    spend_p2_sol = Program.to([xch_parent_amt_list, cat_parent_amt_list, treasury_inner_puzhash])
-    dupe_conds = spend_p2_puz.run(spend_p2_sol)
-    assert dupe_conds == conds
-
-
-def test_merge_p2_singleton() -> None:
-    """
-    The treasury funds are held by `p2_singleton_via_delegated` puzzles.
-    Because a DAO can have a large number of these coins, it's possible to
-    merge them together without requiring a treasury spend.
-    There are two cases tested:
-    - For the merge coins that do not create the single output coin, and
-    - For the coin that does create the output.
-    """
-    # Setup a singleton struct
-    singleton_inner: Program = Program.to(1)
-    singleton_id = Program.to("singleton_id").get_tree_hash()
-    singleton_struct: Program = Program.to((SINGLETON_MOD_HASH, (singleton_id, SINGLETON_LAUNCHER_HASH)))
-
-    # Setup p2_singleton_via_delegated puz
-    my_id = Program.to("my_id").get_tree_hash()
-    p2_singleton = P2_SINGLETON_MOD.curry(singleton_struct, P2_SINGLETON_AGGREGATOR_MOD)
-    my_puzhash = p2_singleton.get_tree_hash()
-
-    # Spend to delegated puz
-    delegated_puz = Program.to(1)
-    delegated_sol = Program.to([[51, 0xCAFEF00D, 300]])
-    solution = Program.to([0, singleton_inner.get_tree_hash(), delegated_puz, delegated_sol, my_id])
-    conds = conditions_dict_for_solution(p2_singleton, solution, INFINITE_COST)
-    apa = std_hash(
-        SINGLETON_MOD.curry(singleton_struct, singleton_inner).get_tree_hash()
-        + Program.to([my_id, delegated_puz.get_tree_hash()]).get_tree_hash()
-    )
-    assert len(conds) == 4
-    assert conds[ConditionOpcode.ASSERT_PUZZLE_ANNOUNCEMENT][0].vars[0] == apa
-    assert conds[ConditionOpcode.CREATE_COIN][0].vars[1] == int_to_bytes(300)
-
-    # Merge Spend (not output creator)
-    output_parent_id = Program.to("output_parent").get_tree_hash()
-    output_coin_amount = uint64(100)
-    aggregator_sol = Program.to([my_id, my_puzhash, 300, 0, [output_parent_id, output_coin_amount]])
-    merge_p2_singleton_sol = Program.to([aggregator_sol, 0, 0, 0, 0])
-    conds = conditions_dict_for_solution(p2_singleton, merge_p2_singleton_sol, INFINITE_COST)
-    assert len(conds) == 5
-    assert conds[ConditionOpcode.ASSERT_MY_PUZZLEHASH][0].vars[0] == my_puzhash
-    assert conds[ConditionOpcode.CREATE_COIN_ANNOUNCEMENT][0].vars[0] == int_to_bytes(0)
-
-    # Merge Spend (output creator)
-    fake_parent_id = Program.to("fake_parent").get_tree_hash()
-    merged_coin_id = Coin(fake_parent_id, my_puzhash, uint64(200)).name()
-    merge_sol = Program.to([[my_id, my_puzhash, 100, [[fake_parent_id, my_puzhash, 200]], 0]])
-    conds = conditions_dict_for_solution(p2_singleton, merge_sol, INFINITE_COST)
-    assert len(conds) == 7
-    assert conds[ConditionOpcode.ASSERT_COIN_ANNOUNCEMENT][0].vars[0] == std_hash(merged_coin_id)
-    assert conds[ConditionOpcode.CREATE_COIN][0].vars[1] == int_to_bytes(300)
-
-    # Test merge and aggregate announcements match up
-    parent_ids = [
-        Program.to("fake_parent_1").get_tree_hash(),
-        Program.to("fake_parent_2").get_tree_hash(),
-        Program.to("fake_parent_3").get_tree_hash(),
-    ]
-    amounts = [uint64(1000), uint64(2000), uint64(3000)]
-    parent_puzhash_amounts = []
-    merge_coin_ids: list[bytes32] = []
-    for pid, amt in zip(parent_ids, amounts):
-        parent_puzhash_amounts.append([pid, my_puzhash, amt])
-        merge_coin_ids.append(Coin(pid, my_puzhash, amt).name())
-
-    output_parent_amount = [output_parent_id, output_coin_amount]
-    output_coin_id = Coin(output_parent_id, my_puzhash, output_coin_amount).name()
-
-    agg_sol = Program.to([[output_coin_id, my_puzhash, output_coin_amount, parent_puzhash_amounts, 0]])
-    agg_conds = conditions_dict_for_solution(p2_singleton, agg_sol, INFINITE_COST)
-    # aggregator coin announces merge coin IDs
-    agg_ccas = [std_hash(output_coin_id + x.vars[0]) for x in agg_conds[ConditionOpcode.CREATE_COIN_ANNOUNCEMENT]]
-    # aggregator coin asserts 0 from merge coins
-    agg_acas = [x.vars[0] for x in agg_conds[ConditionOpcode.ASSERT_COIN_ANNOUNCEMENT]]
-
-    for coin_id, ppa in zip(merge_coin_ids, parent_puzhash_amounts):
-        sol = Program.to([[coin_id, ppa[1], ppa[2], 0, output_parent_amount]])
-        merge_conds = conditions_dict_for_solution(p2_singleton, sol, INFINITE_COST)
-        # merge coin announces 0
-        cca = std_hash(coin_id + merge_conds[ConditionOpcode.CREATE_COIN_ANNOUNCEMENT][0].vars[0])
-        # merge coin asserts my_id from aggregator
-        aca = merge_conds[ConditionOpcode.ASSERT_COIN_ANNOUNCEMENT][0].vars[0]
-        assert aca in agg_ccas
-        assert cca in agg_acas
-        assert merge_conds[ConditionOpcode.ASSERT_MY_COIN_ID][0].vars[0] == coin_id
-
-
-def test_treasury() -> None:
-    """
-    The treasury has two spend paths:
-    - Proposal Path: when a proposal is being closed the treasury spend runs the
-      validator and the actual proposed code (if passed)
-    - Oracle Path: The treasury can make announcements about itself that are
-      used to close invalid proposals
-    """
-    # Setup the treasury
-    treasury_id = Program.to("treasury_id").get_tree_hash()
-    treasury_struct: Program = Program.to((SINGLETON_MOD_HASH, (treasury_id, SINGLETON_LAUNCHER_HASH)))
-    CAT_TAIL_HASH = Program.to("tail").get_tree_hash()
-
-    proposal_id = Program.to("singleton_id").get_tree_hash()
-    proposal_struct: Program = Program.to((SINGLETON_MOD_HASH, (proposal_id, SINGLETON_LAUNCHER_HASH)))
-    p2_singleton = P2_SINGLETON_MOD.curry(treasury_struct, P2_SINGLETON_AGGREGATOR_MOD)
-    p2_singleton_puzhash = p2_singleton.get_tree_hash()
-    parent_id = Program.to("parent").get_tree_hash()
-    locked_amount = 100000
-    oracle_spend_delay = 10
-    self_destruct_time = 1000
-    proposal_length = 40
-    soft_close_length = 5
-    attendance = 1000
-    pass_margin = 5100
-    conditions = [[51, 0xDABBAD00, 1000], [51, 0xCAFEF00D, 100]]
-
-    # Setup the validator
-    minimum_amt = 1
-    excess_puzhash = bytes32(b"1" * 32)
-    dao_lockup_self = DAO_LOCKUP_MOD.curry(
-        SINGLETON_MOD_HASH,
-        SINGLETON_LAUNCHER_HASH,
-        DAO_FINISHED_STATE_HASH,
-        CAT_MOD_HASH,
-        CAT_TAIL_HASH,
-    )
-
-    proposal_curry_one = DAO_PROPOSAL_MOD.curry(
-        DAO_PROPOSAL_TIMER_MOD_HASH,
-        SINGLETON_MOD_HASH,
-        SINGLETON_LAUNCHER_HASH,
-        CAT_MOD_HASH,
-        DAO_FINISHED_STATE_HASH,
-        DAO_TREASURY_MOD_HASH,
-        dao_lockup_self.get_tree_hash(),
-        CAT_TAIL_HASH,
-        treasury_id,
-    )
-    proposal_validator = DAO_PROPOSAL_VALIDATOR_MOD.curry(
-        treasury_struct,
-        proposal_curry_one.get_tree_hash(),
-        minimum_amt,
-        excess_puzhash,
-    )
-
-    # Can now create the treasury inner puz
-    treasury_inner = DAO_TREASURY_MOD.curry(
-        DAO_TREASURY_MOD_HASH,
-        proposal_validator,
-        proposal_length,
-        soft_close_length,
-        attendance,
-        pass_margin,
-        self_destruct_time,
-        oracle_spend_delay,
-    )
-
-    # Setup the spend_p2_singleton (proposal inner puz)
-    spend_p2_singleton = SPEND_P2_SINGLETON_MOD.curry(
-        treasury_struct,
-        CAT_MOD_HASH,
-        conditions,
-        [],
-        p2_singleton_puzhash,  # tailhash conds
-    )
-    spend_p2_singleton_puzhash = spend_p2_singleton.get_tree_hash()
-
-    parent_amt_list = [[parent_id, locked_amount]]
-    cat_parent_amt_list: list[Optional[Any]] = []
-    spend_p2_singleton_solution = Program.to([parent_amt_list, cat_parent_amt_list, treasury_inner.get_tree_hash()])
-
-    proposal: Program = proposal_curry_one.curry(
-        proposal_curry_one.get_tree_hash(),
-        proposal_id,
-        spend_p2_singleton_puzhash,
-        950,
-        1200,
-    )
-    full_proposal = SINGLETON_MOD.curry(proposal_struct, proposal)
-
-    # Oracle spend
-    solution: Program = Program.to([0, 0, 0, 0, 0, treasury_struct])
-    conds: Program = treasury_inner.run(solution)
-    assert len(conds.as_python()) == 3
-
-    # Proposal Spend
-    proposal_amt = uint64(10)
-    proposal_coin_id = Coin(parent_id, full_proposal.get_tree_hash(), proposal_amt).name()
-    solution = Program.to(
-        [
-            [proposal_coin_id, spend_p2_singleton_puzhash, 0, "s"],
-            [proposal_id, 1200, 950, parent_id, proposal_amt],
-            spend_p2_singleton,
-            spend_p2_singleton_solution,
-        ]
-    )
-    conds = treasury_inner.run(solution)
-    assert len(conds.as_python()) == 10 + len(conditions)
-
-
-def test_lockup() -> None:
-    """
-    The lockup puzzle tracks the voting records of DAO CATs. When a proposal is
-    voted on, the proposal ID is added to a list, against which, future votes
-    are checked.
-    This test checks the addition of new votes to the lockup, and that you can't
-    re-vote on a proposal twice.
-    """
-    CAT_TAIL_HASH = Program.to("tail").get_tree_hash()
-
-    INNERPUZ = Program.to(1)
-    previous_votes = [0xFADEDDAB]
-
-    dao_lockup_self = DAO_LOCKUP_MOD.curry(
-        SINGLETON_MOD_HASH,
-        SINGLETON_LAUNCHER_HASH,
-        DAO_FINISHED_STATE_HASH,
-        CAT_MOD_HASH,
-        CAT_TAIL_HASH,
-    )
-
-    full_lockup_puz: Program = dao_lockup_self.curry(
-        dao_lockup_self.get_tree_hash(),
-        previous_votes,
-        INNERPUZ,
-    )
-    my_id = Program.to("my_id").get_tree_hash()
-    lockup_coin_amount = 20
-
-    # Test adding vote
-    new_proposal = 0xBADDADAB
-    new_vote_list = [new_proposal, 0xFADEDDAB]
-    child_puzhash = dao_lockup_self.curry(
-        dao_lockup_self.get_tree_hash(),
-        new_vote_list,
-        INNERPUZ,
-    ).get_tree_hash()
-    message = Program.to([new_proposal, lockup_coin_amount, 1, my_id]).get_tree_hash()
-    generated_conditions = [[51, child_puzhash, lockup_coin_amount], [62, message]]
-    solution: Program = Program.to(
-        [
-            my_id,
-            generated_conditions,
-            20,
-            new_proposal,
-            INNERPUZ.get_tree_hash(),  # fake proposal curry vals
-            1,
-            20,
-            child_puzhash,
-            0,
-        ]
-    )
-    conds: Program = full_lockup_puz.run(solution)
-    assert len(conds.as_python()) == 6
-
-    # Test Re-voting on same proposal fails
-    new_proposal = 0xBADDADAB
-    new_vote_list = [new_proposal, 0xBADDADAB]
-    child_puzhash = dao_lockup_self.curry(
-        dao_lockup_self.get_tree_hash(),
-        new_vote_list,
-        INNERPUZ,
-    ).get_tree_hash()
-    message = Program.to([new_proposal, lockup_coin_amount, 1, my_id]).get_tree_hash()
-    generated_conditions = [[51, child_puzhash, lockup_coin_amount], [62, message]]
-    revote_solution: Program = Program.to(
-        [
-            my_id,
-            generated_conditions,
-            20,
-            new_proposal,
-            INNERPUZ.get_tree_hash(),  # fake proposal curry vals
-            1,
-            20,
-            child_puzhash,
-            0,
-        ]
-    )
-    with pytest.raises(ValueError) as e_info:
-        conds = full_lockup_puz.run(revote_solution)
-    assert "clvm raise" in e_info.value.args[0]
-
-    # Test vote removal
-    solution = Program.to(
-        [
-            0,
-            generated_conditions,
-            20,
-            [0xFADEDDAB],
-            INNERPUZ.get_tree_hash(),
-            0,
-            0,
-            0,
-            0,
-        ]
-    )
-    conds = full_lockup_puz.run(solution)
-    assert len(conds.as_python()) == 3
-
-    new_innerpuz = Program.to("new_inner")
-    new_innerpuzhash = new_innerpuz.get_tree_hash()
-    child_lockup = dao_lockup_self.curry(
-        dao_lockup_self.get_tree_hash(),
-        previous_votes,
-        new_innerpuz,
-    ).get_tree_hash()
-    message = Program.to([0, 0, 0, my_id]).get_tree_hash()
-    spend_conds = [[51, child_lockup, lockup_coin_amount], [62, message]]
-    transfer_sol = Program.to(
-        [
-            my_id,
-            spend_conds,
-            lockup_coin_amount,
-            0,
-            INNERPUZ.get_tree_hash(),  # fake proposal curry vals
-            0,
-            0,
-            INNERPUZ.get_tree_hash(),
-            new_innerpuzhash,
-        ]
-    )
-    conds = full_lockup_puz.run(transfer_sol)
-    assert conds.at("rrrrfrf").as_atom() == child_lockup
-
-
-def test_proposal_lifecycle() -> None:
-    """
-    This test covers the whole lifecycle of a proposal and treasury.
-    Its main function is to check that the announcement pairs between treasury
-    and proposal are accurate.
-    It covers the spend proposal and update proposal types.
-    """
-    proposal_pass_percentage: uint64 = uint64(5100)
-    attendance_required: uint64 = uint64(1000)
-    proposal_timelock: uint64 = uint64(40)
-    soft_close_length: uint64 = uint64(5)
-    self_destruct_time: uint64 = uint64(1000)
-    oracle_spend_delay: uint64 = uint64(10)
-    min_amt: uint64 = uint64(1)
-    CAT_TAIL_HASH = Program.to("tail").get_tree_hash()
-
-    dao_rules = DAORules(
-        proposal_timelock=proposal_timelock,
-        soft_close_length=soft_close_length,
-        attendance_required=attendance_required,
-        pass_percentage=proposal_pass_percentage,
-        self_destruct_length=self_destruct_time,
-        oracle_spend_delay=oracle_spend_delay,
-        proposal_minimum_amount=min_amt,
-    )
-
-    # Setup the treasury
-    treasury_id = Program.to("treasury_id").get_tree_hash()
-    treasury_singleton_struct: Program = Program.to((SINGLETON_MOD_HASH, (treasury_id, SINGLETON_LAUNCHER_HASH)))
-    treasury_amount = 1
-
-    # setup the p2_singleton
-    p2_singleton = P2_SINGLETON_MOD.curry(treasury_singleton_struct, P2_SINGLETON_AGGREGATOR_MOD)
-    p2_singleton_puzhash = p2_singleton.get_tree_hash()
-    parent_id = Program.to("parent").get_tree_hash()
-    locked_amount = 100000
-    conditions = [[51, 0xDABBAD00, 1000], [51, 0xCAFEF00D, 100]]
-
-    excess_puzhash = get_p2_singleton_puzhash(treasury_id)
-    dao_lockup_self = DAO_LOCKUP_MOD.curry(
-        SINGLETON_MOD_HASH,
-        SINGLETON_LAUNCHER_HASH,
-        DAO_FINISHED_STATE_HASH,
-        CAT_MOD_HASH,
-        CAT_TAIL_HASH,
-    )
-
-    proposal_curry_one = DAO_PROPOSAL_MOD.curry(
-        DAO_PROPOSAL_TIMER_MOD_HASH,
-        SINGLETON_MOD_HASH,
-        SINGLETON_LAUNCHER_HASH,
-        CAT_MOD_HASH,
-        DAO_FINISHED_STATE_HASH,
-        DAO_TREASURY_MOD_HASH,
-        dao_lockup_self.get_tree_hash(),
-        CAT_TAIL_HASH,
-        treasury_id,
-    )
-    proposal_validator = DAO_PROPOSAL_VALIDATOR_MOD.curry(
-        treasury_singleton_struct,
-        proposal_curry_one.get_tree_hash(),
-        min_amt,
-        excess_puzhash,
-    )
-
-    treasury_inner_puz: Program = DAO_TREASURY_MOD.curry(
-        DAO_TREASURY_MOD_HASH,
-        proposal_validator,
-        proposal_timelock,
-        soft_close_length,
-        attendance_required,
-        proposal_pass_percentage,
-        self_destruct_time,
-        oracle_spend_delay,
-    )
-    treasury_inner_puzhash = treasury_inner_puz.get_tree_hash()
-
-    calculated_treasury_puzhash = get_treasury_puzzle(dao_rules, treasury_id, CAT_TAIL_HASH).get_tree_hash()
-    assert treasury_inner_puzhash == calculated_treasury_puzhash
-
-    full_treasury_puz = SINGLETON_MOD.curry(treasury_singleton_struct, treasury_inner_puz)
-    full_treasury_puzhash = full_treasury_puz.get_tree_hash()
-
-    # Setup the spend_p2_singleton (proposal inner puz)
-    spend_p2_singleton = SPEND_P2_SINGLETON_MOD.curry(
-        treasury_singleton_struct,
-        CAT_MOD_HASH,
-        conditions,
-        [],
-        p2_singleton_puzhash,  # tailhash conds
-    )
-    spend_p2_singleton_puzhash = spend_p2_singleton.get_tree_hash()
-
-    parent_amt_list = [[parent_id, locked_amount]]
-    cat_parent_amt_list: list[Optional[Any]] = []
-    spend_p2_singleton_solution = Program.to([parent_amt_list, cat_parent_amt_list, treasury_inner_puzhash])
-
-    # Setup Proposal
-    proposal_id = Program.to("proposal_id").get_tree_hash()
-    proposal_singleton_struct: Program = Program.to((SINGLETON_MOD_HASH, (proposal_id, SINGLETON_LAUNCHER_HASH)))
-
-    current_votes = 1200
-    yes_votes = 950
-    proposal: Program = proposal_curry_one.curry(
-        proposal_curry_one.get_tree_hash(),
-        proposal_id,
-        spend_p2_singleton_puzhash,
-        yes_votes,
-        current_votes,
-    )
-    full_proposal: Program = SINGLETON_MOD.curry(proposal_singleton_struct, proposal)
-    full_proposal_puzhash: bytes32 = full_proposal.get_tree_hash()
-    proposal_amt = uint64(11)
-    proposal_coin_id = Coin(parent_id, full_proposal_puzhash, proposal_amt).name()
-
-    treasury_solution: Program = Program.to(
-        [
-            [proposal_coin_id, spend_p2_singleton_puzhash, 0],
-            [proposal_id, current_votes, yes_votes, parent_id, proposal_amt],
-            spend_p2_singleton,
-            spend_p2_singleton_solution,
-        ]
-    )
-
-    proposal_solution = Program.to(
-        [
-            proposal_validator.get_tree_hash(),
-            0,
-            proposal_timelock,
-            proposal_pass_percentage,
-            attendance_required,
-            0,
-            soft_close_length,
-            self_destruct_time,
-            oracle_spend_delay,
-            0,
-            proposal_amt,
-        ]
-    )
-
-    # lineage_proof my_amount inner_solution
-    lineage_proof = [treasury_id, treasury_inner_puzhash, treasury_amount]
-    full_treasury_solution = Program.to([lineage_proof, treasury_amount, treasury_solution])
-    full_proposal_solution = Program.to([lineage_proof, proposal_amt, proposal_solution])
-
-    # Run the puzzles
-    treasury_conds = conditions_dict_for_solution(full_treasury_puz, full_treasury_solution, INFINITE_COST)
-    proposal_conds = conditions_dict_for_solution(full_proposal, full_proposal_solution, INFINITE_COST)
-
-    # Announcements
-    treasury_aca = treasury_conds[ConditionOpcode.ASSERT_COIN_ANNOUNCEMENT][0].vars[0]
-    proposal_cca = proposal_conds[ConditionOpcode.CREATE_COIN_ANNOUNCEMENT][0].vars[0]
-    assert std_hash(proposal_coin_id + proposal_cca) == treasury_aca
-
-    treasury_cpas = [
-        std_hash(full_treasury_puzhash + cond.vars[0])
-        for cond in treasury_conds[ConditionOpcode.CREATE_PUZZLE_ANNOUNCEMENT]
-    ]
-    proposal_apas = [cond.vars[0] for cond in proposal_conds[ConditionOpcode.ASSERT_PUZZLE_ANNOUNCEMENT]]
-    assert treasury_cpas[1] == proposal_apas[1]
-
-    # Test Proposal to update treasury
-    # Set up new treasury params
-    new_proposal_pass_percentage: uint64 = uint64(2500)
-    new_attendance_required: uint64 = uint64(500)
-    new_proposal_timelock: uint64 = uint64(900)
-    new_soft_close_length: uint64 = uint64(10)
-    new_self_destruct_time: uint64 = uint64(1000)
-    new_oracle_spend_delay: uint64 = uint64(20)
-    new_minimum_amount: uint64 = uint64(10)
-    proposal_excess_puzhash: bytes32 = get_p2_singleton_puzhash(treasury_id)
-
-    new_dao_rules = DAORules(
-        proposal_timelock=new_proposal_timelock,
-        soft_close_length=new_soft_close_length,
-        attendance_required=new_attendance_required,
-        pass_percentage=new_proposal_pass_percentage,
-        self_destruct_length=new_self_destruct_time,
-        oracle_spend_delay=new_oracle_spend_delay,
-        proposal_minimum_amount=new_minimum_amount,
-    )
-
-    update_proposal = DAO_UPDATE_MOD.curry(
-        DAO_TREASURY_MOD_HASH,
-        DAO_PROPOSAL_VALIDATOR_MOD_HASH,
-        treasury_singleton_struct,
-        proposal_curry_one.get_tree_hash(),
-        new_minimum_amount,
-        proposal_excess_puzhash,
-        new_proposal_timelock,
-        new_soft_close_length,
-        new_attendance_required,
-        new_proposal_pass_percentage,
-        new_self_destruct_time,
-        new_oracle_spend_delay,
-    )
-    update_proposal_puzhash = update_proposal.get_tree_hash()
-    update_proposal_sol = Program.to([])
-
-    proposal = proposal_curry_one.curry(
-        proposal_curry_one.get_tree_hash(),
-        proposal_id,
-        update_proposal_puzhash,
-        yes_votes,
-        current_votes,
-    )
-    full_proposal = SINGLETON_MOD.curry(proposal_singleton_struct, proposal)
-    full_proposal_puzhash = full_proposal.get_tree_hash()
-    proposal_coin_id = Coin(parent_id, full_proposal_puzhash, proposal_amt).name()
-
-    treasury_solution = Program.to(
-        [
-            [proposal_coin_id, update_proposal_puzhash, 0, "u"],
-            [proposal_id, current_votes, yes_votes, parent_id, proposal_amt],
-            update_proposal,
-            update_proposal_sol,
-        ]
-    )
-
-    proposal_solution = Program.to(
-        [
-            proposal_validator.get_tree_hash(),
-            0,
-            proposal_timelock,
-            proposal_pass_percentage,
-            attendance_required,
-            0,
-            soft_close_length,
-            self_destruct_time,
-            oracle_spend_delay,
-            0,
-            proposal_amt,
-        ]
-    )
-
-    lineage_proof = [treasury_id, treasury_inner_puzhash, treasury_amount]
-    full_treasury_solution = Program.to([lineage_proof, treasury_amount, treasury_solution])
-    full_proposal_solution = Program.to([lineage_proof, proposal_amt, proposal_solution])
-
-    treasury_conds = conditions_dict_for_solution(full_treasury_puz, full_treasury_solution, INFINITE_COST)
-    proposal_conds = conditions_dict_for_solution(full_proposal, full_proposal_solution, INFINITE_COST)
-
-    treasury_aca = treasury_conds[ConditionOpcode.ASSERT_COIN_ANNOUNCEMENT][0].vars[0]
-    proposal_cca = proposal_conds[ConditionOpcode.CREATE_COIN_ANNOUNCEMENT][0].vars[0]
-    assert std_hash(proposal_coin_id + proposal_cca) == treasury_aca
-
-    treasury_cpas = [
-        std_hash(full_treasury_puzhash + cond.vars[0])
-        for cond in treasury_conds[ConditionOpcode.CREATE_PUZZLE_ANNOUNCEMENT]
-    ]
-    proposal_apas = [cond.vars[0] for cond in proposal_conds[ConditionOpcode.ASSERT_PUZZLE_ANNOUNCEMENT]]
-    assert treasury_cpas[1] == proposal_apas[1]
-
-    new_treasury_inner = update_proposal.run(update_proposal_sol).at("frf").as_atom()
-    expected_treasury_inner = get_treasury_puzzle(new_dao_rules, treasury_id, CAT_TAIL_HASH)
-    assert new_treasury_inner == expected_treasury_inner.get_tree_hash()
-
-    expected_treasury_hash = curry_singleton(treasury_id, expected_treasury_inner).get_tree_hash()
-    assert treasury_conds[ConditionOpcode.CREATE_COIN][1].vars[0] == expected_treasury_hash
-
-
-async def do_spend(
-    sim: SpendSim,
-    sim_client: SimClient,
-    coins: list[Coin],
-    puzzles: list[Program],
-    solutions: list[Program],
-) -> tuple[MempoolInclusionStatus, Optional[Err]]:
-    spends = []
-    for coin, puzzle, solution in zip(coins, puzzles, solutions):
-        spends.append(make_spend(coin, puzzle, solution))
-    spend_bundle = WalletSpendBundle(spends, AugSchemeMPL.aggregate([]))
-    result = await sim_client.push_tx(spend_bundle)
-    await sim.farm_block()
-    return result
-
-
-@pytest.mark.anyio
-async def test_singleton_aggregator() -> None:
-    async with sim_and_client() as (sim, sim_client):
-        aggregator = P2_SINGLETON_AGGREGATOR_MOD
-        aggregator_hash = aggregator.get_tree_hash()
-        await sim.farm_block(aggregator_hash)
-        await sim.farm_block(aggregator_hash)
-        for i in range(5):
-            await sim.farm_block()
-
-        coin_records = await sim_client.get_coin_records_by_puzzle_hash(aggregator_hash)
-        coins = [c.coin for c in coin_records]
-
-        output_coin = coins[0]
-        output_sol = Program.to(
-            [
-                output_coin.name(),
-                output_coin.puzzle_hash,
-                output_coin.amount,
-                [[c.parent_coin_info, c.puzzle_hash, c.amount] for c in coins[1:]],
-            ]
-        )
-        merge_sols = [
-            Program.to([c.name(), c.puzzle_hash, c.amount, [], [output_coin.parent_coin_info, output_coin.amount]])
-            for c in coins[1:]
-        ]
-
-        res = await do_spend(sim, sim_client, coins, [aggregator] * 4, [output_sol, *merge_sols])
-        assert res[0] == MempoolInclusionStatus.SUCCESS
-
-        await sim.rewind(uint32(sim.block_height - 1))
-
-        # Spend a merge coin with empty output details
-        output_sol = Program.to(
-            [
-                output_coin.name(),
-                output_coin.puzzle_hash,
-                output_coin.amount,
-                [],
-                [],
-            ]
-        )
-        res = await do_spend(sim, sim_client, [output_coin], [aggregator], [output_sol])
-        assert res[0] == MempoolInclusionStatus.FAILED
-
-        # Try to steal treasury coins with a phoney output
-        acs = Program.to(1)
-        acs_ph = acs.get_tree_hash()
-        await sim.farm_block(acs_ph)
-        bad_coin = (await sim_client.get_coin_records_by_puzzle_hash(acs_ph))[0].coin
-        bad_sol = Program.to(
-            [
-                [ConditionOpcode.CREATE_COIN, acs_ph, sum(c.amount for c in coins)],
-                *[[ConditionOpcode.ASSERT_COIN_ANNOUNCEMENT, std_hash(c.name())] for c in coins],
-                [ConditionOpcode.CREATE_COIN_ANNOUNCEMENT, 0],
-            ]
-        )
-
-        merge_sols = [
-            Program.to([c.name(), c.puzzle_hash, c.amount, [], [bad_coin.parent_coin_info, bad_coin.amount]])
-            for c in coins
-        ]
-
-        res = await do_spend(sim, sim_client, [bad_coin, *coins], [acs] + [aggregator] * 4, [bad_sol, *merge_sols])
-        assert res[0] == MempoolInclusionStatus.FAILED