[LABS-151] Replace NIL with Program.NIL (#20189)

Quexington · web-flow · commit 657b637544b8 · 2025-10-24T11:24:28.000-07:00
Replace `NIL` with `Program.NIL`
diff --git a/chia/_tests/cmds/wallet/test_did.py b/chia/_tests/cmds/wallet/test_did.py
@@ -10,7 +10,7 @@
 
 from chia._tests.cmds.cmd_test_utils import TestRpcClients, TestWalletRpcClient, logType, run_cli_command_and_assert
 from chia._tests.cmds.wallet.test_consts import FINGERPRINT_ARG, STD_TX, STD_UTX, get_bytes32
-from chia.types.blockchain_format.program import NIL, Program
+from chia.types.blockchain_format.program import Program
 from chia.types.signing_mode import SigningMode
 from chia.util.bech32m import encode_puzzle_hash
 from chia.wallet.conditions import Condition, ConditionValidTimes, CreateCoinAnnouncement, CreatePuzzleAnnouncement
@@ -42,7 +42,7 @@
     argnames=["program", "result"],
     argvalues=[
         (Program.to(NIL_TREEHASH), True),
-        (NIL, True),
+        (Program.NIL, True),
         (Program.to(bytes32([1] * 32)), False),
     ],
 )
diff --git a/chia/_tests/wallet/cat_wallet/test_cat_wallet.py b/chia/_tests/wallet/cat_wallet/test_cat_wallet.py
@@ -19,7 +19,7 @@
 from chia._tests.util.time_out_assert import time_out_assert, time_out_assert_not_none
 from chia.simulator.simulator_protocol import ReorgProtocol
 from chia.types.blockchain_format.coin import Coin, coin_as_list
-from chia.types.blockchain_format.program import NIL, Program
+from chia.types.blockchain_format.program import Program
 from chia.types.coin_spend import make_spend
 from chia.util.bech32m import encode_puzzle_hash
 from chia.util.db_wrapper import DBWrapper2
@@ -82,7 +82,9 @@ async def mint_cat(
                 1,
                 [
                     CreateCoin(wrapped_inner_puzzle_hash, amount, memos=[inner_puzzle_hash]).to_program(),
-                    UnknownCondition(opcode=Program.to(51), args=[NIL, Program.to(-113), tail, NIL]).to_program(),
+                    UnknownCondition(
+                        opcode=Program.to(51), args=[Program.NIL, Program.to(-113), tail, Program.NIL]
+                    ).to_program(),
                 ],
             )
         )
@@ -112,7 +114,7 @@ async def mint_cat(
                             cat_addition,
                             tail_hash,
                             eve_inner_puzzle,
-                            NIL,
+                            Program.NIL,
                         )
                     ],
                 )
