Add a restriction that forces create coins to a specific destination

Author: Quexington

chia/_tests/clvm/test_restrictions.py

@@ -24,7 +24,7 @@
     UnknownRestriction,
 )
 from chia.wallet.puzzles.custody.restriction_utilities import ValidatorStackRestriction
-from chia.wallet.puzzles.custody.restrictions import Force1of2wRestrictedVariable, Timelock
+from chia.wallet.puzzles.custody.restrictions import FixedCreateCoinDestinations, Force1of2wRestrictedVariable, Timelock
 from chia.wallet.puzzles.load_clvm import load_clvm_maybe_recompile
 from chia.wallet.wallet_spend_bundle import WalletSpendBundle
 
@@ -159,6 +159,77 @@ async def test_timelock_wrapper(cost_logger: CostLogger) -> None:
         assert restriction.memo(0) == Program.to([None])
 
 
+@pytest.mark.anyio
+async def test_fixed_create_coin_wrapper(cost_logger: CostLogger) -> None:
+    async with sim_and_client() as (sim, client):
+        restriction = ValidatorStackRestriction(
+            required_wrappers=[FixedCreateCoinDestinations(allowed_ph=bytes32.zeros)]
+        )
+        pwr = PuzzleWithRestrictions(nonce=0, restrictions=[restriction], puzzle=ACSMember())
+
+        # Farm and find coin
+        await sim.farm_block(pwr.puzzle_hash())
+        coin = (await client.get_coin_records_by_puzzle_hashes([pwr.puzzle_hash()], include_spent_coins=False))[0].coin
+
+        # Attempt to create a coin somewhere else
+        any_old_dpuz = DelegatedPuzzleAndSolution(
+            puzzle=Program.to((1, [CreateCoin(bytes32([1] * 32), uint64(1)).to_program()])), solution=Program.to(None)
+        )
+        wrapped_dpuz = restriction.modify_delegated_puzzle_and_solution(any_old_dpuz, [Program.to(None)])
+        escape_attempt = WalletSpendBundle(
+            [
+                make_spend(
+                    coin,
+                    pwr.puzzle_reveal(),
+                    pwr.solve(
+                        [], [Program.to([any_old_dpuz.puzzle.get_tree_hash()])], Program.to([[1, "bar"]]), any_old_dpuz
+                    ),
+                )
+            ],
+            G2Element(),
+        )
+        result = await client.push_tx(escape_attempt)
+        assert result == (MempoolInclusionStatus.FAILED, Err.GENERATOR_RUNTIME_ERROR)
+
+        # Now send it to the correct place
+        correct_dpuz = DelegatedPuzzleAndSolution(
+            puzzle=Program.to(
+                (1, [CreateCoin(bytes32.zeros, uint64(1)).to_program(), Remark(Program.to("foo")).to_program()])
+            ),
+            solution=Program.to(None),
+        )
+        wrapped_dpuz = restriction.modify_delegated_puzzle_and_solution(correct_dpuz, [Program.to(None)])
+        sb = cost_logger.add_cost(
+            "Minimal puzzle with restrictions w/ fixed create coin wrapper",
+            WalletSpendBundle(
+                [
+                    make_spend(
+                        coin,
+                        pwr.puzzle_reveal(),
+                        pwr.solve(
+                            [],
+                            [Program.to([correct_dpuz.puzzle.get_tree_hash()])],
+                            Program.to([Remark(Program.to("bar")).to_program()]),
+                            wrapped_dpuz,
+                        ),
+                    )
+                ],
+                G2Element(),
+            ),
+        )
+        result = await client.push_tx(sb)
+        assert result == (MempoolInclusionStatus.SUCCESS, None)
+
+        conditions = parse_conditions_non_consensus(
+            run(sb.coin_spends[0].puzzle_reveal, sb.coin_spends[0].solution).as_iter()
+        )
+        assert Remark(Program.to("foo")) in conditions
+        assert Remark(Program.to("bar")) in conditions
+
+        # memo format assertion for coverage sake
+        assert restriction.memo(0) == Program.to([None])
+
+
 @dataclass(frozen=True)
 class SelfDestructRestriction:
     @property