@@ -1411,7 +1413,7 @@ async def test_cat_change_detection(wallet_environments: WalletTestFramework, wa
     if wallet_type is RCATWallet:
         inner_puzhash = create_revocation_layer(bytes32.zeros, inner_puzhash).get_tree_hash()
     puzzlehash_unhardened = construct_cat_puzzle(
-        CAT_MOD, Program.to(None).get_tree_hash(), inner_puzhash
+        CAT_MOD, Program.NIL.get_tree_hash(), inner_puzhash
     ).get_tree_hash_precalc(inner_puzhash)
     change_derivation = DerivationRecord(
         uint32(0), puzzlehash_unhardened, pubkey_unhardened, WalletType.CAT, uint32(2), False
@@ -1422,7 +1424,7 @@ async def test_cat_change_detection(wallet_environments: WalletTestFramework, wa
         our_puzzle = await action_scope.get_puzzle(wallet.wallet_state_manager)
     cat_puzzle = construct_cat_puzzle(
         CAT_MOD,
-        Program.to(None).get_tree_hash(),
+        Program.NIL.get_tree_hash(),
         Program.to(1),
     )
     addr = encode_puzzle_hash(cat_puzzle.get_tree_hash(), "txch")
@@ -1451,7 +1453,7 @@ async def test_cat_change_detection(wallet_environments: WalletTestFramework, wa
     cat_coin = next(c for c in spend_bundle.additions() if c.amount == cat_amount_0)
     next_coin = Coin(
         cat_coin.name(),
-        construct_cat_puzzle(CAT_MOD, Program.to(None).get_tree_hash(), our_puzzle).get_tree_hash(),
+        construct_cat_puzzle(CAT_MOD, Program.NIL.get_tree_hash(), our_puzzle).get_tree_hash(),
         cat_amount_0,
     )
     eve_spend, _ = await wsm.sign_bundle(
@@ -1478,7 +1480,7 @@ async def test_cat_change_detection(wallet_environments: WalletTestFramework, wa
             ),
             make_spend(
                 next_coin,
-                construct_cat_puzzle(CAT_MOD, Program.to(None).get_tree_hash(), our_puzzle),
+                construct_cat_puzzle(CAT_MOD, Program.NIL.get_tree_hash(), our_puzzle),
                 Program.to(
                     [
                         [
@@ -1660,7 +1662,7 @@ async def test_cat_melt_balance(wallet_environments: WalletTestFramework) -> Non
                         conditions=(
                             UnknownCondition(
                                 opcode=Program.to(51),
-                                args=[Program.to(None), Program.to(-113), Program.to(ACS_TAIL), Program.to(None)],
+                                args=[Program.NIL, Program.to(-113), Program.to(ACS_TAIL), Program.NIL],
                             ),
                         ),
                     ),
diff --git a/chia/_tests/wallet/db_wallet/test_db_graftroot.py b/chia/_tests/wallet/db_wallet/test_db_graftroot.py
@@ -31,7 +31,7 @@
 )
 ACS_PH = ACS.get_tree_hash()
 
-NIL_PH = Program.to(None).get_tree_hash()
+NIL_PH = Program.NIL.get_tree_hash()
 
 
 @pytest.mark.anyio
diff --git a/chia/_tests/wallet/nft_wallet/test_ownership_outer_puzzle.py b/chia/_tests/wallet/nft_wallet/test_ownership_outer_puzzle.py
@@ -16,7 +16,6 @@
 
 def test_ownership_outer_puzzle() -> None:
     ACS = Program.to(1)
-    NIL = Program.to([])
     owner = bytes32.zeros
     # (mod (current_owner conditions solution)
     #     (list current_owner () conditions)
@@ -28,7 +27,7 @@ def test_ownership_outer_puzzle() -> None:
     )
     transfer_program_default: Program = puzzle_for_transfer_program(bytes32([1] * 32), bytes32([2] * 32), uint16(5000))
     ownership_puzzle: Program = puzzle_for_ownership_layer(owner, Program.to(transfer_program), ACS)
-    ownership_puzzle_empty: Program = puzzle_for_ownership_layer(NIL, Program.to(transfer_program), ACS)
+    ownership_puzzle_empty: Program = puzzle_for_ownership_layer(Program.NIL, Program.to(transfer_program), ACS)
     ownership_puzzle_default: Program = puzzle_for_ownership_layer(owner, transfer_program_default, ACS)
     ownership_driver: Optional[PuzzleInfo] = match_puzzle(uncurry_puzzle(ownership_puzzle))
     ownership_driver_empty: Optional[PuzzleInfo] = match_puzzle(uncurry_puzzle(ownership_puzzle_empty))
@@ -41,7 +40,7 @@ def test_ownership_outer_puzzle() -> None:
     assert transfer_program_driver is not None
     assert ownership_driver.type() == "ownership"
     assert ownership_driver["owner"] == owner
-    assert ownership_driver_empty["owner"] == NIL
+    assert ownership_driver_empty["owner"] == Program.NIL
     assert ownership_driver["transfer_program"] == transfer_program
     assert ownership_driver_default["transfer_program"] == transfer_program_driver
     assert transfer_program_driver.type() == "royalty transfer program"
diff --git a/chia/_tests/wallet/rpc/test_wallet_rpc.py b/chia/_tests/wallet/rpc/test_wallet_rpc.py
@@ -3130,7 +3130,7 @@ async def test_cat_spend_run_tail(wallet_rpc_environment: WalletRpcTestEnvironme
     # Send to a CAT with an anyone can spend TAIL
     async with env.wallet_1.wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
         our_ph = await action_scope.get_puzzle_hash(env.wallet_1.wallet.wallet_state_manager)
-    cat_puzzle: Program = construct_cat_puzzle(CAT_MOD, Program.to(None).get_tree_hash(), Program.to(1))
+    cat_puzzle: Program = construct_cat_puzzle(CAT_MOD, Program.NIL.get_tree_hash(), Program.to(1))
     addr = encode_puzzle_hash(
         cat_puzzle.get_tree_hash(),
         "txch",
@@ -3175,7 +3175,7 @@ async def test_cat_spend_run_tail(wallet_rpc_environment: WalletRpcTestEnvironme
     await farm_transaction(full_node_api, wallet_node, eve_spend)
 
     # Make sure we have the CAT
-    res = await client.create_wallet_for_existing_cat(Program.to(None).get_tree_hash())
+    res = await client.create_wallet_for_existing_cat(Program.NIL.get_tree_hash())
     assert res["success"]
     cat_wallet_id = res["wallet_id"]
     await time_out_assert(20, get_confirmed_balance, tx_amount, client, cat_wallet_id)
diff --git a/chia/_tests/wallet/test_conditions.py b/chia/_tests/wallet/test_conditions.py
@@ -285,9 +285,7 @@ class TimelockInfo:
     ],
 )
 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 == parse_timelock_info([UnknownCondition(Program.NIL, []), *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
     )
diff --git a/chia/_tests/wallet/test_debug_spend_bundle.py b/chia/_tests/wallet/test_debug_spend_bundle.py
@@ -50,7 +50,7 @@ def test_debug_spend_bundle(capsys: pytest.CaptureFixture[str]) -> None:
                 make_spend(
                     coin_bad_reveal,
                     ACS,
-                    Program.to(None),
+                    Program.NIL,
                 ),
                 make_spend(
                     coin,
@@ -60,7 +60,7 @@ def test_debug_spend_bundle(capsys: pytest.CaptureFixture[str]) -> None:
                 make_spend(
                     child_coin,
                     ACS,
-                    Program.to(None),
+                    Program.NIL,
                 ),
             ],
             sig,
diff --git a/chia/_tests/wallet/test_signer_protocol.py b/chia/_tests/wallet/test_signer_protocol.py
@@ -135,7 +135,7 @@ async def test_p2dohp_wallet_signer_protocol(wallet_environments: WalletTestFram
     async with wallet.wallet_state_manager.new_action_scope(wallet_environments.tx_config, push=False) as action_scope:
         [coin] = await wallet.select_coins(uint64(0), action_scope)
     puzzle: Program = await wallet.puzzle_for_puzzle_hash(coin.puzzle_hash)
-    delegated_puzzle: Program = Program.to(None)
+    delegated_puzzle: Program = Program.NIL
     delegated_puzzle_hash: bytes32 = delegated_puzzle.get_tree_hash()
     solution: Program = Program.to([None, None, None])
 
diff --git a/chia/_tests/wallet/test_util.py b/chia/_tests/wallet/test_util.py
@@ -106,7 +106,7 @@ def test_list_to_binary_tree() -> None:
 @pytest.mark.parametrize(
     "serializations",
     [
-        (tuple(), Program.to(None), []),
+        (tuple(), Program.NIL, []),
         ((bytes32.zeros,), Program.to([bytes32.zeros]), [LineageProofField.PARENT_NAME]),
         (
             (bytes32.zeros, bytes32.zeros),
@@ -129,7 +129,7 @@ def test_lineage_proof_varargs(serializations: tuple[tuple[Any, ...], Program, l
 @pytest.mark.parametrize(
     "serializations",
     [
-        ({}, Program.to(None), []),
+        ({}, Program.NIL, []),
         ({"parent_name": bytes32.zeros}, Program.to([bytes32.zeros]), [LineageProofField.PARENT_NAME]),
         (
             {"parent_name": bytes32.zeros, "inner_puzzle_hash": bytes32.zeros},
diff --git a/chia/_tests/wallet/vc_wallet/test_cr_outer_puzzle.py b/chia/_tests/wallet/vc_wallet/test_cr_outer_puzzle.py
@@ -22,7 +22,7 @@
 
 def test_cat_outer_puzzle() -> None:
     authorized_providers: list[bytes32] = [bytes32.zeros, bytes32.zeros]
-    proofs_checker: Program = Program.to(None)
+    proofs_checker: Program = Program.NIL
     ACS: Program = Program.to(1)
     cr_puzzle: Program = construct_cr_layer(authorized_providers, proofs_checker, ACS)
     double_cr_puzzle: Program = construct_cr_layer(authorized_providers, proofs_checker, cr_puzzle)
diff --git a/chia/_tests/wallet/vc_wallet/test_vc_lifecycle.py b/chia/_tests/wallet/vc_wallet/test_vc_lifecycle.py
@@ -117,7 +117,7 @@ async def test_covenant_layer(cost_logger: CostLogger) -> None:
                                 inner_puzzle_hash=ACS_PH,
                                 amount=uint64(acs_coin.amount),
                             ),
-                            Program.to(None),
+                            Program.NIL,
                             Program.to([[51, covenant_puzzle_hash, acs_coin.amount]]),
                         ),
                     ),
@@ -139,7 +139,7 @@ async def test_covenant_layer(cost_logger: CostLogger) -> None:
                                 covenant_puzzle,
                                 solve_covenant_layer(
                                     LineageProof(parent_name=parent.parent_coin_info, amount=uint64(parent.amount)),
-                                    Program.to(None),
+                                    Program.NIL,
                                     Program.to([[51, covenant_puzzle_hash, cov.amount]]),
                                 ),
                             ),
@@ -173,7 +173,7 @@ async def test_covenant_layer(cost_logger: CostLogger) -> None:
                                     inner_puzzle_hash=ACS_PH,
                                     amount=uint64(acs_cov.amount),
                                 ),
-                                Program.to(None),
+                                Program.NIL,
                                 Program.to([[51, covenant_puzzle_hash, new_acs_cov.amount]]),
                             ),
                         ),
@@ -335,7 +335,7 @@ async def test_revocation_layer(cost_logger: CostLogger) -> None:
                         p2_either_puzzle,
                         solve_revocation_layer(
                             ACS,
-                            Program.to(None),
+                            Program.NIL,
                             hidden=True,
                         ),
                     )
@@ -616,16 +616,16 @@ async def test_vc_lifecycle(test_syncing: bool, cost_logger: CostLogger) -> None
             dpuz_1, launch_crcat_spend_1, cr_1 = CRCAT.launch(
                 cr_coin_1,
                 CreateCoin(ACS_PH, uint64(cr_coin_1.amount)),
-                Program.to(None),
-                Program.to(None),
+                Program.NIL,
+                Program.NIL,
                 AUTHORIZED_PROVIDERS,
                 proofs_checker.as_program(),
             )
             dpuz_2, launch_crcat_spend_2, cr_2 = CRCAT.launch(
                 cr_coin_2,
                 CreateCoin(ACS_PH, uint64(cr_coin_2.amount)),
-                Program.to(None),
-                Program.to(None),
+                Program.NIL,
+                Program.NIL,
                 AUTHORIZED_PROVIDERS,
                 proofs_checker.as_program(),
             )
@@ -700,7 +700,7 @@ async def test_vc_lifecycle(test_syncing: bool, cost_logger: CostLogger) -> None
                     ),
                 ],
                 NEW_PROOFS if error != "use_malicious_cats" else MALICIOUS_PROOFS,
-                Program.to(None),
+                Program.NIL,
                 launcher_id,
                 vc.launcher_id,
                 vc.wrap_inner_with_backdoor().get_tree_hash(),
diff --git a/chia/_tests/wallet/vc_wallet/test_vc_wallet.py b/chia/_tests/wallet/vc_wallet/test_vc_wallet.py
@@ -55,7 +55,7 @@ async def mint_cr_cat(
     full_node_api: FullNodeSimulator,
     tx_config: TXConfig,
     authorized_providers: list[bytes32] = [],
-    tail: Program = Program.to(None),
+    tail: Program = Program.NIL,
     proofs_checker: ProofsChecker = ProofsChecker(["foo", "bar"]),
 ) -> None:
     async with wallet_0.wallet_state_manager.new_action_scope(tx_config, push=True) as action_scope:
@@ -849,7 +849,7 @@ async def test_cat_wallet_conversion(
 
     # Key point of test: create a normal CAT wallet first, and see if it gets converted to CR-CAT wallet
     await CATWallet.get_or_create_wallet_for_cat(
-        wallet_node_0.wallet_state_manager, wallet_0, Program.to(None).get_tree_hash().hex()
+        wallet_node_0.wallet_state_manager, wallet_0, Program.NIL.get_tree_hash().hex()
     )
 
     did_id = bytes32.zeros
diff --git a/chia/types/blockchain_format/program.py b/chia/types/blockchain_format/program.py
@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import io
-from typing import TYPE_CHECKING, Any, Callable, Optional, TypeVar, Union
+from typing import TYPE_CHECKING, Any, Callable, ClassVar, Optional, TypeVar, Union
 
 from chia_rs import MEMPOOL_MODE, run_chia_program, tree_hash
 from chia_rs.sized_bytes import bytes32
@@ -30,6 +30,8 @@ class Program(SExp):
     A thin wrapper around s-expression data intended to be invoked with "eval".
     """
 
+    NIL: ClassVar[Program]
+
     @classmethod
     def parse(cls, f) -> Self:
         return sexp_from_stream(f, cls.to)
@@ -247,7 +249,7 @@ def _tree_hash(node: SExp, precalculated: set[bytes32]) -> bytes32:
     return bytes32(std_hash(s))
 
 
-NIL = Program.from_bytes(b"\x80")
+Program.NIL = Program.to(None)
 
 
 # real return type is more like Union[T_Program, CastableType] when considering corner and terminal cases
diff --git a/chia/wallet/cat_wallet/cat_wallet.py b/chia/wallet/cat_wallet/cat_wallet.py
@@ -683,7 +683,7 @@ async def generate_unsigned_spendbundle(
                 cat_condition = UnknownCondition(
                     opcode=Program.to(51),
                     args=[
-                        Program.to(None),
+                        Program.NIL,
                         Program.to(-113),
                         tail_reveal,
                         tail_solution,
diff --git a/chia/wallet/conditions.py b/chia/wallet/conditions.py
@@ -245,7 +245,7 @@ def from_program(cls, program: Program) -> Self:
             uint64(program.at("rrf").as_int()),
             (
                 None
-                if potential_memos == Program.to(None)
+                if potential_memos == Program.NIL
                 else [memo.as_atom() for memo in potential_memos.at("f").as_iter()]
             ),
         )
@@ -966,9 +966,7 @@ def to_program(self) -> Program:
 
     @classmethod
     def from_program(cls, program: Program) -> UnknownCondition:
-        return cls(
-            program.at("f"), [] if program.at("r") == Program.to(None) else [p for p in program.at("r").as_iter()]
-        )
+        return cls(program.at("f"), [] if program.at("r") == Program.NIL else [p for p in program.at("r").as_iter()])
 
 
 # Abstractions
diff --git a/chia/wallet/did_wallet/did_info.py b/chia/wallet/did_wallet/did_info.py
@@ -8,15 +8,15 @@
 from chia_rs.sized_ints import uint16, uint64
 
 from chia.types.blockchain_format.coin import Coin
-from chia.types.blockchain_format.program import NIL, Program
+from chia.types.blockchain_format.program import Program
 from chia.util.streamable import Streamable, streamable
 from chia.wallet.lineage_proof import LineageProof
 from chia.wallet.util.curry_and_treehash import NIL_TREEHASH
 
 
 def did_recovery_is_nil(recovery_program: Program) -> bool:
     # cannot use set as not hashable
-    if recovery_program in (NIL, NIL_TREEHASH):  # noqa: PLR6201
+    if recovery_program in (Program.NIL, NIL_TREEHASH):  # noqa: PLR6201
         return True
     else:
         return False
diff --git a/chia/wallet/did_wallet/did_wallet.py b/chia/wallet/did_wallet/did_wallet.py
@@ -381,9 +381,7 @@ async def coin_added(self, coin: Coin, _: uint32, peer: WSChiaConnection, parent
             p2_puzzle, recovery_list_hash, num_verification, singleton_struct, metadata = did_curried_args
             did_data = DIDCoinData(
                 p2_puzzle=p2_puzzle,
-                recovery_list_hash=bytes32(recovery_list_hash.as_atom())
-                if recovery_list_hash != Program.to(None)
-                else None,
+                recovery_list_hash=bytes32(recovery_list_hash.as_atom()) if recovery_list_hash != Program.NIL else None,
                 num_verification=uint16(num_verification.as_int()),
                 singleton_struct=singleton_struct,
                 metadata=metadata,
diff --git a/chia/wallet/nft_wallet/transfer_program_puzzle.py b/chia/wallet/nft_wallet/transfer_program_puzzle.py
@@ -77,4 +77,4 @@ def get_inner_solution(self, constructor: PuzzleInfo, solution: Program) -> Opti
         return None
 
     def solve(self, constructor: PuzzleInfo, solver: Solver, inner_puzzle: Program, inner_solution: Program) -> Program:
-        return Program.to(None)
+        return Program.NIL
diff --git a/chia/wallet/notification_manager.py b/chia/wallet/notification_manager.py
@@ -96,7 +96,7 @@ async def send_new_notification(
         notification_spend = make_spend(
             notification_coin,
             notification_puzzle,
-            Program.to(None),
+            Program.NIL,
         )
         extra_spend_bundle = WalletSpendBundle([notification_spend], G2Element())
         await self.wallet_state_manager.main_wallet.generate_signed_transaction(
diff --git a/chia/wallet/util/compute_hints.py b/chia/wallet/util/compute_hints.py
diff --git a/chia/wallet/vc_wallet/cr_cat_drivers.py b/chia/wallet/vc_wallet/cr_cat_drivers.py
diff --git a/chia/wallet/vc_wallet/cr_cat_wallet.py b/chia/wallet/vc_wallet/cr_cat_wallet.py
diff --git a/chia/wallet/vc_wallet/vc_drivers.py b/chia/wallet/vc_wallet/vc_drivers.py
diff --git a/chia/wallet/vc_wallet/vc_store.py b/chia/wallet/vc_wallet/vc_store.py
diff --git a/chia/wallet/vc_wallet/vc_wallet.py b/chia/wallet/vc_wallet/vc_wallet.py
diff --git a/chia/wallet/wallet_rpc_api.py b/chia/wallet/wallet_rpc_api.py
diff --git a/chia/wallet/wallet_state_manager.py b/chia/wallet/wallet_state_manager.py

Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@`
`31`	`31`	`)`
`32`	`32`	`ACS_PH = ACS.get_tree_hash()`
`33`	`33`
`34`		`-NIL_PH = Program.to(None).get_tree_hash()`
	`34`	`+NIL_PH = Program.NIL.get_tree_hash()`
`35`	`35`
`36`	`36`
`37`	`37`	`@pytest.mark.anyio`
Original file line number	Diff line number	Diff line change
`@@ -285,9 +285,7 @@ class TimelockInfo:`
`285`	`285`	`],`
`286`	`286`	`)`
`287`	`287`	`def test_timelock_parsing(timelock_info: TimelockInfo) -> None:`
`288`		`- assert timelock_info.parsed_info == parse_timelock_info(`
`289`		`- [UnknownCondition(Program.to(None), []), *timelock_info.drivers]`
`290`		`- )`
	`288`	`+ assert timelock_info.parsed_info == parse_timelock_info([UnknownCondition(Program.NIL, []), *timelock_info.drivers])`
`291`	`289`	`assert timelock_info.parsed_info.to_conditions() == (`
`292`	`290`	`timelock_info.conditions_after if timelock_info.conditions_after is not None else timelock_info.drivers`
`293`	`291`	`)`
Original file line number	Diff line number	Diff line change
`@@ -106,7 +106,7 @@ def test_list_to_binary_tree() -> None:`
`106`	`106`	`@pytest.mark.parametrize(`
`107`	`107`	`"serializations",`
`108`	`108`	`[`
`109`		`- (tuple(), Program.to(None), []),`
	`109`	`+ (tuple(), Program.NIL, []),`
`110`	`110`	`((bytes32.zeros,), Program.to([bytes32.zeros]), [LineageProofField.PARENT_NAME]),`
`111`	`111`	`(`
`112`	`112`	`(bytes32.zeros, bytes32.zeros),`
`@@ -129,7 +129,7 @@ def test_lineage_proof_varargs(serializations: tuple[tuple[Any, ...], Program, l`
`129`	`129`	`@pytest.mark.parametrize(`
`130`	`130`	`"serializations",`
`131`	`131`	`[`
`132`		`- ({}, Program.to(None), []),`
	`132`	`+ ({}, Program.NIL, []),`
`133`	`133`	`({"parent_name": bytes32.zeros}, Program.to([bytes32.zeros]), [LineageProofField.PARENT_NAME]),`
`134`	`134`	`(`
`135`	`135`	`{"parent_name": bytes32.zeros, "inner_puzzle_hash": bytes32.zeros},`