chia/wallet/puzzles/custody/fixed_create_coin_destinations.clsp

@@ -0,0 +1,23 @@
+(mod
+  (
+    ALLOWED_PH
+    Conditions
+  )
+
+  (defconstant CREATE_COIN 51)
+
+  (defun check_conditions (ALLOWED_PH conditions return)
+    (if conditions
+        (if (= (f (f conditions)) CREATE_COIN)
+            (if (= (f (r (f conditions))) ALLOWED_PH)
+                (check_conditions ALLOWED_PH (r conditions) return)
+                (x)
+            )
+            (check_conditions ALLOWED_PH (r conditions) return)
+        )
+        return
+    )
+  )
+
+  (check_conditions ALLOWED_PH Conditions Conditions)
+)

chia/wallet/puzzles/custody/fixed_create_coin_destinations.clsp.hex

@@ -0,0 +1 @@
+ff02ffff01ff02ff06ffff04ff02ffff04ff05ffff04ff0bffff04ff0bff808080808080ffff04ffff01ff33ff02ffff03ff0bffff01ff02ffff03ffff09ff23ff0480ffff01ff02ffff03ffff09ff53ff0580ffff01ff02ff06ffff04ff02ffff04ff05ffff04ff1bffff04ff17ff808080808080ffff01ff088080ff0180ffff01ff02ff06ffff04ff02ffff04ff05ffff04ff1bffff04ff17ff80808080808080ff0180ffff011780ff0180ff018080

chia/wallet/puzzles/custody/restrictions.py

@@ -21,10 +21,14 @@
     RestrictionHint,
     UnknownRestriction,
 )
+from chia.wallet.puzzles.load_clvm import load_clvm_maybe_recompile
 from chia.wallet.util.merkle_tree import hash_an_atom
 
 TIMELOCK_WRAPPER = Program.from_bytes(puzzle_mods.TIMELOCK)
 FORCE_1_OF_2_W_RESTRICTED_VARIABLE = Program.from_bytes(puzzle_mods.FORCE_1_OF_2_W_RESTRICTED_VARIABLE)
+FIXED_CREATE_COIN_DESTINATIONS = load_clvm_maybe_recompile(
+    "fixed_create_coin_destinations.clsp", package_or_requirement="chia.wallet.puzzles.custody"
+)
 
 
 @dataclass(frozen=True)
@@ -45,6 +49,24 @@ def puzzle_hash(self, nonce: int) -> bytes32:
         return self.puzzle(nonce).get_tree_hash()
 
 
+@dataclass(kw_only=True, frozen=True)
+class FixedCreateCoinDestinations:
+    allowed_ph: bytes32
+
+    @property
+    def member_not_dpuz(self) -> bool:
+        return False
+
+    def memo(self, nonce: int) -> Program:
+        return Program.to(None)
+
+    def puzzle(self, nonce: int) -> Program:
+        return FIXED_CREATE_COIN_DESTINATIONS.curry(self.allowed_ph)
+
+    def puzzle_hash(self, nonce: int) -> bytes32:
+        return self.puzzle(nonce).get_tree_hash()
+
+
 @dataclass(kw_only=True, frozen=True)
 class Force1of2wRestrictedVariable:
     left_side_hash: bytes32

chia/wallet/puzzles/deployed_puzzle_hashes.json

@@ -1,5 +1,6 @@
 {
   "conditions_banned": "e7e26a3fc3a8a35e3e9944e8107bf330e107e884afdb8c5003559b3882b6566b",
+  "fixed_create_coin": "9b180c90094b82658705d838a954ad31abeeccf513fcb75b9924caa8d795fd29",
   "self_destruct": "d0dc28ae70b9f9b5d49581a1914ae0844109234a712eda1381846fa358939ffb",
   "test_generator_deserialize": "52add794fc76e89512e4a063c383418bda084c8a78c74055abe80179e4a7832c",
   "test_multiple_generator_input_arguments": "156dafbddc3e1d3bfe1f2a84e48e5e46b287b8358bf65c3c091c93e855fbfc5b"